二叉树的递归与非递归遍历

对于二叉树的遍历，最简单的就是递归遍历，同时仿照递归算法执行过程中递归工作栈的变化可写出对应的非递归算法。

首先建立二叉树的结构类

public class BiTree<T> {
    private T data;
    private BiTree<T> left;
    private BiTree<T> right;
    
    public BiTree(T data) {
        this.data = data;
        left = right = null;
    }
    
    public void setLeft(BiTree<T> left) {
        this.left = left;
    }
    
    public void setRight(BiTree<T> right) {
        this.right = right;
    }
    
    public void visit() {
        System.out.print(data + " ");
    }
    
    public BiTree<T> getLeft() {
        return left;
    }
    
    public BiTree<T> getRight() {
        return right;
    }
}

下面这个类提供了各种遍历的递归与非递归算法：

import java.util.*;

public class TreeUtil {
    public static <T> void preOrderTraverseRecursive(BiTree<T> tree) {
        if(tree == null) {
            return;
        }
        
        tree.visit();
        preOrderTraverseRecursive(tree.getLeft());
        preOrderTraverseRecursive(tree.getRight());
    }
    
    public static <T> void inOrderTraverseRecursive(BiTree<T> tree) {
        if(tree == null) {
            return;
        }
        
        inOrderTraverseRecursive(tree.getLeft());
        tree.visit();
        inOrderTraverseRecursive(tree.getRight());
    }
    
    public static <T> void postOrderTraverseRecursive(BiTree<T> tree) {
        if(tree == null) {
            return;
        }
        
        postOrderTraverseRecursive(tree.getLeft());
        postOrderTraverseRecursive(tree.getRight());
        tree.visit();
    }
    
        /*
         * 先序遍历非递归算法
         */
    public static <T> void preOrderTraverseNonRecursive(BiTree<T> tree) {
        if(tree == null) {
            return;
        }
        
        LinkedList<BiTree<T>> stack = new LinkedList<BiTree<T>>();
        BiTree<T> p = tree;
        
        while(p != null || !stack.isEmpty()) {
            if(p != null) {
                p.visit();
                stack.push(p.getRight());
                p = p.getLeft();
            } else {
                p = stack.pollFirst();
            }
        }
    }
    
        /*
         * 中序遍历非递归算法
         */
    public static <T> void inOrderTraverseNonRecursive(BiTree<T> tree) {
        if(tree == null) {
            return;
        }
        
        LinkedList<BiTree<T>> stack = new LinkedList<BiTree<T>>();
        BiTree<T> p = tree;
        
        while(p != null || !stack.isEmpty()) {
            if(p != null) {
                stack.push(p);
                p = p.getLeft();
            } else {
                p = stack.pollFirst();
                p.visit();
                p = p.getRight();
            }
        }
    }
    
        /*
         * 后序遍历非递归算法
         */
    public static <T> void postOrderTraverseNonRecursive(BiTree<T> tree) {
        if(tree == null) {
            return;
        }
        
        LinkedList<BiTree<T>> stack = new LinkedList<BiTree<T>>();
        BiTree<T> p = tree;
        
        while(true) {
            if(p != null) {
                stack.push(p);
                stack.push(p.getRight());
                p = p.getLeft();
            } else {
                p = stack.pollFirst();
                if(p == null) {
                    p = stack.pollFirst();
                    p.visit();
                    if(stack.isEmpty()) return;
                    p = stack.pollFirst();
                }
                stack.push(null);
            }
        }
    }
    
    public static <T> BiTree<T> generateTreeFromArray(T[] array) {
        if(array == null || array.length == 0) {
            return null;
        }
        
        int index = 0;
        Queue<BiTree<T>> q = new LinkedList<BiTree<T>>();
        BiTree<T> root = new BiTree<T>(array[index++]);
        BiTree<T> current;
        
        q.offer(root);
        while((current = q.poll()) != null && index < array.length) {
            BiTree<T> left = new BiTree<T>(array[index++]);
            q.offer(left);
            current.setLeft(left);

            if(index < array.length) {
                BiTree<T> right = new BiTree<T>(array[index++]);
                q.offer(right);
                current.setRight(right);
            }
        }
        
        return root;
    }

    public static void main(String[] args) {
        BiTree<Integer> tree = generateTreeFromArray(new Integer[]{1,2,3,4,5,6,7,8,9,10});
        preOrderTraverseRecursive(tree);
        System.out.println();
        preOrderTraverseNonRecursive(tree);
        System.out.println();
        inOrderTraverseRecursive(tree);
        System.out.println();
        inOrderTraverseNonRecursive(tree);
        System.out.println();
        postOrderTraverseRecursive(tree);
        System.out.println();
        postOrderTraverseNonRecursive(tree);
        System.out.println();
    }
} 

遍历算法的基本操作是结点访问，对于含n个结点的二叉树，时间复杂度为O(n)。所需辅助空间为栈的最大容量，即树的深度，最坏情况下为n，所以空间复杂度也是O(n)。