二叉树的遍历实现

二叉树的遍历方式有先序遍历、中序遍历、后序遍历、层次遍历，本文主要讲的是这几种遍历方式的实现代码，包括递归和非递归的实现。

1. 先序遍历

先序遍历的顺序是父节点、左孩子、右孩子。

1.1 递归实现

 public static void preOrderByD(Node head){
    if(head == null) return;
     System.out.print(head.val + " ");
     preOrderByD(head.left);
     preOrderByD(head.right);

 }

1.2 非递归实现

使用栈，先将头结点放进去，当栈不为空时（循环的判断条件），取出栈顶结点，并打印，然后判断栈顶结点是否有右孩子，有的话，就存到栈里，再 判断是否有左孩子，有的话，就存到栈里。因为左孩子是在右孩子之前打印的，所以，先把右孩子放到栈中，再把左孩子放到栈中，最后出栈的时候，左孩子在右孩子前面。

代码

public static void preOrder(Node head){
    if(head != null){
        Deque<Node> stack = new LinkedList<>();
        stack.push(head);
        while(!stack.isEmpty()){
            head = stack.pop();
            System.out.print(head.val + " ");
            if(head.right != null){
                stack.push(head.right);
            }
            if(head.left != null){
                stack.push(head.left);
            }
        }
    }
}

2. 中序遍历

中序遍历的顺序是左孩子、父节点、右孩子。

2.1 递归实现

public static void inOrderByD(Node head){
   if(head == null) return;
    inOrderByD(head.left);
    System.out.print(head.val + " ");
    inOrderByD(head.right);
}

2.2 非递归实现

定义一个栈，当栈不为空，或者head不为空时（循环的条件），判断head，如果head不为空，将head的左孩子们压入栈，当head为空时，弹出栈顶结点，输出，并且将栈顶结点的右孩子赋给head,重复上述过程。

代码

public static void inOrder(Node head){
    if(head != null){
        Deque<Node> stack = new LinkedList<>();
        while(!stack.isEmpty() || head != null){
            if(head != null){
                stack.push(head);
                head = head.left;
            }else{
                head = stack.pop();
                System.out.print(head.val+" ");
                head = head.right;
            }
        }
    }
}

3. 后序遍历

后序遍历的顺序是左孩子、右孩子、父节点。

3.1 递归实现

public static void postOrderByD(Node head){
   if(head == null) return;
    postOrderByD(head.left);
    postOrderByD(head.right);
    System.out.print(head.val + " ");
}

3.2 非递归实现

后序遍历的非递归实现，有两种方式，一种是借助辅助栈，另一种不借助辅助栈

借助辅助栈

定义两个栈stack、helper，每次将stack栈中的栈顶元素放到helper中，之后将stack栈栈顶元素的左孩子放入栈，再把右孩子放入栈，进stack栈的顺序是根左右，那么最后进helper栈的顺序是根右左，所以，最后将helper中的元素弹出，顺序就是左右根。

代码

public static void postOrder(Node head){
   if(head != null){
        Deque<Node> stack = new LinkedList<>();
        Deque<Node> helper = new LinkedList<>();
        stack.push(head);
        while(!stack.isEmpty()){
           head = stack.pop();
           helper.push(head);
           if(head.left != null){
               stack.push(head.left);
           }
           if(head.right != null){
               stack.push(head.right);
           }
        }
        while(!helper.isEmpty()){
            System.out.print(helper.pop().val + " ");
        }
    }
}

不借助栈

定义一个栈stack,一个空节点node,让node记录输出的结点，如果栈顶元素不等于空，并且该结点的左右孩子都不等于node的话，说明这个结点的左孩子和右孩子都没有输出，就把这个结点的左孩子放入栈，如果head的结点的右孩子没输出过，就把右孩子放入栈。

代码

public static void postOrder2(Node head){
    Node node = null;
    if(head != null){
        Deque<Node> stack = new LinkedList<>();
        stack.push(head);
        while(!stack.isEmpty()){
            head = stack.peek();
            //每次输出，node都会变，所以这里node要和左右孩子比较
            if(head.left != null && node != head.left && node != head.right){
                stack.push(head.left);
           //head的左孩子输出了，右孩子没输出，就把右孩子放入栈
            }else if(head.right != null && node != head.right ){
                stack.push(head.right);
            }else{
                System.out.print(stack.pop().val + " ");
                node = head;
            }
        }
    }
}

4. 层次遍历

层次遍历，就是一层一层的遍历。层次遍历的实现，是靠队列完成的，每次将队列节点素取出打印后，判断该结点是否有孩子，有孩子结点的话，就将孩子结点存到队列中。

代码

 public static void levelTraverse(Node head){
    if(head != null){
       Deque<Node> queue = new LinkedList<>();
       queue.offer(head);
       while(!queue.isEmpty()){
           head = queue.poll();
           System.out.print(head.val + " ");
           if(head.left != null) queue.offer(head.left);
           if(head.right != null) queue.offer(head.right);
       }
    }
}

如有不足之处，欢迎指正，谢谢！