二叉树的深度优先遍历及广度优先遍历

• 深度优先用栈, 广度优先用队列

package com.zzk.data;

import java.util.*;

/**
 * @author zzk
 * @Title: DfsAndBfs
 * @Description: 二叉树的深度优先及广度优先
 * @date 2021-12-2 15:00
 */
public class DfsAndBfs {

    private Node root;

    static class Node {
        public Integer key;
        public DfsAndBfs.Node left;
        public DfsAndBfs.Node right;

        public Node(Integer key, Node left, Node right) {
            this.key = key;
            this.left = left;
            this.right = right;
        }
    }

    /**
     * 插入到树中
     */
    public void insert(Integer key) {
        if (null == root) {
            root = new DfsAndBfs.Node(key, null, null);
        } else {
            insert(root, key);
        }
    }

    private void insert(DfsAndBfs.Node node, Integer key) {
        DfsAndBfs.Node targetNode = new DfsAndBfs.Node(key, null, null);
        if (key.compareTo(node.key) < 0) {
            if (null == node.left) {
                node.left = targetNode;
            } else {
                insert(node.left, key);
            }
        } else {
            if (null == node.right) {
                node.right = targetNode;
            } else {
                insert(node.right, key);
            }
        }
    }

    /**
     *          9
     *        /   \
     *       4     10
     *         \
     *           7
     *         /   \
     *        6      8
     */

    //右孩子先入栈,
    public List<Integer> Dfs(){
        return _Dfs(root);
    }

    private List<Integer> _Dfs(Node node){
        List res = new ArrayList();
        Stack<Node> stack = new Stack<>();
        stack.push(node);

        while (!stack.isEmpty()){
            Node pop = stack.pop();
            res.add(pop.key);
            if (null != pop.right) {
                stack.push(pop.right);
            }
            if (null != pop.left) {
                stack.push(pop.left);
            }
        }
        return res;
    }


    public List<Integer> Bfs(){
        return _Bfs(root);
    }

    private List<Integer> _Bfs(Node node){
        List res = new ArrayList();
        Queue<Node> queue = new ArrayDeque<>();
        queue.add(root);

        while (!queue.isEmpty()){
            Node pop = queue.poll();
            res.add(pop.key);
            if (null != pop.left) {
                queue.add(pop.left);
            }
            if (null != pop.right) {
                queue.add(pop.right);
            }
        }
        return res;
    }


    public static void main(String[] args) {
        DfsAndBfs dfsAndBfs = new DfsAndBfs();
        dfsAndBfs.insert(9);
        dfsAndBfs.insert(4);
        dfsAndBfs.insert(10);
        dfsAndBfs.insert(7);
        dfsAndBfs.insert(6);
        dfsAndBfs.insert(8);

        List<Integer> dfs = dfsAndBfs.Dfs();
        for (Integer df : dfs) {
            System.out.print(df + "\t");
        }
        System.out.println("");
        List<Integer> bfs = dfsAndBfs.Bfs();
        for (Integer bf : bfs) {
            System.out.print(bf + "\t");
        }

    }


}