【数据结构】二叉树遍历

二叉树结构

/**
 * Created by novax_000 on 2016/5/1.
 */
public class BinaryTree<T> {
    public T value;
    public BinaryTree<T> left;
    public BinaryTree<T> right;

    public BinaryTree(T value, BinaryTree<T> left, BinaryTree<T> right) {
        super();
        this.value = value;
        this.left = left;
        this.right = right;
    }

    public BinaryTree(){
        super();
    }


}

二叉树的遍历：

1、先序遍历（递归）

 //递归先序遍历
    public void preOrderRecursive(BinaryTree<T> root)
    {
        if(root==null)
        {
            return;
        }
        //先访问根节点
        System.out.println(root.value);
        //然后访问左孩子
        preOrderRecursive(root.left);
        //然后访问右孩子
        preOrderRecursive(root.right);
    }

2、中序遍历（递归）

 //递归中序遍历
    public void inOrderRecursive(BinaryTree<T> root)
    {
        if(root==null)
        {
            return;
        }
        //先访问左孩子
        inOrderRecursive(root.left);
        //再访问根节点
        System.out.println(root.value);
        //再访问右孩子
        inOrderRecursive(root.right);
    }

3、后序遍历（递归）

    //递归后序遍历
    public void postOrderRecursive(BinaryTree<T> root)
    {
        if(root==null)
        {
            return;
        }
        //先访问左孩子
        postOrderRecursive(root.left);
        //再访问右孩子
        postOrderRecursive(root.right);
        //最后访问根节点
        System.out.println(root.value);
    }

4、先序遍历（非递归）

  //非递归先序遍历
    public void preOrderNonRecursive(BinaryTree<T> root)
    {
        if(root==null)
        {
            return;
        }
        Stack<BinaryTree> stack = new Stack<BinaryTree>();

        stack.push(root);
        //当栈不为空时
        while(!stack.isEmpty())
        {
            //先弹出根节点
            BinaryTree<T> temp = stack.pop();
            System.out.println(temp.value);
            //把右孩子压入栈
            if(temp.right!=null)
            {
                stack.push(temp.right);
            }
            //把左孩子压入栈
            if(temp.left!=null)
            {
                stack.push(temp.left);
            }
        }
    }

5、中序遍历（非递归）

    //非递归中序遍历
    public void inOrderNonRecursive(BinaryTree<T> root)
    {
        if(root==null)
        {
            return;
        }
        Stack<BinaryTree> stack = new Stack<BinaryTree>();
        BinaryTree<T> current = root;
        while(current!=null||!stack.isEmpty())
        {
            //一路向左入栈
            while(current!=null)
            {
                stack.push(current);
                current = current.left;
            }
            if(!stack.isEmpty())
            {
                current = stack.peek();
                stack.pop();
                System.out.println(current.value);
                current = current.right;
            }
        }
    }

6、后序遍历（非递归）

  //非递归后序遍历
    public void postOrderNonRecursive(BinaryTree<T> root)
    {
        if(root==null)
        {
            return;
        }
        Stack<BinaryTree> stack = new Stack<BinaryTree>();
        BinaryTree<T> current = root;
        BinaryTree<T> pre = null;
        while(current!=null||!stack.isEmpty())
        {
            while(current!=null)
            {
                stack.push(current);
                current = current.left;
            }
            current = stack.peek();
            //如果当前节点无右孩子或者当前节点的右孩子已经访问过了，就访问当前节点
            if((current.right==null)||(current.right==pre))
            {
                System.out.println(current.value);
                //用pre记录已经访问过的节点
                pre = current;
                stack.pop();
                current = null;
            }
            else
            {
                current = current.right;
            }
        }
    }

7、后序遍历第二种方法（非递归）

  //非递归后序遍历第二种方法，用两个栈
    public void postOrderNonRecursiveWithTwoStack(BinaryTree<T> root)
    {
        Stack<BinaryTree> stack1 = new Stack<BinaryTree>();
        Stack<BinaryTree> stack2 = new Stack<BinaryTree>();
        BinaryTree<T> current;
        stack1.push(root);
        while(!stack1.isEmpty())
        {
            current = stack1.peek();
            stack1.pop();
            //第二个栈的入栈顺序为先根节点，然后右孩子，然后左孩子
            stack2.push(current);
            //按先左孩子，后右孩子的顺序压入第一个栈
            if(current.left!=null)
            {
                stack1.push(current.left);

            }
            if(current.right!=null)
            {
                stack1.push(current.right);
            }

            
        }
        //第二个栈的出栈顺序为左孩子，右孩子，根节点
        while(!stack2.isEmpty())
        {
            System.out.println(stack2.peek().value);
            stack2.pop();
        }
    }