二叉树的遍历-先序中序后序层次（java实现）

二叉树的结构

public class TreeNode{
    int data;
    Treenode left;
    Treenode right;
    void Treenode(int data){
        this.data = data;
    }
}

遍历

即将树的所有结点访问且仅访问一次。按照根节点位置的不同分为前序遍历，中序遍历，后序遍历。
前序遍历：根节点->左子树->右子树
中序遍历：左子树->根节点->右子树
后序遍历：左子树->右子树->根节点

递归与非递归实现

非递归使用Stack
前序遍历

//递归
void traverse(TreeNode node){
        if(node != null){
            System.out.println("data:" + node.data);
            traverse(node.left);
            traverse(node.right);
        }
    }
//非递归
void preOrderTraverse(TreeNode root){
        Stack<TreeNode> stack = new Stack<>();
        TreeNode t = root;
        while(t != null || !stack.isEmpty()){
            while(t != null){
                stack.push(t);
                System.out.print(t.data + " ");
                t = t.left;
            }
            if(!stack.isEmpty()){
                t = stack.pop();
                t = t.right;
            }
        }
    }

中序遍历

//递归
void traverse(TreeNode node){
        if(node != null){
            traverse(node.left);
            System.out.println("data:" + node.data);
            traverse(node.right);
        }
    }
//非递归
void inOrderTraverse(TreeNode root){
        Stack<TreeNode> stack = new Stack<>();
        TreeNode t = root;
        while(t != null || !stack.isEmpty()){
            while(t != null){
                stack.push(t);
                t = t.left;
            }
            if(!stack.isEmpty()){
                t = stack.pop();
                System.out.print(t.data + " ");
                t = t.right;
            }
        }
    }

后序遍历

//递归
void traverse(TreeNode node){
        if(node != null){
            traverse(node.left);
            traverse(node.right);
            System.out.println("data:" + node.data);
        }
    }

非递归后序遍历要保证左孩子和右孩子都已被访问（且左孩子在右孩子前访问）才能访问根结点。
提供的思路：
思路：对于根结点，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的结点，此时该结点出现在栈顶，按照相同的规则处理右子树，当访问其右孩子后，该结点又出现在栈顶，此时可以将其出栈并访问。这样就保证了正确的访问顺序。在这个过程中，每个结点都两次出现在栈顶，只有在第二次出现在栈顶时，才访问它。
实现方式：
1.定义一种结构，信息包含TreeNode，以及右结点是否被访问rvisited
2.定义一种结构，信息包含TreeNode，以及出现在栈顶的次数，第一次为true，第二次为false;
实现代码有时间再写。

//非递归
void postOrderTraverse1(TreeNode node){
        Stack<TreeNode> stack = new Stack<>();

    }

第二种（个人偏好第二种）：结点出栈的时候访问结点，当左右孩子都已经被访问时出栈，进栈时先进右孩子再进左孩子。算法：
1.若根结点不空，将根结点入栈；
2.若栈不空，若栈顶元素不存在左右孩子或者都已经被访问，则栈顶元素出栈并访问，否则若栈顶元素存在左右孩子，若存在右孩子，则右孩子进栈，若存在左孩子，则左孩子进栈；
3.重复2.

void postOrderTraverse2(TreeNode root){
    if(root == null)
        return;
    Stack<TreeNode> stack = new Stack<>();
    stack.push(root);
    TreeNode cur = null;
    TreeNode pre = null;
    while(!stack.isEmpty()){
        cur = stack.peek();
        //如果当前结点没有孩子结点或者孩子节点都已被访问过
        if((cur.left == null && cur.right == null)|| (pre != null &&(pre == cur.left || pre == cur.right))){
            System.out.print("data:" + cur.data);
            stack.pop();
            pre = cur;
        }else{
            if(tmp.right != null){
                stack.push(tmp.right);
            }
            if(tmp.left != null){
                stack.push(tmp.left);
            }
        }
    }
}

思路：需要判断上次访问的节点是位于左子树，还是右子树。若是位于左子树，则需跳过根节点，先进入右子树，再回头访问根节点；若是位于右子树，则直接访问根节点。(和上一种差不多，只是实现不一样）

层次遍历，使用队列

import java.util.Queue;
import java.util.LinkedList;

public class Solution{
    private void traverseLevel(TreeNode node){
        if(node == null){
            return;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(node);
        while(!queue.isEmpty()){
            TreeNode tmp = queue.poll();
            System.out.println(tmp.data + "->");
            if(tmp.left != null){
                queue.add(tmp.left);
            }
            if(tmp.right != null){
                queue.add(tmp.right);           }
        }
    }

}