树的遍历

树的遍历

先了解一下树的相关定义:

1. 结点的度：一个结点含有的子结点的个数称为该结点的度；
2. 叶结点或终端结点：度为0的结点称为叶结点；
3. 非终端结点或分支结点：度不为0的结点；
4. 双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点；
5. 孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点；
6. 兄弟结点：具有相同父结点的结点互称为兄弟结点；
7. 树的度：一棵树中，最大的结点的度称为树的度；
8. 结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；
9. 树的高度或深度：树中结点的最大层次；
10. 堂兄弟结点：双亲在同一层的结点互为堂兄弟；
11. 结点的祖先：从根到该结点所经分支上的所有结点；
12. 子孙：以某结点为根的子树中任一结点都称为该结点的子孙。
13. 森林：由m（m>=0）棵互不相交的树的集合称为森林；
14. 无序树：树中任意节点的子结点之间没有顺序关系，这种树称为无序树,也称为自由树;
15. 有序树：树中任意节点的子结点之间有顺序关系，这种树称为有序树；
16. 二叉树：每个节点最多含有两个子树的树称为二叉树；
17. 完全二叉树：若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树；
18. 满二叉树：除最后一层无任何子节点外，每一层上的所有结点都有两个子结点的二叉树；
19. 哈夫曼树：带权路径最短的二叉树称为哈夫曼树或最优二叉树。

以下面的树作为例子

树的节点类

public class TreeNode<E> {
    public E value;
    public TreeNode left;
    public TreeNode right;

    public TreeNode() {
    }

    public TreeNode(E value) {
        this.value = value;
    }

    public TreeNode(E value, TreeNode left, TreeNode right) {
        this.value = value;
        this.left = left;
        this.right = right;
    }

    @Override
    public String toString() {
        return "TreeNode{" +
                "value=" + value +
                '}';
    }
}

树的遍历

1. 先序遍历(深度优先搜索)

他的访问顺序是：根节点→左子树→右子树
访问顺序如下图

(A)根节点→(B)左子树→©右子树
对于（B）左子树而言：(B)根节点→(D)左孩子→(E)右孩子
对于（C）右子树而言：(C )根节点→(F)左孩子→(G)右孩子
故例子的先序遍历的结果是：A→B→D→E→C→F→G

递归

public static void preorder(TreeNode treeNode) {
    if (treeNode == null)
        return;
    System.out.print(treeNode.value + " ");
    preorder(treeNode.left); // 遍历左子树
    preorder(treeNode.right); // 遍历右子树
}

栈

public static void preorder2(TreeNode treeNode) {
    if (treeNode == null)
        return;
    Stack<TreeNode> stack = new Stack<>();
    stack.push(treeNode); // 压栈
    while (!stack.empty()) {
        TreeNode temp = stack.pop(); // 出栈
        System.out.print(temp.value + " ");
        if (treeNode.right != null) // 先将右子树压栈，因为后遍历右子树
            stack.push(treeNode.right);
        if (treeNode.left != null)
            stack.push(treeNode.left);
    }
}

2. 中序遍历

他的访问顺序是：左子树→根节点→右子树
访问顺序如下图

(B)左子树→(A)根节点→©右子树
对于（B）左子树而言：(D)左孩子→(B)根节点→(E)右孩子
对于（C）右子树而言：(F)左孩子→(C ) 根节点→(G)右孩子
故例子的中序遍历的结果是：D→B→E→A→F→C→G

递归

public static void inorder(TreeNode treeNode) {
    if (treeNode == null)
        return;
    inorder(treeNode.left); // 遍历左子树
    System.out.print(treeNode.value + " ");
    inorder(treeNode.right); // 遍历右子树
}

栈

public static void inorder2(TreeNode treeNode) {
    Stack<TreeNode> stack = new Stack<>();
    while (treeNode != null || !stack.empty()) {
        while (treeNode != null) {
            stack.push(treeNode);
            treeNode = treeNode.left;
        }
        if (!stack.empty()) {
            treeNode = stack.pop();
            System.out.printf(treeNode.value + " ");
            treeNode = treeNode.right;
        }
    }
}

3. 后序遍历

