1.递归遍历

2.非递归遍历

3.层次遍历

1.递归遍历

• 在使用递归遍历的时候，每个节点会经过三次.

public class PreInPosTraversal {

	public static class Node {
		public int value;
		public Node left;
		public Node right;

		public Node(int data) {
			this.value = data;
		}
	}

    // 前序遍历
	public static void preOrderRecur(Node head) {
		if (head == null) {
			return;
		}
		System.out.print(head.value + " ");
		preOrderRecur(head.left);
		preOrderRecur(head.right);
	}

    // 中序遍历
	public static void inOrderRecur(Node head) {
		if (head == null) {
			return;
		}
		inOrderRecur(head.left);
		System.out.print(head.value + " ");
		inOrderRecur(head.right);
	}

    // 后序遍历
	public static void posOrderRecur(Node head) {
		if (head == null) {
			return;
		}
		posOrderRecur(head.left);
		posOrderRecur(head.right);
		System.out.print(head.value + " ");
	}
}

2.非递归遍历

• 非递归一般只会经过每个节点两次

// 前序非递归（中左右），使用一个栈。先压右节点，再压左节点。
public static void preOrderUnRecur(Node head) {
		System.out.print("pre-order: ");
		if(root==null) return;
        Stack<TreeNode> s=new Stack<>();
        while (!s.isEmpty()||root!=null){
            while(root!=null){
                System.out.print(root.val+" ");
                s.push(root);
                root=root.left;
            }
            if(!s.isEmpty()){
                TreeNode t=s.pop();
                root=t.right;
            }
        }
	}

// 中序非递归（左中右），使用一个栈。
// 若节点非空，一路向左下压栈，若节点空，则弹出打印并将右节点压栈继续循环。
public static void inOrderUnRecur(Node head) {
		System.out.print("in-order: ");
		if(root==null) return;
        Stack<TreeNode> s=new Stack<>();
        while (!s.isEmpty()||root!=null){
            while(root!=null){
                s.push(root);
                root=root.left;
            }
            if(!s.isEmpty()){
                TreeNode t = s.pop();
                System.out.print(t.val+" ");
                root=t.right;
            }
        }
	}

// 后续非递归（左右中）。可以使用微调后的前序遍历作为辅助，得到（中右左），循环过程中压栈最后弹出就可以得到（左右中）。
public static void posOrderUnRecur1(Node head) {
		System.out.print("pos-order: ");
		if (head != null) {
			Stack<Node> s1 = new Stack<Node>();
			Stack<Node> s2 = new Stack<Node>();
			s1.push(head);
			while (!s1.isEmpty()) {
				head = s1.pop();
				s2.push(head);
				if (head.left != null) {
					s1.push(head.left);
				}
				if (head.right != null) {
					s1.push(head.right);
				}
			}
			while (!s2.isEmpty()) {
				System.out.print(s2.pop().value + " ");
			}
		}
	}

3.层次遍历

// 层次遍历，用队列保存每个节点的左右子节点。
public static void level (Node node) {
        if (node == null) {
            return;
        }
        List<Node> list = new ArrayList<Node>();
        list.add(node);
        while (!list.isEmpty()) {
            Node temp = list.remove(0);
            System.out.println(temp.value);
            if (temp.left !=  null) {
                list.add(temp.left);
            }
            if (temp.right != null) {
                list.add(temp.right);
            }
        }
    }