二叉树三种递归和非递归遍历 层序遍历

以下为二叉树的三种遍历（中序，先序，后序）源码，和非递归遍历源码。 

中序 递归遍历

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

中序非递归遍历

public static void inorderTraversalNoRe(TreeNode root) {
		Stack<TreeNode> s = new Stack<TreeNode>();  
        while (root != null || !s.empty()) {  
            while (root != null) {  
                s.push(root);  
                root = root.left;  
            }  
            if (!s.empty()) {  
            	root = s.pop();  
                System.out.print(root.val);  
                root = root.right;  
            }  
        }  
    }

先序递归遍历

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

先序非递归遍历

public static void preorderTraversalNoRe(TreeNode root) {
		Stack<TreeNode> s = new Stack<TreeNode>();  
        while (root != null || !s.empty()) {  
            while (root != null) {  
                System.out.print(root.val);  
                s.push(root);  
                root = root.left;  
            }  
            if (!s.empty()) {  
            	root = s.pop();  
            	root = root.right;  
            }  
        }  
    }

后序递归遍历

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

后序非递归遍历

public static void postorderTraversalNoRe(TreeNode root) {
		Stack<TreeNode> s = new Stack<TreeNode>();  //记录节点
        Stack<Integer> s2 = new Stack<Integer>();  
        int i = 1;  
        while (root != null || !s.empty()) {  
            while (root != null) {  
                s.push(root);  
                s2.push(0);  
                root = root.left;  
            }  
            while (!s.empty() && s2.peek().equals(i)) {  
                s2.pop();  
                System.out.print(s.pop().val);  
            }  
  
            if (!s.empty()) {  
                s2.pop();  
                s2.push(1);  
                root = s.peek();  //返回栈顶元素，但不移除
                root = root.right;  
            }  
        }  
    }


//方法二
public static List<Integer> postTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root != null){
            Stack<TreeNode> s1 = new Stack<TreeNode>();
            Stack<TreeNode> s2 = new Stack<TreeNode>();
            s1.push(root);
            while(!s1.isEmpty()){
                root = s1.pop();
                s2.push(root);
                if(root.l != null){
                    s1.push(root.l);
                }
                if(root.r != null){
                    s1.push(root.r);
                }
            }
            while(!s2.isEmpty()){
                list.add(s2.pop().val);
            }
        }
        return list;
    }

层序遍历，0标识分隔层次

private static List<Integer> cengTraversal(TreeNode root) {
        if(root==null)return null;
        List<Integer> list = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        TreeNode last = root;
        TreeNode nlast = root;
        queue.add(root);
        while (!queue.isEmpty()){
            TreeNode tmp = queue.poll();
            list.add(tmp.val);
            if(tmp.l!=null){
                queue.add(tmp.l);
                nlast = tmp.l;
            }
            if(tmp.r!=null){
                queue.add(tmp.r);
                nlast = tmp.r;
            }
            if(last == tmp){
                last = nlast;
                list.add(0);
            }
        }
        return list;
    }

 

最后给出根节点定义

public class TreeNode {

	public int val;
	public TreeNode left;
	public TreeNode right;
	public TreeNode(int x){val = x;};
}