深搜 广搜 代码

参考书中的图6-7 G7遍历，选取点1作为起始，用的邻接矩阵。深搜实现了递归和非递归版本，非递归版本用了栈，注意压入的节点不能立马出栈。后面还要用到，只有在该节点走投无路后才出栈，递归版本比较简单易懂。
广度优先用的queue队列。

public class GraphTraversal {
    public static void bfsMethod(int[][] adjMatrix, int start){
        Queue<Integer> queue = new LinkedList<Integer>();
        int numOfNodes = adjMatrix[start].length;
        int[] isVisited = new int[numOfNodes];
        isVisited[start] = 1;
        queue.add(start);
        int i = 0;
        int element = 0;
        while(!queue.isEmpty()){
            element = queue.remove();
            System.out.print(element+" ");
            i = 0;
            while(i < numOfNodes){
                if(adjMatrix[element][i] == 1 && isVisited[i] == 0){
                    queue.add(i);
                    isVisited[i] = 1;
                }
                i++;
            }
        }
    }

    private static int[] visited;
    public static void dfs(int[][] adjMatrix, int start){
        visited[start] =1;
        System.out.print(start + " ");
        for (int i = adjMatrix[start].length-1; i >= 0; i--) {
            if (adjMatrix[start][i] == 1 && visited[i] == 0){
                dfs(adjMatrix, i);
            }
        }
    }

    public static void dfsMethod(int [][] adjMatrix, int start){
        Stack<Integer> stack = new Stack<Integer>();
        int numOfNodes = adjMatrix[start].length;
        int[] isVisited = new int[numOfNodes];
        stack.push(start);
        isVisited[start] = 1;
        System.out.print(start + " ");
        int element = 0;
        while(!stack.isEmpty()){
            element = stack.peek(); //这里最重要，不能先出栈
            int i =numOfNodes-1;
            for(; i >= 0 ; i--){
                if(adjMatrix[element][i] == 1 && isVisited[i] == 0){
                    stack.push(i);
                    System.out.print(i + " ");
                    isVisited[i] = 1;
                    break;
                }
            }
            if (i == -1){
                stack.pop();
            }
        }
    }

    public static void main(String[] args){

        int numOfNodes = 0;
        int start = 0;//设置起始点
        Scanner scanner = new Scanner(System.in);
        numOfNodes = 7;
        visited = new int[numOfNodes];
        int[][] adjMatrix = { {0,1,1,1,0,0,0},
                {1,0,0,0,1,1,1},
                {1,0,0,0,0,0,1},
                {1,0,0,0,0,0,0},
                {0,1,0,0,0,1,0},
                {0,1,0,0,1,0,0},
                {0,1,1,0,0,0,0}};

        System.out.println("输入图开始遍历的起点(从0开始编号):");
        start = scanner.nextInt();

        System.out.print("广度优先遍历：正确的遍历结果应该是 1 0 4 5 6 2 3");
        System.out.println();
        bfsMethod(adjMatrix, start);

        //按书上从1开始遍历
        System.out.print("\n深度优先遍历: 正确的遍历结果应该是 1 6 2 0 3 5 4");
        System.out.println();
        dfsMethod(adjMatrix, start);

        System.out.println("\n递归版的深度优先遍历");
        dfs(adjMatrix, 1);
        scanner.close();

    }

}

参考文献：
1. 徐孝凯. 数据结构实用教程(Java语言描述)[J]. 计算机教育, 2013, No.192(9):37-37.