Java创建、遍历（递归+非递归）二叉树

输入：一个先序的数组，将数组中的元素构建成为二叉树

package test.tree;

import java.util.ArrayList;
import java.util.Stack;

public class BinaryTree {
    private TreeNode root;
    private int size = 0;

    public BinaryTree() {
    }

    public BinaryTree(int value) {
        this.root = new TreeNode(value);
        this.size = 1;
    }

    public TreeNode getRoot() {
        return root;
    }


    /**
     * 先序遍历递归实现
     * @param node
     * @param container
     */
    public void preOrderTreeWalk(TreeNode node, ArrayList<Integer> container) {
        if (node != null) {
            container.add(node.value);
            preOrderTreeWalk(node.leftChildNode, container);
            preOrderTreeWalk(node.rightChildNode, container);
        }
    }

    /**
     * 非递归实现先序遍历
     * @param root
     * @param container
     */
    public void prePrint2(TreeNode root, ArrayList<Integer> container) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while(root != null || !stack.isEmpty()) {
            if(root != null) {
                container.add(root.value);
                stack.push(root);
                root = root.leftChildNode;
            }
            else if(!stack.isEmpty()) { //pNode == null, !stack.isEmpty
                TreeNode node = stack.pop();
                root = node.rightChildNode;
            }
        }
    }

    /**
     * 递归实现中序遍历
     * @param node
     * @param container
     */
    public void midOrderTreeWalk(TreeNode node, ArrayList<Integer> container) {
        if (node != null) {
            midOrderTreeWalk(node.leftChildNode, container);
            container.add(node.value);
            midOrderTreeWalk(node.rightChildNode, container);
        }
    }

    /**
     * 非递归实现中序遍历
     * @param root
     * @param container
     */
    public void inPrint2(TreeNode root, ArrayList<Integer> container) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while(root != null || !stack.isEmpty()) {
            if(root != null) {
                stack.push(root);
                root = root.leftChildNode;
            } else {
                TreeNode node = stack.pop();
                container.add(node.value);
                root = node.rightChildNode;
            }
        }
    }

    /**
     * 递归实现后序遍历
     * @param node
     * @param container
     */
    public void postOrderTreeWalk(TreeNode node, ArrayList<Integer> container) {
        if (node != null) {
            postOrderTreeWalk(node.leftChildNode, container);
            postOrderTreeWalk(node.rightChildNode, container);
            container.add(node.value);
        }
    }

    /**
     * 非递归实现后序遍历
     * @param node
     * @param container
     */
    public void postPrintTree(TreeNode node, ArrayList<Integer> container) {

        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode p = node, prev = node;
        while(p != null || !stack.isEmpty()) {
            while(p != null) {
                stack.push(p);
                p = p.leftChildNode;
            }

            if(!stack.isEmpty()) {
                TreeNode tmp = stack.peek().rightChildNode;
                if(tmp == null || tmp == prev) {
                    p = stack.pop();
                    container.add(p.value);
                    prev = p;
                    p = null;
                } else {
                    p = tmp;
                }
            }
        }

    }

    public void createBinaryTree(int[] data) {
        if (data != null) {
            for (int i : data) {
                insert(i);
            }
        }
    }

    public void insert(int value) {
        if (root == null) { //当前没有根节点，则数组中的第一个数是根节点
            root = new TreeNode(value);
        } else {
            TreeNode curNode = root; //根节点
            TreeNode parentNode;
            while (true) {
                parentNode = curNode; //curNode:root
                if (value < curNode.value) {
                    curNode = curNode.leftChildNode; //小于根节点，就在是root的左孩子结点
                    if (curNode == null) {
                        parentNode.leftChildNode = new TreeNode(value);
//                        parentNode.leftChildNode.leftOrRight = -1;
                        break;
                    }
                } else {
                    curNode = curNode.rightChildNode;
                    if (curNode == null) {
                        parentNode.rightChildNode = new TreeNode(value);
//                        parentNode.rightChildNode.leftOrRight = 1;
                        break;
                    }
                }
            }
        }
        ++size;
    }


    public int size() {
        return this.size;
    }

    public boolean isEmpty() {
        return size == 0;
    }
}

测试

package test.tree;

import java.util.ArrayList;

public class TestBinTree {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int[] data = { 21, 25, 16, 32, 22, 19, 13, 20};
        BinaryTree bTree = new BinaryTree();
        bTree.createBinaryTree(data);
        ArrayList<Integer> container = new ArrayList<Integer>();
        TreeNode root = bTree.getRoot();
        container.clear();
        bTree.preOrderTreeWalk(root, container);
        System.out.println("递归先序遍历:  " + container);
        container.clear();
        bTree.prePrint2(root, container);
        System.out.println("非递归先序遍历:"+container);
        container.clear();
        System.out.println("----------------------------------------------");
        bTree.midOrderTreeWalk(root, container);
        System.out.println("递归中序遍历:  " + container);
        container.clear();
        bTree.inPrint2(root, container);
        System.out.println("非递归中序遍历:"+container);
        container.clear();
        System.out.println("----------------------------------------------");
        bTree.postOrderTreeWalk(root, container);
        System.out.println("递归后续遍历:  " + container);
        container.clear();
        bTree.postPrintTree(root, container);
        System.out.println("非递归后序遍历:" + container);

    }
}

结果

递归先序遍历:  [21, 16, 13, 19, 20, 25, 22, 32]
非递归先序遍历:[21, 16, 13, 19, 20, 25, 22, 32]
----------------------------------------------
递归中序遍历:  [13, 16, 19, 20, 21, 22, 25, 32]
非递归中序遍历:[13, 16, 19, 20, 21, 22, 25, 32]
----------------------------------------------
递归后续遍历:  [13, 20, 19, 16, 22, 32, 25, 21]
非递归后序遍历:[13, 20, 19, 16, 22, 32, 25, 21]