Java：深度优先搜索、广度优先搜索

最新推荐文章于 2024-09-08 00:00:00 发布

起个名字好难__

最新推荐文章于 2024-09-08 00:00:00 发布

阅读量137

点赞数

分类专栏：刷题笔记文章标签：二叉树

本文链接：https://blog.csdn.net/qq_35531985/article/details/109693972

版权

刷题笔记专栏收录该内容

12 篇文章 0 订阅

订阅专栏

本文介绍了深度优先搜索（DFS）和广度优先搜索（BFS）两种算法，并通过Java代码展示了它们在二叉树遍历中的实现。DFS包括递归和非递归两种方式，而BFS则使用队列进行节点的层次遍历。这两种算法都是图论和数据结构中重要的搜索策略，适用于多种问题解决。

摘要由CSDN通过智能技术生成

以下图的遍历为例
在这里插入图片描述

广度优先搜索

英文缩写为BFS即Breadth FirstSearch。其过程检验来说是对每一层节点依次访问，访问完一层进入下一层，而且每个节点只能访问一次。在实际实现中，使用队列来进行实现，先往队列中插入左节点再插入右节点，这样出队就是先左后右了。

先将A插入队列中，队列中有元素（A）
将A弹出，得到A结点，然后A的孩子从左至右先后放到队列中，（B,C）。
继续弹出B，得到B结点，然后将B的孩子从左至右先后放入到队列中，（C,D,E）。
然后弹出C，将C的左右孩子依次放入（D,E,F,G,H）。
将D弹出，D没有孩子，队列不新增。（E,F,G,H）

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/

public class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> lists=new ArrayList<Integer>();
        if(root==null)
            return lists;
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode tree=queue.poll();
            if(tree.left!=null)
                queue.offer(tree.left);
            if(tree.right!=null)
                queue.offer(tree.right);
            lists.add(tree.val);
        }
        return lists;
    }
}

深度优先搜索

英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次。对于上面的例子来说深度优先遍历的结果就是：A,B,D,E,I,C,F,G,H.(假设先走子节点的的左侧)。

先往栈中压入右节点，再压左节点，这样出栈就是先左节点后右节点了。

首先将A节点压入栈中，stack（A）;
将A节点弹出，同时将A的子节点C，B压入栈中，此时B在栈的顶部，stack(B,C)
将B节点弹出，同时将B的子节点E，D压入栈中，此时D在栈的顶部，stack（D,E,C）
将D节点弹出，没有子节点压入,此时E在栈的顶部，stack（E，C）
将E节点弹出，同时将E的子节点I压入，stack（I,C）
弹出I，I没有孩子，栈中不新增新的结点，stack（C）
弹出C，C的三个孩子从右往左依次进入栈中，stack（F,G,H）
以此类推…
代码实现(二叉树的，多叉树类似)：
非递归：


/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/

public class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> lists=new ArrayList<Integer>();
        if(root==null)
            return lists;
        Stack<TreeNode> stack=new Stack<TreeNode>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode tree=stack.pop();
　　　　　　//先往栈中压入右节点，再压左节点，这样出栈就是先左节点后右节点了。
            if(tree.right!=null)
                stack.push(tree.right);
            if(tree.left!=null)
                stack.push(tree.left);
            lists.add(tree.val);
        }
        return lists;
    }
}

递归：


	public void depthOrderTraversalWithRecursive()  
    {  
        depthTraversal(root);  
    }  
      
    private void depthTraversal(TreeNode tn)  
    {  
        if (tn!=null)   
        {  
            System.out.print(tn.value+"  ");  
            depthTraversal(tn.left);  
            depthTraversal(tn.right);  
        }         
    }