深度优先和广度优先搜索算法

深度优先和广度优先搜索算法

1、先构建子节点以及子节点构成的二叉树

//定义一个节点，节点连接有左节点和右节点
public class TreeNode {
    public int data;
    public TreeNode lift;
    public TreeNode right;

    public TreeNode(int data) {
        this.data = data;
    }

}
//构建一个二叉树
//先构建一个二叉树
        TreeNode head = new TreeNode(1);
        TreeNode two = new TreeNode(2);
        TreeNode three = new TreeNode(3);
        TreeNode four = new TreeNode(4);
        TreeNode five = new TreeNode(5);
        TreeNode six = new TreeNode(6);
        TreeNode seven = new TreeNode(7);
        head.lift = two;
        head.right = three;
        two.lift = four;
        two.right = five;
        three.lift = six;
        three.right = seven;

2、广度优先：

广度优先使用了队列结构，先将顶点放入队列中，然后在弹出顶点的同时判断该顶点的左节点是否为空，否，则加入队列，再判断该顶点的右节点是否为空，否，则将右节点加入到队列中。此时该顶点的左右节点依次进入队列中，先进先出，再弹出左节点的时候判断其左右节点是否为空，否，则依次加入队列，然后弹出右节点，判断其左右节点。这样依次循环下去，就能一层一层从左到右输出所有节点的信息。

//广度优先
    public static void boardFirstSearch(TreeNode node){
        if (node == null){
            return;
        }
        Queue<TreeNode> myQueue = new LinkedList<>();
        myQueue.add(node);
        while (!myQueue.isEmpty()){
            TreeNode treeNode = myQueue.poll();
            System.out.print(treeNode.data+" ");
            if (treeNode.lift != null){
                myQueue.add(treeNode.lift);
            }
            if (treeNode.right != null){
                myQueue.add(treeNode.right);
            }
        }
    }

3、深度优先：

深度优先使用了栈数据结构，即先进后出。先将顶点压入栈中，然后弹出，由于栈的结构是先进后出，因此需要先判断右边，如果右节点不为空，则入栈，然后判断左节点是否为空，否，则将左节点入栈，然后此时弹出左节点，再判断左节点的右节点、左节点是否为空，依次压入中中。这就导致了每次入栈都是先压入右节点，先弹出左节点。所以出栈的顺序就是先输出栈的最靠左一列的节点信息。

//深度优先
    public static void deepFirstSearch(TreeNode node){
        if (node == null){
            return;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.add(node);
        while (!stack.isEmpty()){
            TreeNode node1 = stack.pop();
            System.out.print(node1.data+" ");
            if (node1.right != null){
                stack.add(node1.right);
            }
            if (node1.lift != null){
                stack.add(node1.lift);
            }
        }
    }

4、代码结果

1 2 3 4 5 6 7 
1 2 4 5 3 6 7 

}
}
}

### 4、代码结果

```java
1 2 3 4 5 6 7 
1 2 4 5 3 6 7 

代码结果的显示：广度优先算法是每一层从左往右依次输出；深度优先算法则是先输出左边一列的节点信息。