二叉树遍历（非递归）

二叉树遍历

二叉树是一种很重要的数据结构, 二叉树的遍历又是二叉树的重要算法

1. 递归方法, 利用递归, 二叉树的前、中、后序遍历大致都是几行代码就可以实现。但是递归算法虽然方便了我们思考，却增大了机器跑代码的负担。

void preorder(BinTree<T> tr) {	// 前序遍历
	if(tr == null) return;
	visit(tr.data);				// 改变visit位置即可
	preorder(tr.lChild);
	preorder(tr.rChild);
}

递归算法看起来很优雅，但涉及多层次函数调用，编译器支持尾递归优化则还好，如果不支持尾递归，那么·这种算法的时间复杂度O(n)的常数项还是挺大的。

2. 递归算法的实现基础是栈内存的使用，如果我们人为的结合栈数据结构，则可以实现迭代算法
   • 前序遍历
   • 中序遍历
   • 后序遍历
   • 层序遍历

Java算法实现

package com.codevs.learn;

import java.util.*;
import java.util.function.Consumer;

/**
 * 二叉树遍历方法, 非递归
 * 前序遍历, 中序遍历可以从遍历顺序上考虑, 结合栈的特性
 * 后序遍历的实现稍微复杂一点, 除了遍历顺序, 还要考虑节点的重复遍历
 */
public class BinTree<T> {	// 简单结构
    BinTree<T> lChild;
    BinTree<T> rChild;
    T data;
    
    /**
     * 考虑前序遍历的特点: 先从左分支依次访问所有节点, 然后逆序依次访问右子树(可循环部分), 而逆序符合栈的特点
     */
    public static <T> void preorder(BinTree<T> tr, Consumer<T> c) {
        Deque<BinTree<T>> stack = new LinkedList<>();
        while(true) {
            while(tr != null) {         // 沿左分支依次遍历, 将右子节点入栈
                c.accept(tr.data);
                if(tr.rChild != null) { // Deque不允许null数据, 否则这里也可以直接入栈
                    stack.push(tr.rChild);
                }
                tr = tr.lChild;
            }
            if(stack.isEmpty()) {       // 栈空表示遍历完成
                break;
            }
            tr = stack.pop();           // 左分支遍历完，对栈顶右子树做相同遍历
        }
    }
    
    /**
     * 考虑中序遍历: 先找左节点, 即也要沿左分支找底层节点, 然后逆序访问(左 根 右)
     */
    public static <T> void midorder(BinTree<T> tr, Consumer<T> c) {
        Deque<BinTree<T>> stack = new LinkedList<>();
        while(true) {
            while(tr != null) {     // 沿左分支找底层左节点
                stack.push(tr);
                tr = tr.lChild;
            }                       // 此处栈顶即下一个要处理的节点(左 根 右)
            if(stack.isEmpty()) {   // 栈空表示遍历完成
                break;
            }
            tr = stack.pop();       // 左子树遍历完成
            c.accept(tr.data);
            tr = tr.rChild;         // 遍历右子树
        }
    }
    
    /**
     * 后序遍历复杂一些, 因为找到左分支的底层节点后, 还要考虑其右子树是否存在的情况
     * 可以考虑: 访问到一个左节点时, 不能直接处理, 需要先遍历其右子树(无论存不存在), 从右子树返回后才可以直接处理
     * 所以, 每个节点首次访问时不能处理, 需要在二次访问时才被真正处理
     */
    public static <T> void suforder(BinTree<T> tr, Consumer<T> c) {
        Deque<BinTree<T>> stack = new LinkedList<>();
        Map<BinTree<T>, Boolean> flag = new HashMap<>();	// 这里使用Map为例记录节点访问标志
        while(true) {
            while(tr != null) {     // 同理，左分支入栈
                stack.push(tr);
                tr = tr.lChild;
            }                       // 此时如果栈不为空, 则栈顶元素被记一次访问
            if(stack.isEmpty()) {   // 栈空表示遍历完成
                break;
            }
            tr = stack.peek();      // 获取当前栈顶元素
            while(flag.get(tr) == Boolean.TRUE) { // 如果该元素已经是二次访问, 则处理
                flag.remove(tr);            // 清除其标志
                stack.pop();                // 该元素出栈
                c.accept(tr.data);          // 访问内容
                if(stack.isEmpty()) {       // 判空
                    return;
                }
                tr = stack.peek();          // 继续获取栈顶元素处理, 此时也是记一次访问
            }
            flag.put(tr, Boolean.TRUE);     // 标记栈顶元素, 表示下次再访问(即从右子树返回)直接处理
            tr = tr.rChild;                 // 遍历其右子树
        }
    }
    
    /**
     * 层序遍历, 借助队列可以很容易实现
     */
    public static <T> void flrorder(BinTree<T> tr, Consumer<T> c) {
        Queue<BinTree<T>> queue = new LinkedList<>();
        if(tr != null) {
            queue.add(tr);
        }
        while(!queue.isEmpty()) {
            tr = queue.poll();
            c.accept(tr.data);
            if(tr.lChild != null) {
                queue.add(tr.lChild);
            }
            if(tr.rChild != null) {
                queue.add(tr.rChild);
            }
        }
    }

    /**
     * 简单测试
     */
    BinTree(BinTree<T> l, BinTree<T> r, T d) {
        this.lChild = l;
        this.rChild = r;
        this.data = d;
    }
    public static void main(String[] args) {
    	// 先随便乱写一个二叉树， 用于遍历测试
        BinTree<String> btree = new BinTree<>(
            new BinTree<>(new BinTree<>(null, null, "D"),
            new BinTree<>(null, new BinTree<>(null, null, "G"), "E"), "B"),
            new BinTree<>(null, new BinTree<>(
            new BinTree<>(new BinTree<>(null, null, "J"), null, "H"),
            new BinTree<>(new BinTree<>(null, null, "K"), null, "I"), "F"), "C"), "A");

        BinTree.preorder(btree, d -> System.out.print(d));
        System.out.println("\t----先序遍历");
        BinTree.midorder(btree, d -> System.out.print(d));
        System.out.println("\t----中序遍历");
        BinTree.suforder(btree, d -> System.out.print(d));
        System.out.println("\t----后序遍历");
        BinTree.flrorder(btree, d -> System.out.print(d));
        System.out.println("\t----层序遍历");
    }
}

输出结果：

	ABDEGCFHJIK     ----先序遍历
	DBEGACJHFKI     ----中序遍历
	DGEBJHKIFCA     ----后序遍历
	ABCDEFGHIJK     ----层序遍历

非递归算法实现之后，虽然时间复杂度也是O(n)，但常系数的减小对于大量数据来说，时间和空间效率的提升还是很可观的