二叉树的深度优先遍历和广度优先遍历算法

最近在看《漫画算法》，里面有个二叉树的深度优先遍历和广度优先遍历算法，书中没有递归方式实现的广度优先遍历算法，正好今天有空，自己手动实现了一下。

注：深度优先和队列实现的广度优先算法，可以参见书上或者以下链接https://www.jb51.net/article/138495.htm

话不多说，直接上代码

import java.util.ArrayList;
import java.util.List;

public class BinaryTreeTraverseTest {
    public static void main(String[] args) {
        BinarySortTree<Integer> tree = new BinarySortTree<Integer>();
        tree.insertNode(35);
        tree.insertNode(20);
        tree.insertNode(15);
        tree.insertNode(16);
        tree.insertNode(29);
        tree.insertNode(28);
        tree.insertNode(30);
        tree.insertNode(40);
        tree.insertNode(50);
        tree.insertNode(45);
        tree.insertNode(55);
        System.out.print("广度优先遍历-递归法：");
        List list = new ArrayList();
        list.add(tree.getRoot());
        tree.breadthFirstTraverse(list);
    }
}

/** 
 * 节点
 *  */
class Node<E extends Comparable<E>> {
    E value;
    Node<E> left;
    Node<E> right;

    Node(E value) {
        this.value = value;
        left = null;
        right = null;
    }
}

/** 
 * 二叉树
 * */
class BinarySortTree<E extends Comparable<E>> {
    private Node<E> root;

    BinarySortTree() {
        root = null;
    }

    public void insertNode(E value) {
        if (root == null) {
            root = new Node<E>(value);
            return;
        }
        Node<E> currentNode = root;
        while (true) {
            if (value.compareTo(currentNode.value) > 0) {
                if (currentNode.right == null) {
                    currentNode.right = new Node<E>(value);
                    break;
                }
                currentNode = currentNode.right;
            } else {
                if (currentNode.left == null) {
                    currentNode.left = new Node<E>(value);
                    break;
                }
                currentNode = currentNode.left;
            }
        }
    }

    public Node<E> getRoot() {
        return root;
    }

    /**
     * 广度优先算法
     * @param list    
     * */  
    public void breadthFirstTraverse(List<Node<E>> list) {
        if(list.size()==0){
            return;
        }
        Node<E> node = list.get(0);
        if(node.left != null){
            list.add(node.left);
        }
        if(node.right != null){
            list.add(node.right);
        }
        System.out.print(node.value + " ");
        list.remove(0);
        breadthFirstTraverse(list);
    }
}

 

最终输出结果：

广度优先遍历-递归法：35 20 40 15 29 50 16 28 30 45 55 

 

输出结果和队列实现的方式一样。

若内容有误，欢迎指正。