图的数据结构及遍历算法

图的邻接矩阵结构：

public class GraphArray<T> {
    private int[][] edges; // 邻接矩阵
    private T[] vertexs; // 顶点
    private int[] visited; // 是否访问
    private int number; // 顶点个数

    public GraphArray(int[][] edges, T[] vertexs) {
        if (edges.length != edges[0].length) {
            throw new RuntimeException("矩阵不符合规范");
        }
        if (edges.length != vertexs.length) {
            throw new RuntimeException("矩阵不符合规范");
        }
        this.edges = edges;
        this.vertexs = vertexs;
        number = edges.length;
        visited = new int[number];
    }
}

深度优先递归算法

// 深度优先递归算法
void DFSTraverse() {
    visited = new int[number];
    for (int i = 0; i < number; i++) {
        if (visited[i] == 0) {
            DFS(i);
        }
    }
}

void DFS(int i) {
    visited[i] = 1;
    System.out.print(vertexs[i] + " ");
    for (int j = 0; j < number; j++) {
        if (visited[j] == 0 && edges[i][j] == 1) {
            DFS(j);
        }
    }
}

深度优先非递归算法：

// 深度优先非递归算法
void depth() {
    Stack<Integer> s = new Stack<Integer>();
    for (int i = 0; i < number; i++) {
        if (visited[i] == 0) {
            // 访问顶点并入栈
            s.add(i);
            visited[i] = 1;
            while (!s.isEmpty()) {
                int j = s.pop();// 栈顶元素出栈
                System.out.print(vertexs[j] + " ");
                for (int k = 0; k < number; k++) {
                    // 栈顶元素的邻接点（未被访问的）
                    if (edges[j][k] == 1 && visited[k] == 0) {
                        // 访问此邻接点并入栈
                        s.add(k);
                        visited[k] = 1;
                    }
                }
            }
        }
    }
}

广度优先算法：

// 广度优先算法
void BFSTraverse() {
    visited = new int[number];
    Queue<Integer> queue = new LinkedList<Integer>();
    for (int i = 0; i < number; i++) {
        if (visited[i] == 0) {
            // 访问顶点并入队
            visited[i] = 1;
            System.out.print(vertexs[i] + " ");
            queue.add(i);
            while (!queue.isEmpty()) {
                int j = queue.poll();// 队头元素出队
                for (int k = 0; k < number; k++) {
                    // 队头元素的邻接点（未被访问）
                    if (edges[j][k] == 1 && visited[k] == 0) {
                        // 访问此邻接点并入队
                        visited[k] = 1;
                        System.out.print(vertexs[k] + " ");
                        queue.add(k);
                    }
                }
            }
        }
    }
}