二叉树的先序、中序、后序遍历

1.先序遍历

package test;
import java.util.ArrayList;
import java.util.LinkedList;

class TreeNode {
	int val;
	TreeNode left = null;
	TreeNode right = null;
	TreeNode(int val) {
		this.val = val;
	}
}
public class Test {
	public static void preOrder(TreeNode root) {
		LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
		if(root == null) return;
		
		ArrayList<Integer> val = new ArrayList<Integer>();
		stack.push(root);
		TreeNode tmp = null;
		
		while(!stack.isEmpty()) {
			tmp = stack.pop();
			val.add(tmp.val);
			
			// 先添加右结点，然后添加左结点
			if(tmp.right != null) {
				stack.push(tmp.right);
			}
			
			if(tmp.left != null) {
				stack.push(tmp.left);
			}
			
		}
		
	for (Integer t : val) {
		System.out.print(t + " ");
	}
	}

	public static void main(String[] args) {
		TreeNode t1 = new TreeNode(1);
		TreeNode t2 = new TreeNode(2);
		TreeNode t3 = new TreeNode(3);
		TreeNode t4 = new TreeNode(4);
		TreeNode t5 = new TreeNode(5);
		TreeNode t6 = new TreeNode(6);
		TreeNode t7 = new TreeNode(7);
		t1.left = t2;
		t1.right = t3;
		t2.left = t4;
		t2.right = t5;
		t3.right = t7;
		preOrder(t1);
	}

}

时间复杂度为O(n),空间复杂度为O(n)

2.中序遍历

package test;
import java.util.ArrayList;
import java.util.LinkedList;

class TreeNode {
	int val;
	TreeNode left = null;
	TreeNode right = null;
	TreeNode(int val) {
		this.val = val;
	}
}
public class Test {
	public static void preOrder(TreeNode root) {
		LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
		if(root == null) return;
		
		ArrayList<Integer> val = new ArrayList<Integer>();
		TreeNode tmp = root;
		
		while(!stack.isEmpty() || tmp != null) {
			while (tmp != null) {
				stack.push(tmp);
				tmp = tmp.left;
			}
			// 有可能
			if (!stack.isEmpty()) {
				tmp = stack.pop();
				val.add(tmp.val);
				tmp = tmp.right;
				
			}
		}
		
		for (Integer t : val) {
			System.out.print(t + " ");
		}
	}

	public static void main(String[] args) {
		TreeNode t1 = new TreeNode(1);
		TreeNode t2 = new TreeNode(2);
		TreeNode t3 = new TreeNode(3);
		TreeNode t4 = new TreeNode(4);
		TreeNode t5 = new TreeNode(5);
		TreeNode t6 = new TreeNode(6);
		TreeNode t7 = new TreeNode(7);
		t1.left = t2;
		t1.right = t3;
		t2.left = t4;
		t2.right = t5;
		t3.right = t7;
		preOrder(t1);
	}

}

3.后序遍历

package test;
import java.util.ArrayList;
import java.util.LinkedList;

class TreeNode {
	int val;
	TreeNode left = null;
	TreeNode right = null;
	TreeNode(int val) {
		this.val = val;
	}
}
public class Test {
	public static void preOrder(TreeNode root) {
		LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
		// 按照栈来存储元素的，所以呢，你也得按照栈来存放访问的boolean
		LinkedList<Boolean> judge = new LinkedList<Boolean>();
		if(root == null) return;
		
		ArrayList<Integer> val = new ArrayList<Integer>();
		
		TreeNode tmp = root;
		
		while(!stack.isEmpty() || tmp != null) {
			while (tmp != null) {
				stack.push(tmp);
				judge.push(true);
				tmp = tmp.left;
			}
			// 只要他有两个判断条件，所以需要isEmpty()
			// 第一次遇到的时候不添加val，第二次才会添加val
			if (!stack.isEmpty()) {
				tmp = stack.pop();
				if(judge.pop()) {
					// 第一次出去了，是因为要判断，但是他不否和要求，所以还得进来
					stack.push(tmp);
					judge.push(false);
					tmp = tmp.right;
				} else {
					val.add(tmp.val);
					tmp = null;
				}
			}
		}
		
		for (Integer t : val) {
			System.out.print(t + " ");
		}
	}

	public static void main(String[] args) {
		TreeNode t1 = new TreeNode(1);
		TreeNode t2 = new TreeNode(2);
		TreeNode t3 = new TreeNode(3);
		TreeNode t4 = new TreeNode(4);
		TreeNode t5 = new TreeNode(5);
		TreeNode t6 = new TreeNode(6);
		TreeNode t7 = new TreeNode(7);
		t1.left = t2;
		t1.right = t3;
		t2.left = t4;
		t2.right = t5;
		t3.right = t7;
		preOrder(t1);
	}

}