算法

（一）二叉树遍历

四种主要的遍历思想为：

深度优先：
前序遍历：根结点 —> 左子树 —> 右子树
中序遍历：左子树—> 根结点 —> 右子树
后序遍历：左子树 —> 右子树 —> 根结点

广度优先：
层次遍历：只需按层次遍历即可

例如，求下面二叉树的各种遍历

前序遍历：1 2 4 5 7 8 3 6

中序遍历：4 2 7 5 8 1 3 6

后序遍历：4 7 8 5 2 6 3 1

层次遍历：1 2 3 4 5 6 7 8

1、前序遍历
递归版本：

public void preOrderTraverse1(TreeNode root) {  
        if (root != null) {  
            System.out.print(root.val+"  ");  
            preOrderTraverse1(root.left);  
            preOrderTraverse1(root.right);  
        }  
    }  

非递归版本：（LinkedList替换成Stack也可以，下同）

public void preOrderTraverse2(TreeNode root) {  
        LinkedList<TreeNode> stack = new LinkedList<>();  
        TreeNode pNode = root;  
        while (pNode != null || !stack.isEmpty()) {  
            if (pNode != null) {  
                System.out.print(pNode.val+"  ");  
                stack.push(pNode);  
                pNode = pNode.left;  
            } else { //pNode == null && !stack.isEmpty()  
                TreeNode node = stack.pop();  
                pNode = node.right;  
            }  
        }  
    }  

2、中序遍历
递归版本：

public void inOrderTraverse1(TreeNode root) {  
        if (root != null) {  
            inOrderTraverse1(root.left);  
            System.out.print(root.val+"  ");  
            inOrderTraverse1(root.right);  
        }  
    }  

非递归版本：

public void inOrderTraverse2(TreeNode root) {  
        LinkedList<TreeNode> stack = new LinkedList<>();  
        TreeNode pNode = root;  
        while (pNode != null || !stack.isEmpty()) {  
            if (pNode != null) {  
                stack.push(pNode);  
                pNode = pNode.left;  
            } else { //pNode == null && !stack.isEmpty()  
                TreeNode node = stack.pop();  
                System.out.print(node.val+"  ");  
                pNode = node.right;  
            }  
        }  
    }  

3.后序遍历
递归版本：

public void postOrderTraverse1(TreeNode root) {  
        if (root != null) {  
            postOrderTraverse1(root.left);  
            postOrderTraverse1(root.right);  
            System.out.print(root.val+"  ");  
        }  
    }  

非递归版本：

方法1

public void postOrderTraversel(TreeNode root){
    if(root == null)
        return;
    Stack<TreeNode> s = new Stack<TreeNode>();
    Stack<TreeNode> outPut = new Stack<TreeNode>();
    s.push(root);
    while(!s.isEmpty()){
        TreeNode cur = s.pop();
        outPut.push(cur);

        if(cur.left != null){
            s.push(cur.left);
        }
        if(cur.right != null){
            s.push(cur.right);
        }
    }
    while(!outPut.isEmpty()){
        System.out.print(outPut.pop().val + " ");
    }
}

图示：

方法2（不易理解）

public void posOrder1(TreeNode root)
    {
        Stack<TreeNode> stack1 = new Stack<>();
        Stack<TreeNode> stack2 = new Stack<>();
        TreeNode pNode = root;
        int i = 1;
        while(pNode != null || !stack1.empty()){
            while (pNode != null){
                stack1.push(pNode);
                stack2.push(0);
                pNode = pNode.left;
            }

            while(!stack1.empty() && stack2.peek() == i){
                stack2.pop();
                System.out.print(stack1.pop().element + "   ");
            }

            if(!stack1.empty()){
                stack2.pop();
                stack2.push(1);
                pNode = stack1.peek();
                pNode = pNode.right;
            }
        }
    }

4、层次遍历

public void levelTraverse(TreeNode root) {  
        if (root == null) {  
            return;  
        }  
        LinkedList<TreeNode> queue = new LinkedList<>();  
        queue.offer(root);  
        while (!queue.isEmpty()) {  
            TreeNode node = queue.poll();  
            System.out.print(node.val+"  ");  
            if (node.left != null) {  
                queue.offer(node.left);  
            }  
            if (node.right != null) {  
                queue.offer(node.right);  
            }  
        }  
    }  

5、深度优先遍历
其实深度遍历就是上面的前序、中序和后序。但是为了保证与广度优先遍历相照应，也写在这。代码也比较好理解，其实就是前序遍历，代码如下：

public void depthOrderTraverse(TreeNode root) {  
        if (root == null) {  
            return;  
        }  
        LinkedList<TreeNode> stack = new LinkedList<>();  
        stack.push(root);  
        while (!stack.isEmpty()) {  
            TreeNode node = stack.pop();  
            System.out.print(node.val+"  ");  
            if (node.right != null) {  
                stack.push(node.right);  
            }  
            if (node.left != null) {  
                stack.push(node.left);  
            }  
        }  
    }