diff --git a/README.md b/README.md
index c7dc5aa5bba1afbc05a618946e230510e5bfd2c2..7c746b86f53960d3119d671558e6b29633ff82a6 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@
 
 ### 截止日期
 
-2021.1.6
+2021.1.13
 
 ### 基础
 
diff --git a/bb.txt b/bb.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3fba106992d7b796101735637865a4ef8fe84968
--- /dev/null
+++ b/bb.txt
@@ -0,0 +1,35 @@
+package MatrixExpression;
+
+import MatrixExpression.MyAdjGraphic;
+import MatrixExpression.Weight;
+
+public class MatrixExpression {
+
+    public static void main(String[] args) {
+        
+        int n=5; 
+        int e=5; 
+        
+        MyAdjGraphic g = new MyAdjGraphic(n);
+        Object[] vertices = new Object[]{new Character('A'),new Character('B'),new Character('C'),new Character('D'),new Character('E')};
+        Weight[] weights = new Weight[]{new Weight(0,1,10),new Weight(0,4,20),new Weight(2,1,40),new Weight(1,3,30),new Weight(3,2,50)};
+        try
+        {
+           Weight.createAdjGraphic(g, vertices, n, weights, e);
+           System.out.println("领接矩阵:");
+           g.print();
+           System.out.println("结点的个数："+g.getNumOfVertice());
+           System.out.println("边的个数："+g.getNumOfEdges());
+           g.deleteEdges(0, 4);
+           System.out.println("删除:");
+           g.print();
+           System.out.println("结点的个数："+g.getNumOfVertice());
+           System.out.println("边的个数："+g.getNumOfEdges());
+        }
+        catch(Exception ex)
+        {
+            
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/cc.txt b/cc.txt
new file mode 100644
index 0000000000000000000000000000000000000000..527daf3fabf95de49c7233c1a7dba7d2aae5b40b
--- /dev/null
+++ b/cc.txt
@@ -0,0 +1,97 @@
+package MatrixTable;
+
+
+public class CreateGraph1 {
+    int vlen;
+    int elen; 
+    VertexNode[] vertexNodeList; 
+    EdgeNode edgeNode;
+ 
+  
+    public CreateGraph1(char[] vexs, char[][] edges) {
+        vlen = vexs.length;
+        elen = edges.length;
+ 
+        vertexNodeList = new VertexNode[vlen];
+        for (int i = 0; i < vlen; i++) {
+            vertexNodeList[i] = new VertexNode();
+            vertexNodeList[i].vertex = vexs[i];
+            vertexNodeList[i].firstedge = null;
+        }
+ 
+        for (int i = 0; i < elen; i++) {
+            EdgeNode edgeNode = new EdgeNode();
+            int vi = getPosition(edges[i][0], vexs);
+            int vj = getPosition(edges[i][1], vexs);
+             
+            edgeNode.adjvex = edges[i][1];
+            edgeNode.next = vertexNodeList[vi].firstedge;
+            vertexNodeList[vi].firstedge = edgeNode;
+        }
+    }
+ 
+   
+    private class VertexNode {
+        char vertex; 
+        EdgeNode firstedge; 
+    }
+ 
+   
+    private class EdgeNode {
+        char adjvex; 
+        EdgeNode next; 
+    }
+ 
+
+    private int getPosition(char ch, char[] vexs) {
+        for (int i = 0; i < vlen; i++)
+            if (vexs[i] == ch)
+                return i;
+        return -1;
+    }
+ 
+
+    public void print() {
+        System.out.printf("AdjList:\n");
+        for (int i = 0; i < vlen; i++) {
+            System.out.print(vertexNodeList[i].vertex + "-->");
+            if (vertexNodeList[i].firstedge != null) {
+                EdgeNode mEdgeNode = new EdgeNode();
+                mEdgeNode = vertexNodeList[i].firstedge;
+                System.out.print(mEdgeNode.adjvex);
+                while (mEdgeNode.next != null) {
+                    mEdgeNode = mEdgeNode.next;
+                    System.out.print(mEdgeNode.adjvex);
+                }
+                System.out.print("\n");
+            } else {
+                System.out.print("\n");
+            }
+        }
+    }
+ 
+ 
+    public static void main(String args[]) {
+  
+        char[] vexs = {
+            'A', 'B', 'C', 'D'
+        };
+       
+        char[][] edges = new char[][] {
+            {
+                'A', 'B'
+            }, {
+                'A', 'C'
+            }, {
+                'A', 'D'
+            }, {
+                'B', 'D'
+            }, {
+                'C', 'D'
+            }
+        };
+ 
+        CreateGraph1 listDG = new CreateGraph1(vexs, edges);
+        listDG.print();
+    }
+}
\ No newline at end of file
diff --git a/mm.txt b/mm.txt
new file mode 100644
index 0000000000000000000000000000000000000000..42f4435697eef783ef6ca4ebf88b7b85787ace6c
--- /dev/null
+++ b/mm.txt
@@ -0,0 +1,110 @@
+package MatrixExpression;
+
+import java.util.ArrayList;
+
+public class MyAdjGraphic {
+
+    static final int maxWeight=-1; 
+    ArrayList vertices = new ArrayList();
+    int[][] edges; 
+    int numOfEdges; 
+    
+    public MyAdjGraphic(int n)
+    {
+        edges = new int[n][n];
+        for(int i=0;i<n;i++)
+        {
+            for(int j=0;j<n;j++)
+            {
+                if(i==j) 
+                {
+                   edges[i][j]=0;    
+                }
+                else
+                {
+                   edges[i][j]=maxWeight;
+                }
+            }
+        }
+        numOfEdges = 0;
+    }
+    
+
+    public int getNumOfEdges()
+    {
+        return this.numOfEdges;
+    }
+    
+ 
+    public int getNumOfVertice()
+    {
+        return this.vertices.size();
+    }
+    
+
+    public Object getValueOfVertice(int index)
+    {
+        return this.vertices.get(index);    
+    }
+    
+
+    public int getWeightOfEdges(int v1,int v2) throws Exception
+    {
+       if((v1 < 0 || v1 >= vertices.size())||(v2 < 0||v2 >= vertices.size()))
+       {
+           throw new Exception("v1或者v2参数越界错误！");
+       }
+       return this.edges[v1][v2];
+       
+    }
+    
+
+    public void insertVertice(Object obj)
+    {
+        this.vertices.add(obj);
+    }
+    
+   
+    public void insertEdges(int v1,int v2,int weight) throws Exception
+    {
+        if((v1 < 0 || v1 >= vertices.size())||(v2 < 0||v2 >= vertices.size()))
+        {
+          throw new Exception("v1或者v2参数越界错误！");
+        }
+        
+        this.edges[v1][v2]=weight;
+        this.numOfEdges++;
+    }
+    
+  
+    public void deleteEdges(int v1,int v2) throws Exception
+    {
+        if((v1 < 0 || v1 >= vertices.size())||(v2 < 0||v2 >= vertices.size()))
+        {
+          throw new Exception("v1或者v2参数越界错误！");
+        }
+        if( v1==v2 || this.edges[v1][v2]==maxWeight)//自己到自己的边或者边不存在则不用删除。    
+        {
+            throw new Exception("边不存在！");
+        }
+        
+        this.edges[v1][v2]=maxWeight;
+        this.numOfEdges--;   
+    }
+    
+    
+    public void print()
+    {
+        for(int i=0;i<this.edges.length;i++ )
+        {
+            for(int j=0;j<this.edges[i].length;j++)
+            {
+                System.out.print(edges[i][j]+" ");    
+            }
+            System.out.println();
+        }
+    }
+    
+    
+    
+}
\ No newline at end of file
diff --git a/nn.txt b/nn.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e6be51b8623781d28b45094d7c7dfc5e28ac7583
--- /dev/null
+++ b/nn.txt
@@ -0,0 +1,29 @@
+package MatrixExpression;
+public class Weight {
+	   
+    int row;  
+    int col;  
+    int weight; 
+    
+    Weight(int row,int col,int weight)
+    {
+        this.row = row;
+        this.col = col;
+        this.weight = weight;
+    }
+    
+    public static void createAdjGraphic(MyAdjGraphic g, Object[] vertices, int n,Weight[] weight,int e)
+    throws Exception
+    {
+     
+       for(int i=0;i<n;i++)
+       {
+           g.insertVertice(vertices[i]);
+       }
+     
+       for(int i=0;i<e;i++)
+       {
+           g.insertEdges(weight[i].row, weight[i].col, weight[i].weight);
+       }
+    }
+}
\ No newline at end of file
diff --git a/vv.txt b/vv.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e6be51b8623781d28b45094d7c7dfc5e28ac7583
--- /dev/null
+++ b/vv.txt
@@ -0,0 +1,29 @@
+package MatrixExpression;
+public class Weight {
+	   
+    int row;  
+    int col;  
+    int weight; 
+    
+    Weight(int row,int col,int weight)
+    {
+        this.row = row;
+        this.col = col;
+        this.weight = weight;
+    }
+    
+    public static void createAdjGraphic(MyAdjGraphic g, Object[] vertices, int n,Weight[] weight,int e)
+    throws Exception
+    {
+     
+       for(int i=0;i<n;i++)
+       {
+           g.insertVertice(vertices[i]);
+       }
+     
+       for(int i=0;i<e;i++)
+       {
+           g.insertEdges(weight[i].row, weight[i].col, weight[i].weight);
+       }
+    }
+}
\ No newline at end of file
diff --git a/zz.txt b/zz.txt
new file mode 100644
index 0000000000000000000000000000000000000000..40dad8e5f442d12b7be92ed703a7400e4097d4a1
--- /dev/null
+++ b/zz.txt
@@ -0,0 +1,148 @@
+package Traversal;
+
+public class T {
+    private char[] mVexs;
+    private int[][] mMatrix;
+    public T(char[] vexs, char[][] edges){
+        int vlen=vexs.length;
+        int elen=edges.length;
+        mVexs=new char[vlen];
+        for(int i=0;i<vlen;i++){
+            mVexs[i]=vexs[i];
+        }
+        mMatrix=new int[vlen][vlen];
+        for(int i=0;i<elen;i++){
+ 
+            int pos1=getPos(edges[i][0]);
+            int pos2=getPos(edges[i][1]);
+            mMatrix[pos1][pos2]=1;
+        }
+    }
+    private int getPos(char c) {
+ 
+        for(int i=0;i<mVexs.length;i++){
+            if(mVexs[i]==c){
+                return i;
+            }
+        }return -1;
+    }
+ 
+    private int nextVertex(int i, int w) {
+        for(int j=w+1;j<mVexs.length;j++){
+            if(mMatrix[i][j]==1){
+                return j;
+            }
+        }return -1;
+ 
+    }
+ 
+    private int firstVertex(int i) {
+ 
+        for(int j=0;j<mVexs.length;j++){
+            if(mMatrix[i][j]==1){
+                return j;
+            }
+        }return -1;
+    }
+    
+    public void print(){
+        for(int i=0;i<mMatrix.length;i++){
+            for(int j=0;j<mMatrix[i].length;j++){
+                System.out.print(mMatrix[i][j]+" ");
+            }
+            System.out.println();
+        }
+    }
+    public static void main(String[] args) {
+        
+        char[] vexs = {'A', 'B', 'C', 'D','E','F','G','H','I'};
+        char[][] edges = new char[][]{
+                {'A', 'B'},
+                {'A', 'F'},
+                {'B', 'G'},
+                {'B', 'C'},
+                {'B', 'I'},
+                {'C', 'B'},
+                {'C', 'I'},
+                {'C', 'D'},
+                {'D', 'C'},
+                {'D', 'I'},
+                {'D', 'G'},
+                {'D', 'H'},
+                {'D', 'E'},
+                {'E', 'H'},
+                {'E', 'F'},
+                {'F', 'G'},
+                {'F', 'A'},
+                {'F', 'E'},
+                {'G', 'H'},
+                {'G', 'D'},
+                {'G', 'B'},
+                {'H', 'G'},
+                {'H', 'D'},
+                {'H', 'E'},
+                {'I', 'B'},
+                {'I', 'C'}
+ 
+        };
+        T pG;
+        pG = new T(vexs, edges);
+        pG.print();   
+        pG.DFS();    
+        pG.BFS();
+    }
+	private void BFS() {
+		int head=0;
+        int rear=0;
+        int[] queue=new int[this.mVexs.length];
+        boolean[] visited=new boolean[this.mVexs.length];
+        for (int i = 0; i < mVexs.length; i++){
+            visited[i] = false;
+        }
+        System.out.println("BFS:");
+        for(int i=0;i<mVexs.length;i++){
+            if(visited[i]==false){
+                visited[i]=true;
+                System.out.print(" "+mVexs[i]);
+                queue[rear++]=i;
+            }
+            while(head!=rear){
+                int j=queue[head++];
+                int k=firstVertex(j);
+                while(k>=0){
+                    if(visited[k]==false){
+                        visited[k]=true;
+                        System.out.print(" "+mVexs[k]);
+                        queue[rear++]=k;
+                    }
+                    k=nextVertex(j,k);
+                }
+            }
+        }
+
+		
+	}
+	private void DFS() {
+		boolean[] visited=new boolean[mVexs.length];
+        System.out.println("DFS:");
+        for(int i=0;i<mVexs.length;i++){
+            if(visited[i]==false){
+                DFS(i,visited);
+            }
+        }
+        System.out.println();
+
+	}
+	 private void DFS(int i, boolean[] visited) {
+	        visited[i]=true;
+	        System.out.print(" "+mVexs[i]);
+	        int w=firstVertex(i);//i:A,w:B
+	        while(w>=0){
+	            if(visited[w]==false){
+	                DFS(w,visited);
+	            }
+	            w=nextVertex(i,w);
+	        }
+	        i--;
+	    }
+}
\ No newline at end of file