代码随想录第14天：递归遍历、迭代遍历、统一迭代

前序遍历：前序遍历

递归法：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        preorder(root,list);
        return list;
    }

    void preorder(TreeNode node, List<Integer> list) {
		if (node == null) {
			return;
		}
		list.add(node.val);
		preorder(node.left, list);
		preorder(node.right, list);
	}
}

迭代法：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        if (root==null) {
			return list;
		}
        stack.push(root);
        while (!stack.isEmpty()) {
			TreeNode node = stack.pop();
			list.add(node.val);
			if (node.right!=null) {
				stack.push(node.right);
			}
			if (node.left!=null) {
				stack.push(node.left);
			}
		}
        return list;
    }

}

中序遍历：中序遍历

递归法：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        inorder(root, list);
        return list;
    }
    void inorder(TreeNode node, List<Integer> list) {
		if (node == null) {
			return;
		}
		inorder(node.left, list);
		list.add(node.val);
		inorder(node.right, list);
	}
}

迭代法：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
       List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        if (root==null) {
			return list;
		}
        TreeNode node = root;
        while (node!=null || !stack.isEmpty()) {
			if (node!=null) {
				stack.push(node);
				node = node.left;
			}else {
				node = stack.pop();
				list.add(node.val);
				node = node.right;
			}
		}
        return list;
    }
    
}

后序遍历：后序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        postorder(root, list);
        return list;
    }
    void postorder(TreeNode node, List<Integer> list) {
		if (node == null) {
			return;
		}
		postorder(node.left, list);
		postorder(node.right, list);
		list.add(node.val);
	}
}

迭代法：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        if (root==null) {
			return list;
		}
        stack.push(root);
        while (!stack.isEmpty()) {
			TreeNode node = stack.pop();
			list.add(node.val);
			if (node.left!=null) {
				stack.push(node.left);
			}
			if (node.right!=null) {
				stack.push(node.right);
			}
		}
        Collections.reverse(list);
        return list;
    }
}

统一迭代法：中序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
      	List<Integer> list = new LinkedList<>();
		Stack<TreeNode> stack = new Stack<>();
		if (root!=null) {//把根节点入栈
			stack.push(root);
		}
		while (!stack.isEmpty()) {//当根节点不为空时，继续
			TreeNode node = stack.peek();//node每次指向栈顶元素
			if (node!=null) {//如果栈顶元素不为null
				stack.pop();//每次把栈顶元素弹出，以免重复
				if (node.right!=null) {//当前结点的右结点入栈（如果有的话）
					stack.push(node.right);
				}
				stack.push(node);//当前结点入栈
				stack.push(null);//null入栈
				if (node.left!=null) {//当前结点的左节点入栈
					stack.push(node.left);
				}
			}else {
				stack.pop();//当前结点为空，弹出
				node = stack.peek();//node指向新的栈顶元素
				stack.pop();//栈顶元素出栈
				list.add(node.val);//把当前结点元素加入list
			}
		}
		return list;
    }

}

总结：递归法和统一迭代法在前序、中序和后序遍历中都只有轻微的代码改变，而迭代法需要根据具体的方式有所修改，前序和后序类似。因为栈是先入先出，前序遍历本来是左中右，实际上进行迭代的时候得是右中左，后序遍历在执行一次左中右的遍历后还需要将list进行翻转，中序遍历则相差较大。统一迭代法则只需要稍微改变一下顺序即可，但是具体为啥这样就可行，还没想到是什么样的思路找到如此巧妙的想法使得能够同时适应三个。