java实现图算法的深度优先遍历

这里不bb基础了，直接开干

• 本人没有使用java提供的栈，自己建立了一个栈。

public class Graph {

    //节点元素内容
    private char[] vertices;
    //连接的边
    private int[][] adj;
    //节点最大个数
    private int vexnum;
    //判断每个节点是否已经被遍历过
    private boolean[] visited;

    private Stackz stackz;

    /**
     * 初始化
     */
    public Graph(int n) {
        vexnum = n;
        vertices = new char[n];
        adj = new int[n][n];
        visited = new boolean[n];
        for (int i = 0; i < vexnum; i++) {
            for (int j = 0; j < vexnum; j++) {
                adj[i][j] = 0;
            }
        }
        for (int i = 0 ; i < vexnum ; i++){
            visited[i] = false;
        }
        stackz = new Stackz();
    }

    /**
     * 设置节点属性
     * @param vertices
     */
    public void setVertices(char[] vertices){
        this.vertices = vertices;
    }

    /**
     * 设置边
     * @param start
     * @param end
     */
    public void addEdge(int start , int end) {
        adj[start][end] = 1;
        adj[end][start] = 1;
    }

    /**
     * 输出
     * @param i
     */
    public void display(int i){
        System.out.print(vertices[i] + " ");
    }

    /**
     * 返回栈顶节点连通且未走过的节点
     * @param v
     * @param graph
     * @return
     */

    public int getCanVisied(int v,Graph graph){
        for (int i = 0; i < vexnum; i++){
            if (adj[v][i] == 1 && graph.visited[i] == false){
                return i;
            }
        }
        return -1;
    }
    /**
     * dfs深度优先
     * @param graph
     */
    public void dfs(Graph graph){

                graph.visited[0] = true;
                 stackz.push(0);
                 display(stackz.peek());
                 while (stackz.isEmpty() != -1){
                     if ( getCanVisied(stackz.peek(),graph)!=-1){
                         int v = getCanVisied(stackz.peek(),graph);
                         display(v);
                         stackz.push(v);
                         graph.visited[v] =true;

                     }else {
                         stackz.pop();
                     }
                 }
    }

    /**
     * 自己维护的栈
     */
    class Stackz {
            private int sta[];
            private int top ;

            public Stackz(){
                sta = new int[30];
                top = -1;
            }
            public void push(int s){
                sta[++top] = s;
            }

            public int pop(){
                if (top == 0 ){
                    top--;
                    return  -1;
                }else{
                    return --top;
                }
            }
            public int peek(){
                return sta[top];
            }

            public int isEmpty(){
                return top ;
            }

    }

    public static void main(String[] args) {
        Graph graph = new Graph(10);
        char[] ver = {'A', 'B', 'C', 'D', 'E', 'F'};
        //设置节点
        graph.setVertices(ver);
        // 添加边
        graph.addEdge(0, 1);
        graph.addEdge(0, 5);
        graph.addEdge(1, 0);
        graph.addEdge(1, 2);
        graph.addEdge(2, 1);
        graph.addEdge(2, 3);
        graph.addEdge(3, 2);
        graph.addEdge(3, 4);
        graph.addEdge(4, 3);
        graph.addEdge(4, 5);
        graph.addEdge(5, 0);
        graph.addEdge(5, 4);
        System.out.print("深度优先遍历：");
            graph.dfs(graph);
    }
}