DataStructGraphpart1

package graphic;
import queue.*;

public class AdjacencyGraph implements Graph {
    
    private final int MaxValue = 1000;    // for not conjoint
    private int nNode;                  // numbers of node
    private int nEdge;                    // numbers of edge
    private int type;             // type of graphic
    private int[][] adjacency;          // asume the type of element is int
    
    public int MaxValue() {
        return MaxValue;                // return the const MaxValue
    }
    
    public int[][] getArray() {
        return adjacency;                // return adjacency 
    }
    
    public AdjacencyGraph(int nNode, int type) {
        if (type < 1 || type > 3) {
            System.out.print("Initial failed!\n");
            System.exit(1);
        }
        
        this.nNode = nNode;
        nEdge = 0;
        this.type = type;
        this.adjacency = new int[nNode][nNode];
        
        for (int i = 0; i < nNode; i++) {
            for (int j = 0; j < nNode; j++) {
                if (i == j) {
                    adjacency[i][j] = 0;
                } else if (type == 0 || type == 2) {
                    adjacency[i][j] = 0;
                } else {
                    adjacency[i][j] = MaxValue;
                }
            }
        }
    }
    
    @Override
    public void createGraph(EdgeElement[] d) {  
        // TODO Auto-generated method stub
        int i = 0;
        for (; i < d.length; i++) {
            int v1 = d[i].fromVex;
            int v2 = d[i].endVex; 
            verify(v1, v2);
            if (type == 0) {
                adjacency[v1][v2] = adjacency[v2][v1] = 1;
            } else if (type == 1) {
                adjacency[v1][v2] = adjacency[v2][v1] = d[i].weight;
            } else if (type == 2) {
                adjacency[v1][v2] = 1;
            } else {
                adjacency[v1][v2] = d[i].weight;
            }
        }
        nEdge = i;
    }

    @Override
    public int graphType() {
        // TODO Auto-generated method stub
        return type;
    }

    @Override
    public int vertices() {
        // TODO Auto-generated method e
        return nNode;
    }

    @Override
    public int edges() {
        // TODO Auto-generated method stub
        return nEdge;
    }

    @Override
    public boolean find(int i, int j) {
        // TODO Auto-generated method stub
        
        if (adjacency[i][j] != 0 && adjacency[i][j] != MaxValue) {
            return true;
        }
        return false;
    }

    @Override
    public void putEdge(EdgeElement edge) {
        // TODO Auto-generated method stub
        int v1 = edge.fromVex;
        int v2 = edge.endVex;
        verify(v1, v2);
        if (adjacency[v1][v2] == 0 || adjacency[v1][v2] == MaxValue) {
            nEdge++;
        } else {
            System.out.print("the edge is already exits!");
            System.exit(1);
        }
        if (type == 0) {
            adjacency[v1][v2] = adjacency[v2][v1] = 1;
        } else if (type == 1) {
            adjacency[v1][v2] = adjacency[v2][v1] = edge.weight;
        } else if (type == 2) {
            adjacency[v1][v2] = 1;
        } else {
            adjacency[v1][v2] = edge.weight;
        }
    }

    @Override
    public void removeEdge(int i, int j) {
        // TODO Auto-generated method stub
        verify(i, j);
        if (adjacency[i][j] == 0 || adjacency[i][j] == MaxValue) {
            System.out.println("the edge you want to remove is not exits!");
            System.exit(1);
        }
        if (type == 0) {
            adjacency[i][j] = adjacency[j][i] = 0;
        } else if (type == 1) {
            adjacency[i][j] = adjacency[j][i] = MaxValue;
        } else if (type == 2) {
            adjacency[i][j] = 0;
        } else {
            adjacency[i][j] = MaxValue;
        }
        nEdge--;         // do not forget
    }

    @Override
    public int degree(int i) {
        int nDegree = 0;
        if (type < 2) {
            for (int j = 0; j < nNode; j++) {
                if (adjacency[i][j] != 0 || adjacency[i][j] == MaxValue) {
                    nDegree++;
                }
            }
        } else {
            nDegree = inDegree(i) + outDegree(i);
        }
        return nDegree;
    }
    
    @Override
    public int inDegree(int i) {
        // TODO Auto-generated method stub
        verify(i);
        int nDegree = 0;
        if (type < 2) {
            nDegree = -1;
        } else {
            for (int j = 0; j < nNode; j++) {
                if (adjacency[j][i] != 0 && adjacency[j][i] != MaxValue) {
                    nDegree++;
                }
            }
        }
        
        return nDegree;
    }

    @Override
    public int outDegree(int i) {
        // TODO Auto-generated method stub
        verify(i);
        int nDegree = 0;
        if (type < 2) {
            nDegree = -1;
        } else {
            for (int j = 0; j < nNode; j++) {
                if (adjacency[i][j] != 0 && adjacency[i][j] != MaxValue) {
                    nDegree++;
                }
            }
        }
        
        return nDegree;
    }

    @Override
    public void depthFirstSearch(int v) {    // start search from node v
        // TODO Auto-generated method stub
        boolean[] visited = new boolean[nNode];
        for (int i = 0; i < nNode; i++) {
            visited[i] = false;
        }
        dfs(v, visited);
        System.out.println();
    }

    @Override
    public void breadthFirstSearch(int v) {
        // TODO Auto-generated method stub
        boolean[] visited = new boolean[nNode];
        for (int i = 0; i < nNode; i++) {
            visited[i] = false;
        }
        bfs(v, visited);
        System.out.println();
    }
    
