遍历是数据结构进行增删改查的基础，下面对树这种数据结构的遍历进行总结，并给出算法模板。
深度优先遍历
所有遍历都可以拆分成独立的子遍历，并且这种遍历都具有回溯性。所以都可以采用两种方式进行遍历。给出伪代码模板。
递归：
public void transversal(TreeNode root){
if(root == null){
return;
}
//..operation..//
transverseOne();
//..operation..//
transverseAnother();
//..operation..//
}
栈：
public List<Integer> transversal(TreeNode root){
List<Integer> res = new ArrayList<>();
if(root == null){
return res;
}
//因为使用栈存在重复回溯的问题所以就使用记事本记录
HashSet<TreeNode> accessed = new HashSet<>();
Stack<TreeNode> stack = new Stack<>();
stack.add(root);
while (!stack.isEmpty()) {
TreeNode current = stack.pop();
if(accessed.contains(current)){
res.add(current.val);
continue;
}
//添加最后弹出来的节点
addLastPopNode();
//添加第二个弹出来的节点
addSecondPopNode();
//添加第一个弹出来的节点
addFirstPopNode();
}
return res;
}
前序遍历
前序遍历顺序遵循：根-左-右的顺序
//增加了一个res记录节点值
public void preOrderTransversal(TreeNode root, List<Integer> res){
if(root == null){
return;
}
//记录根节点值操作
res.add(root.val);
//transverseOne();
transverse(root.left,res);
//transverseAnother();
transverse(root.right,res);
}
栈：
public List<Integer> preOrderTransversal(TreeNode root){
List<Integer> res = new ArrayList<>();
if(root == null){
return res;
}
//因为使用栈存在重复回溯的问题所以就使用记事本记录
//前序遍历，添加accessed和判断逻辑是连接在一起的所以可以省略
HashSet<TreeNode> accessed = new HashSet<>();
Stack<TreeNode> stack = new Stack<>();
stack.add(root);
while (!stack.isEmpty()) {
TreeNode current = stack.pop();
if(accessed.contains(current)){
res.add(current.val);
continue;
}
//添加最后弹出来的节点 addLastPopNode();
if(current.right != null){
stack.add(current.right);
}
//添加第二个弹出来的节点 addSecondPopNode();
if(current.left != null){
stack.add(current.left);
}
//添加第一个弹出来的节点 addFirstPopNode();
stack.add(current);
//记录回溯
accessed.add(current);
}
return res;
}
中序遍历
前序遍历顺序遵循：左-根-右的顺序
//增加了一个res记录节点值
public void inOrderTransversal(TreeNode root, List<Integer> res){
if(root == null){
return;
}
//transverseOne();
transverse(root.left,res);
//记录根节点值操作
res.add(root.val);
//transverseAnother();
transverse(root.right,res);
}
栈：
public List<Integer> inOrderTransversal(TreeNode root){
List<Integer> res = new ArrayList<>();
if(root == null){
return res;
}
//因为使用栈存在重复回溯的问题所以就使用记事本记录
//前序遍历，添加accessed和判断逻辑是连接在一起的所以可以省略
HashSet<TreeNode> accessed = new HashSet<>();
Stack<TreeNode> stack = new Stack<>();
stack.add(root);
while (!stack.isEmpty()) {
TreeNode current = stack.pop();
if(accessed.contains(current)){
res.add(current.val);
continue;
}
//添加最后弹出来的节点 addLastPopNode();
if(current.right != null){
stack.add(current.right);
}
//添加第二个弹出来的节点 addSecondPopNode();
stack.add(current);
//记录回溯
accessed.add(current);
//添加第一个弹出来的节点 addFirstPopNode();
if(current.left != null){
stack.add(current.left);
}
}
return res;
}
后序遍历
前序遍历顺序遵循：左-右-根的顺序
//增加了一个res记录节点值
public void postOrderTransversal(TreeNode root, List<Integer> res){
if(root == null){
return;
}
//transverseOne();
transverse(root.left,res);
//transverseAnother();
transverse(root.right,res);
//记录根节点值操作
res.add(root.val);
}
栈：
public List<Integer> postOrderTransversal(TreeNode root){
List<Integer> res = new ArrayList<>();
if(root == null){
return res;
}
//因为使用栈存在重复回溯的问题所以就使用记事本记录
//前序遍历，添加accessed和判断逻辑是连接在一起的所以可以省略
HashSet<TreeNode> accessed = new HashSet<>();
Stack<TreeNode> stack = new Stack<>();
stack.add(root);
while (!stack.isEmpty()) {
TreeNode current = stack.pop();
if(accessed.contains(current)){
res.add(current.val);
continue;
}
//添加最后弹出来的节点 addLastPopNode();
stack.add(current);
accessed.add(current);//记录回溯
//添加第二个弹出来的节点 addSecondPopNode();
if(current.right != null){
stack.add(current.right);
}
//添加第一个弹出来的节点 addFirstPopNode();
if(current.left != null){
stack.add(current.left);
}
}
return res;
}
使用遍历模板方便记忆、高速套用。举一反三，扩展N叉树以及问题也迎刃而解。
广度优先遍历
层序遍历
层序遍历是一层层的遍历树，符合队列的顺序。
队列：
public void levelOrderTraversal(TreeNode root){
if(root == null){
return;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while(!queue.isEmpty()){
TreeNode current = queue.poll();
System.out.println(current.val);
if(current.left != null){
queue.offer(current.left);
}
if(current.right != null){
queue.offer(current.right);
}
}
}
加个盐，将每层的数据汇总
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> res = new ArrayList<>();
if (root == null) {
return res;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
List<Integer> item = new ArrayList<>();
int size = queue.size();
for (int i = 0; i < size; i++) {
TreeNode current = queue.poll();
item.add(current.val);
if (current.left != null){
queue.offer(current.left);
}
if (current.right != null){
queue.offer(current.right);
}
}
res.add(item);
}
return res;
}
问题转化的方式，本质不是层序遍历，在遍历到每层的时候，通过递增的层级标记获取对应存储位置，达到了同样的效果。所以严格的讲这是通过深度优先的方式解决了同样的问题，也不失为一种巧妙的思维方式但是不属于层序遍历。
public List<List<Integer>> levelOrderTraversal(TreeNode root){
List<List<Integer>> res = new ArrayList<>();
if(root == null){
return res;
}
levelOrderTraversalHelper(root,res,0);
return res;
}
public void levelOrderTraversalHelper(TreeNode node,List<List<Integer>> res ,int level){
if(node == null){
return;
}
if(res.size() <= level){
res.add(new ArrayList<>());
}
res.get(level).add(node.val);
levelOrderTraversalHelper(node.left,res,level+1);
levelOrderTraversalHelper(node.right,res,level+1);
}
leetcode 题目汇总：
