java程序二叉树的深度优先和广度优先遍历

package com.springboot.study.tests.trees;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @Author: guodong
 * @Date: 2021/12/24 17:03
 * @Version: 1.0
 * @Description:
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TreeNode {

    public int val;

    public TreeNode left;

    public TreeNode right;

}

package com.springboot.study.tests.trees;

import java.util.*;

/**
 * @Author: guodong
 * @Date: 2021/12/24 17:05
 * @Version: 1.0
 * @Description:
 */
public class binaryTree {

    public static void main(String[] args) {
        List<Integer> list=new ArrayList<Integer>();
        //构造二叉树
        TreeNode treeNode6=new TreeNode(2,null,null);
        TreeNode treeNode5=new TreeNode(1,null,null);
        TreeNode treeNode4=new TreeNode(7,null,null);
        TreeNode treeNode3=new TreeNode(6,treeNode5,treeNode6);
        TreeNode treeNode2=new TreeNode(5,treeNode4,null);
        TreeNode root=new TreeNode(3,treeNode2,treeNode3);
        list=DFS(root);
        System.out.println("深度优先遍历:"+list);
        list=BFS(root);
        System.out.println("广度优先遍历:"+list);
    }

    /**
     * 深度优先遍历
     * @param root
     * @return
     */
    public static List<Integer> DFS(TreeNode root){
        Stack<TreeNode> stack=new Stack<TreeNode>();
        List<Integer> list=new ArrayList<Integer>();
        if(root==null)
            return list;
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode t=stack.pop();
            if(t.right!=null){ stack.push(t.right); }
            if(t.left!=null){ stack.push(t.left); }
            list.add(t.val);
        }
        return list;
    }

    /**
     * 广度优先遍历
     * @param root
     * @return
     */
    public static List<Integer> BFS(TreeNode root){
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        List<Integer> list=new ArrayList<Integer>();
        if(root==null){return list;}
        queue.add(root);
        while (!queue.isEmpty()){
            TreeNode t=queue.remove();
            if(t.left!=null){ queue.add(t.left); }
            if(t.right!=null){ queue.add(t.right); }
            list.add(t.val);
        }
        return list;
    }


}

1. 图的深度优先遍历是指，从⼀个节点出发，⼀直沿着边向下深⼊去找节点，如果找不到了则返回上⼀层找其他节点
2. 图的⼴度优先遍历只是，从⼀个节点出发，向下先把第⼀层的节点遍历完，再去遍历第⼆层的节点，直到遍历到最后⼀层
二叉树的深度优先遍历的非递归的通用做法是采用栈，广度优先遍历的非递归的通用做法是采用队列。
深度优先遍历：对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。要特别注意的是，二叉树的深度优先遍历比较特殊，可以细分为先序遍历、中序遍历、后序遍历。具体说明如下：
先序遍历：对任一子树，先访问根，然后遍历其左子树，最后遍历其右子树。
中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树。
后序遍历：对任一子树，先遍历其左子树，然后遍历其右子树，最后访问根。
广度优先遍历：又叫层次遍历，从上往下对每一层依次访问，在每一层中，从左往右（也可以从右往左）访问结点，访问完一层就进入下一层，直到没有结点可以访问为止。