二叉树
这是一个例子：
image.png
二叉树树的遍历方式有两种，深度优先遍历（Depth First Search）和广度优先遍历（Bread First Search）。深度的话就是一条路能走就先走到头，然后再走另外一条路，关于左右走哪条路的顺序不同，分为先根，中根，后根三种；而广度顾名思义就是一层一层的往下遍历，在这一层彻底找完了再往下一层遍历。
中序遍历
思路
即遍历顺序为中根序，左根右，如上图例子的顺序即为：2,5,6,11,7,2,5,4,9
递归算法很容易想到，先递归调用左子树，再输出自身值，再递归调用右子树。
一切递归算法都能转化成非递归算法。中序遍历的非递归算法稍微复杂一点，但大概思路就是把递归的函数栈转化实际编程语言中的对象栈。
申请一个栈，从根节点出发把左子树全部入栈，然后在出栈一个节点的时候，把它的右子树的左节点也全部入栈，其实这个和递归的思路是一模一样的。
递归代码
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
helper(root, res);
return res;
}
private void helper(TreeNode root, List<Integer> res) {
if (root == null) return;
helper(root.left, res);
res.add(root.val);
helper(root.right, res);
}
}
非递归代码
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
TreeNode ptr = root;
Stack<TreeNode> stack = new Stack();
while (ptr != null) { // 入栈所有左子树
stack.push(ptr);
ptr = ptr.left;
}
List<Integer> result = new LinkedList<>();
while (stack.size() != 0) {
TreeNode node = stack.pop();
result.add(node.val);
if (node.right != null){ // 以右节点为根，开始递归
ptr = node.right;
while (ptr != null) {
stack.push(ptr);
ptr = ptr.left;
}
}
}
return result;
}
}
先序遍历
即遍历顺序为先根序，根左右，如上图例子的顺序即为：2,7,2,6,5,11,5,9,4。
递归算法思路也很直接，先输出自身，然后递归输出左子树，再递归输出右子树即可。
非递归算法思路和中序遍历差不多，参考递归的思路，应该先输出自身，然后再把左节点全部入栈，循环到底，然后挨个出栈对右节点当做一个根节点执行类似递归的操作。
递归代码
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
helper(root, res);
return res;
}
private void helper(TreeNode root, List<Integer> res) {
if (root == null) return;
res.add(root.val);
helper(root.left, res);
helper(root.right, res);
}
}
非递归代码
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
TreeNode ptr = root;
List<Integer> result = new LinkedList<>();
Stack<TreeNode> stack = new Stack();
while (ptr != null) {
result.add(ptr.val);
stack.push(ptr);
ptr = ptr.left;
}
while (stack.size() != 0) {
TreeNode node = stack.pop();
if (node.right != null){
ptr = node.right;
while (ptr != null) {
result.add(ptr.val);
stack.push(ptr);
ptr = ptr.left;
}
}
}
return result;
}
}
后序遍历
思路
后序遍历即后跟顺序：左右根，上图例中的二叉树后序遍历结果为：2,5,11,6,7,4,9,5,2
递归思路和上面两种顺序一样，先递归左子树，再递归右子树，再输出自身即可。
非递归稍稍复杂一点，和中序先序不同的地方在于，这个顺序的左和右之间没有指针相连。把最左路线上的节点全部入栈之后，出栈一个有右子树的左节点，不能直接输出它而是得等其右子树全部输出完成之后才能输出，所以我们需要再把这个节点扔进去，但是怎么区分是第一次扔进去的，还是第二次扔进去的呢？如果区分不了就会死循环，两种方式：
- 添加一块其余的空间，比如 map，或者在节点上加个 Flag，来记忆
- 再取出一个节点的右子树后，将其右子树清空，这样遇到空右子树的节点我们就直接输出就好了，不过这样的问题在于会破坏原始树的结构
递归代码
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
helper(root, res);
return res;
}
private void helper(TreeNode root, List<Integer> res) {
if (root == null) return;
helper(root.left, res);
helper(root.right, res);
res.add(root.val);
}
}
非递归代码
public List<Integer> postorderTraversal(TreeNode root) {
TreeNode ptr = root;
List<Integer> result = new LinkedList<>();
Stack<TreeNode> stack = new Stack();
while (ptr != null) {
stack.push(ptr);
ptr = ptr.left;
}
while (stack.size() != 0) {
TreeNode node = stack.pop();
if (node.right == null){
result.add(node.val);
continue;
}
ptr = node.right;
node.right = null; // 把根节点再扔回栈里面，通过有无右子树区分是第一次还是第二次入栈
stack.add(node);
while (ptr != null) {
stack.push(ptr);
ptr = ptr.left;
}
}
return result;
}
层次遍历
思路
非递归的解法，思路很简单，通过队列先入先出的特性来实现，从根节点出发，输出，左节点入队，右节点入队，把下一层的节点取出来，输出，然后分别入队左右节点，直到最后队列空了，意味着到了底层，遍历完毕。
还有一种深度优先的递归解法，把层数传下去，先根或者中根序遍历时维护这一层的全局数组即可。
DFS 递归代码
class Solution {
public List<List<Integer>> result = new LinkedList<>();
public List<List<Integer>> levelOrder(TreeNode root) {
helper(0, root);
return result;
}
public void helper(int level, TreeNode root) {
if (root == null) {
return;
}
if (result.size() <= level) {
result.add(new LinkedList<>());
}
result.get(level).add(root.val);
helper(level + 1, root.left);
helper(level + 1, root.right);
}
}
BFS 非递归代码
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> result = new LinkedList<>();
if (root ==null){
return result;
}
List<TreeNode> list = new LinkedList<>();
list.add(root);
while (!list.isEmpty()) {
List<Integer> level = new LinkedList<>();
int size = list.size();
for (int i = 0; i < size; i++) { // 取出一层所有的节点
TreeNode node = list.remove(0);
level.add(node.val); // 输出
if (node.left != null) {
list.add(node.left); // 左节点入队，如果有的话
}
if (node.right != null) {
list.add(node.right); // 右节点入队，如果有的话
}
}
result.add(level);
}
return result;
}
}
之字形遍历
这是层次遍历的变种，想当于层次遍历的偶数层需要反序，所以我们只需要知道当前层的奇偶即可。
以层次遍历 BFS 的解法为基础，我们只需要加入如下一段即可：
if (result.size() % 2 == 1){ // 在加入结果前判断一下已有长度是不是奇数，是的话这一层就是偶数，反转一下即可。
Collections.reverse(level);
}
完整代码：
class Solution {
public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
List<List<Integer>> result = new LinkedList<>();
if (root ==null){
return result;
}
List<TreeNode> list = new LinkedList<>();
list.add(root);
while (!list.isEmpty()) {
List<Integer> level = new LinkedList<>();
int size = list.size();
for (int i = 0; i < size; i++) {
TreeNode node = list.remove(0);
if (node.left != null) {
list.add(node.left);
}
if (node.right != null) {
list.add(node.right);
}
level.add(node.val);
}
if (result.size() % 2 == 1){
Collections.reverse(level);
}
result.add(level);
}
return result;
}
}