    private void dfs(int i, boolean[] visited) {
        System.out.print(i + " ");
        visited[i] = true;
        for (int j = 0; j < nNode; j++) {
            if (adjacency[i][j] != 0 && adjacency[i][j] != MaxValue && !visited[j]) {
                dfs(j, visited);
            }
        }
    }
    
    private void bfs(int i, boolean[] visited) {
        SequenceQueue queue = new SequenceQueue();
        System.out.print(i + " ");
        visited[i] = true;
        queue.add(i);
        
        while (!queue.isEmpty()) {
            int k = (Integer)queue.remove();
            for (int j = 0; j < nNode; j++) {
                if (adjacency[k][j] != 0 && adjacency[k][j] != MaxValue && !visited[j]) {
                    System.out.print(j + " ");
                    visited[j] = true;
                    queue.add(j);
                }
            }
        }
    }
    
    public void output() {
        int i, j;
        System.out.print("V = {");
        for (i = 0; i < nNode-1; i++) {
            System.out.print(i + ", ");
        }
        System.out.println(nNode-1 + "}");
        if (type == 0 || type == 2) {
            for (i = 0; i < nNode; i++) {
                for (j = 0; j < nNode; j++) {
                    if (type == 0) {    // unweighted, undirected
                        if (i < j) {
                            System.out.print("(" + i + ", " + j + "), ");
                        }
                    } else {            // unweighted, directed
                        System.out.print("<" + i + ", " + j + ">, ");
                    }
                }
            }
        } else {
            for (i = 0; i < nNode; i++) {
                for (j = 0; j < nNode; j++) {
                    if (adjacency[i][j] != 0 && adjacency[i][j] != MaxValue) {
                        if (type == 1) {// weighted, undirected
                            System.out.print("(" + i + ", " + j + "), " + adjacency[i][j] + ", ");
                        } else {        // weighted, directed
                            System.out.print("<" + i + ", " + j + ">, " + adjacency[i][j] + ", ");
                        }
                    }
                }
            }
        }
        System.out.println("}");
    }
    
    public void verify(int... args) {        // some refactor
        if (args.length == 1) {
            if (args[0] > nNode-1 || args[0] < 0) {
                System.out.println("the invalid position!");
                System.exit(1);
            }
        } else {
            if (args[0] < 0 || args[0] > nNode-1 || args[1] < 0 || args[1] > nNode-1 || args[0] == args[1]) {
                System.out.println("invalid position!");
                System.exit(1);
            }
        }
    }
    
    public static void main(String[] args) {
        Graph graph = new AdjacencyGraph(5, 3);
        int[][] a = {
                {0, 1, 2}, {0, 2, 3}, {0, 3, 8}, {1, 3, 12}, 
                {2, 0, 6}, {2, 3, 6}, {2, 4, 1}, {3, 4, 4}
        };
        
        EdgeElement[] matrix = new EdgeElement[a.length];
        for (int i = 0; i < matrix.length; i++) {
            matrix[i] = new EdgeElement(a[i][0], a[i][1], a[i][2]);
        }
        
        graph.createGraph(matrix);
        
        System.out.println("the sequence of deep first search start from 0: ");
        graph.depthFirstSearch(0);
        
        System.out.println("the sequence of bread frist search start from 0: ");
        graph.breadthFirstSearch(0);
        
        graph.output();
        
        System.out.println("the degree, indegree & outdegree of 0: ");
        System.out.println(graph.degree(0) + ", " + graph.inDegree(0) + ", " + graph.outDegree(0));
        
        graph.putEdge(new EdgeElement(4, 1, 5));
        
        graph.removeEdge(0, 2);
        
        System.out.println("Is there exits a edge: (2, 3)?" + graph.find(2, 3));
        

        graph.output();
        
        System.out.println("the type of the graph: " + graph.graphType() + "\n" +
                           "the vertices of the graph: " + graph.vertices() + "\n" + 
                           "the edges of the graph: " + graph.edges());
    }
}

 图的边类：

 1 package graphic;
 2 
 3 public class EdgeElement {
 4     int fromVex;
 5     int endVex;
 6     int weight;
 7     
 8     public EdgeElement(int from, int end) {
 9         fromVex = from;
10         endVex = end;
11         weight = 1;
12     }
13     
14     public EdgeElement(int from, int end, int wgt) {
15         fromVex = from;
16         endVex = end;
17         weight = wgt;
18     }
19 }

1 package graphic;
2 
3 public enum GraphType {
4     unweighted_undirected_graph,  // refer to 0
5     weighted_undirected_graph,    // ... 1
6     unweighted_directed_graph,    // ... 2
7     weighted_directed_graph          // ... 3
8 }

 1 package graphic;
 2 
 3 public interface Graph {
 4     
 5     void createGraph(EdgeElement[] d);    // 根据边集数组参数d建立一个图
 6      7     int graphType();                    // 返回图类型
 8     
 9     int vertices();                        // 返回图中顶点数
10     
11     int edges();                        // 返回图中边数 
12     
13     boolean find(int i, int j);            // 查找（i， j）边是否存在
14     
15     void putEdge(EdgeElement thEdge);    // 插入一条边
16     
17     void removeEdge(int i, int j);        // 删除一条(i, j)边
18     
19     int degree(int i);
20     
21     int inDegree(int i);                // 返回顶点i的入度
22     
23     int outDegree(int i);                // 返回顶点i的出度
24     
25     void output();                        // 输出
26     
27     void depthFirstSearch(int v);        // 从v开始深度优先
28     
29     void breadthFirstSearch(int v);        // 从v开始广度优先
30 }

 先贴下源码，下次给注解。。。