二叉树的遍历

·1.Binary Tree Preorder Traversal

使用栈，时间复杂度O(n)，空间复杂度O(n)
public List<Integer> preorderTraversal(TreeNode root) {
　ArrayList<Integer> result = new ArrayList<>();
　Stack<TreeNode> s = new Stack<>();
    if (root != null) s.push(root);
    while (!s.isEmpty()) {
        final TreeNode p = s.pop();
    　　result.add(p.val);
    　　if (p.right != null) s.push(p.right);
    　　if (p.left != null) s.push(p.left);
　　}
　　return result;
}

　　

递归先序遍历，时间复杂度O(n)，空间复杂度O(n) 
public static void preOrderRec(Node root){  
　　if(root!=null){  
   　　System.out.println(root.value);  
   　　preOrderRec(root.left);  
   　　preOrderRec(root.right);  
  }  
}  

Morris先序遍历，时间复杂度O(n)，空间复杂度O(1)

步骤：

1.如果当前节点的左孩子为空，则输出当前节点并将其右孩子作为当前节点。

2.如果当前节点的左孩子不为空，在当前节点的左子树中找到当前节点在中序遍历下的前驱节点。

a) 如果前驱节点的右孩子为空，将它的右孩子设置为当前节点。输出当前节点（在这里输出，这是与中序遍历唯一一点不同）。当前节点更新为当前节点的左孩子。

b) 如果前驱节点的右孩子为当前节点，将它的右孩子重新设为空。当前节点更新为当前节点的右孩子。

3.重复以上1、2直到当前节点为空。

​

public List<Integer> preorderTraversal(TreeNode root) {
		ArrayList<Integer> result = new ArrayList<>();
		TreeNode cur = root;
		TreeNode prev = null;

		while (cur != null) {
			if (cur.left == null) {
				result.add(cur.val);
				prev = cur;
				cur = cur.right;
			} else {
				/* 查找前驱 */
				prev = cur.left;
				while (prev.right != null && prev.right != cur) {
					prev = prev.right;
				}

				if (prev.right == null) {	/* 还没线索化，则建立线索 */
					result.add(cur.val); 	/* 仅这一行的位置与中序不同 */
					prev.right = cur;
					prev = cur;		/* cur刚刚被访问过 */
					cur = cur.left;
				} else {			/* 已经线索化，则访问节点，并删除线索 */
					prev.right = null;
					cur = cur.right;
				}
			}
		}
		return result;

	}

 2.Binary Tree Inorder Traversal

使用栈，时间复杂度O(n)，空间复杂度O(n)
public List<Integer> inorderTraversal(TreeNode root) {
    ArrayList<Integer> result = new ArrayList<>();
    Stack<TreeNode> s = new Stack<>();

    TreeNode pNode = root;
    while (!s.isEmpty() || pNode != null) {
	  if (pNode != null) {
		  s.push(pNode);
		  pNode = pNode.left;
	  } else {
		  pNode = s.pop();
		  result.add(pNode.val);
		  pNode = pNode.right;
	  }
    }
    return result;
}

　　

递归中序遍历，时间复杂度O(n)，空间复杂度O(n)
public static void inOrderRec(Node root){  
    if(root!=null){  
        preOrderRec(root.left);  
        System.out.println(root.value);  
         preOrderRec(root.right);  
    }  
}  

 使用栈，时间复杂度O(n)，空间复杂度O(n)

步骤：

1.如果当前节点的左孩子为空，则输出当前节点并将其右孩子作为当前节点。

2.如果当前节点的左孩子不为空，在当前节点的左子树中找到当前节点在中序遍历下的前驱节点。

a) 如果前驱节点的右孩子为空，将它的右孩子设置为当前节点。当前节点更新为当前节点的左孩子。

b) 如果前驱节点的右孩子为当前节点，将它的右孩子重新设为空（恢复树的形状）。输出当前节点。当前节点更新为当前节点的右孩子。

3.重复以上1、2直到当前节点为空。

​

public List<Integer> inorderTraversal1(TreeNode root) {
		ArrayList<Integer> result = new ArrayList<>();
		TreeNode cur = root;
		TreeNode prev = null;

		while (cur != null) {
			if (cur.left == null) {
				result.add(cur.val);
				prev = cur;
				cur = cur.right;
			} else {
				/* 查找前驱 */
				prev = cur.left;
				while (prev.right != null && prev.right != cur) {
					prev = prev.right;
				}

				if (prev.right == null) {/* 还没线索化，则建立线索 */
					prev.right = cur;
					cur = cur.left;
				} else {/* 已经线索化，则访问节点，并删除线索 */
					result.add(cur.val);
					prev.right = null;
					prev = cur; /* cur刚刚被访问过 */
					cur = cur.right;
				}
			}
		}
		return result;

	}

3.Binary Tree Postorder Traversal

 

    使用栈，时间复杂度O(n)，空间复杂度O(n)
    /* p，正在访问的结点，q，刚刚访问过的结点 */
    public static void postOrderRec(Node root){  
		TreeNode p = root;
		TreeNode q = null;
		while (!s.isEmpty()) {
			while (p != null) {
				s.push(p);
				p = p.left;
			}
			q = null;
			while (!s.isEmpty()) {
				p = s.pop();
				if (p.right == q) {
					result.add(p.val);
					q = p;
				} else {
					s.push(p);
					p = p.right;
					break;
				}
			}
		}
    }

递归后序遍历，时间复杂度O(n)，空间复杂度O(n) 
public static void postOrderRec(Node root){  
    if(root!=null){  
        preOrderRec(root.left);  
        preOrderRec(root.right);  
        System.out.println(root.value);  
    }  
}