他的访问顺序是：左子树→右子树→根节点
访问顺序如下图

(B)左子树→©右子树→(A)根节点
对于（B）左子树而言：(D)左孩子→(E)右孩子→(B)根节点
对于（C）右子树而言：(F)左孩子→(G)右孩子→(C ) 根节点
故例子的后序遍历的结果是：D→E→B→F→G→C→A

递归

public static void postorder(TreeNode treeNode) {
    if (treeNode == null)
        return;
    postorder(treeNode.left); // 遍历左子树
    postorder(treeNode.right); // 遍历右子树
    System.out.print(treeNode.value + " ");
}

栈

public static void postorder2(TreeNode treeNode) {
    if (treeNode == null)
        return;
    Stack<TreeNode> stack = new Stack<>();
    stack.push(treeNode);
    while (!stack.empty()) {
        TreeNode temp = stack.peek();
        // 如果 temp 的左子树不为空(先左子树)，并且 temp 的左右子树都没有遍历过
        if (temp.left != null && treeNode != temp.left && treeNode != temp.right)
            stack.push(temp.left);
        // 否则 如果 temp 的右子树不为空(先右子树)，并且 temp 的右子树没有遍历过
        else if (temp.right != null && treeNode != temp.right)
            stack.push(temp.right);
        // 否则 如果 temp 左右子树为空或者遍历过了，则遍历 temp 结点
        else {
            System.out.printf(stack.pop().value + " ");
            treeNode = temp;
        }
    }
}

4. 广度优先搜索

他的访问顺序是：先访问上一层，在访问下一层，一层一层的往下访问
访问顺序如下图

故例子的广度优先搜索的结果是：A→B→C→D→E→F→G

队列

public static void bfs(TreeNode treeNode) {
    if (treeNode == null)
        return;
    Queue<TreeNode> queue = new LinkedList<>();
    queue.add(treeNode);
    while (!queue.isEmpty()) {
        TreeNode temp = queue.poll();  // 返回队首并出队
        System.out.printf(temp.value + " ");
        // 左子树不为空时加入队列
        if (temp.left != null)
            queue.add(temp.left);
        // 右子树不为空时加入队列
        if (temp.right != null)
            queue.add(temp.right);
    }
}

测试一下上述遍历方法

public static void main(String[] args) {
    // 构造上述例子中的树
    TreeNode<Character> treeNode_D = new TreeNode('D', null, null);
    TreeNode<Character> treeNode_E = new TreeNode('E', null, null);
    TreeNode<Character> treeNode_F = new TreeNode('F', null, null);
    TreeNode<Character> treeNode_G = new TreeNode('G', null, null);
    TreeNode<Character> treeNode_B = new TreeNode('B', treeNode_D, treeNode_E);
    TreeNode<Character> treeNode_C = new TreeNode('C', treeNode_F, treeNode_G);
    TreeNode<Character> treeNode_A = new TreeNode('A', treeNode_B, treeNode_C);

    System.out.println("------------先序遍历------------");
    System.out.print("递归方法先序遍历: ");
    preorder(treeNode_A);
    System.out.print("\n栈方法先序遍历:   ");
    preorder2(treeNode_A);
    System.out.println();

    System.out.println("------------中序遍历------------");
    System.out.print("递归方法中序遍历: ");
    inorder(treeNode_A);
    System.out.print("\n栈方法中序遍历:   ");
    inorder2(treeNode_A);
    System.out.println();

    System.out.println("------------后序遍历------------");
    System.out.print("递归方法后序遍历: ");
    postorder(treeNode_A);
    System.out.print("\n栈方法后序遍历:   ");
    postorder2(treeNode_A);
    System.out.println();

    System.out.println("------------广度优先搜索---------");
    bfs(treeNode_A);
}

运行结果

------------先序遍历------------
递归方法先序遍历: A B D E C F G 
栈方法先序遍历:   A B D E C F G 
------------中序遍历------------
递归方法中序遍历: D B E A F C G 
栈方法中序遍历:   D B E A F C G 
------------后序遍历------------
递归方法后序遍历: D E B F G C A 
栈方法后序遍历:   D E B F G C A 
------------广度优先搜索---------
A B C D E F G