二叉樹是一種非常常用的數據結構，也是面試的熱門詞。而二叉樹最常見的考點莫過于遍歷，劍指offer的第60頁介紹樹時也著重強調了二叉樹遍歷的重要性，但書中并未實現。本文將完整地實現二叉樹遍歷。
主要內容介紹：
| 方法名稱 | 主要功能 |
|---|---|
| preorderRecursively | 前序遍歷遞歸版 |
| inorderRecursively | 中序遍歷遞歸版 |
| postorderRecursively | 后序遍歷遞歸版 |
| preorderIteratively | 前序遍歷非遞歸版 |
| inorderIteratively | 中序遍歷非遞歸版 |
| postorderIteratively | 后序遍歷非遞歸版 |
| levelorder | 層序遍歷/寬度優先遍歷 |
package structure;
/**
* Created by ryder on 2017/6/12.
* 樹節點
*/
public class TreeNode<T> {
public T val;
public TreeNode<T> left;
public TreeNode<T> right;
public TreeNode(T val){
this.val = val;
this.left = null;
this.right = null;
}
}
package chapter2;
import structure.TreeNode;
import java.util.*;
/**
* Created by ryder on 2017/6/13.
* 二叉樹的遍歷：
* 前序（遞歸，非遞歸），中序（遞歸，非遞歸），后序（遞歸，非遞歸），層序
*/
public class P60_TraversalOfBinaryTree {
//前序遍歷遞歸版
public static List<Integer> preorderRecursively(TreeNode<Integer> node){
List<Integer> list = new ArrayList<>();
if(node==null)
return list;
list.add(node.val);
list.addAll(preorderRecursively(node.left));
list.addAll(preorderRecursively(node.right));
return list;
}
//中序遍歷遞歸版
public static List<Integer> inorderRecursively(TreeNode<Integer> node){
List<Integer> list = new ArrayList<>();
if(node==null)
return list;
list.addAll(inorderRecursively(node.left));
list.add(node.val);
list.addAll(inorderRecursively(node.right));
return list;
}
//后序遍歷遞歸版
public static List<Integer> postorderRecursively(TreeNode<Integer> node){
List<Integer> list = new ArrayList<>();
if(node==null)
return list;
list.addAll(postorderRecursively(node.left));
list.addAll(postorderRecursively(node.right));
list.add(node.val);
return list;
}
//前序遍歷非遞歸版
public static List<Integer> preorderIteratively(TreeNode<Integer> node){
//stack棧頂元素永遠為cur的父節點
Stack<TreeNode<Integer>> stack = new Stack<>();
TreeNode<Integer> cur = node;
List<Integer> list = new LinkedList<>();
if(node==null)
return list;
while(cur!=null || !stack.isEmpty()){
if(cur!=null){
list.add(cur.val);
stack.push(cur);
cur = cur.left;
}
else{
cur = stack.pop().right;
}
}
return list;
}
//中序遍歷非遞歸版
public static List<Integer> inorderIteratively(TreeNode<Integer> node){
//stack棧頂元素永遠為cur的父節點
Stack<TreeNode<Integer>> stack = new Stack<>();
TreeNode<Integer> cur = node;
List<Integer> list = new LinkedList<>();
while(cur!=null || !stack.isEmpty()){
if(cur!=null){
stack.push(cur);
cur = cur.left;
}
else{
list.add(stack.peek().val);
cur = stack.pop().right;
}
}
return list;
}
//后序遍歷非遞歸版
public static List<Integer> postorderIteratively(TreeNode<Integer> node){
//stack棧頂元素永遠為cur的父節點
//prevVisted用于區分是從左子樹還是右子樹返回的
Stack<TreeNode<Integer>> stack = new Stack<>();
TreeNode<Integer> cur = node;
TreeNode<Integer> prevVisted = null;
List<Integer> list = new LinkedList<>();
while(cur!=null || !stack.isEmpty()){
if(cur!=null){
stack.push(cur);
cur = cur.left;
}
else{
cur = stack.peek().right;
if(cur!=null && cur!=prevVisted){
stack.push(cur);
cur = cur.left;
}
else{
prevVisted = stack.pop();
list.add(prevVisted.val);
cur = null;
}
}
}
return list;
}
//層序遍歷
public static List<Integer> levelorder(TreeNode<Integer> node){
Queue<TreeNode<Integer>> queue = new LinkedList<>();
List<Integer> list = new LinkedList<>();
TreeNode<Integer> temp = null;
if(node==null)
return list;
queue.add(node);
while(!queue.isEmpty()){
temp = queue.poll();
list.add(temp.val);
if(temp.left!=null)
queue.offer(temp.left);
if(temp.right!=null)
queue.offer(temp.right);
}
return list;
}
public static void main(String[] args){
// 1
// \
// 2
// /
// 3
//pre->123 in->132 post->321 level->123
TreeNode<Integer> root = new TreeNode<Integer>(1);
root.right = new TreeNode<Integer>(2);
root.right.left = new TreeNode<Integer>(3);
List<Integer> list_preorderRecursively = preorderRecursively(root);
System.out.print("preorderRecursively: "+'\t');
System.out.println(list_preorderRecursively.toString());
List<Integer> list_inorderRecursively = inorderRecursively(root);
System.out.print("inorderRecursively: "+'\t');
System.out.println(list_inorderRecursively.toString());
List<Integer> list_postorderRecursively = postorderRecursively(root);
System.out.print("postorderRecursively: "+'\t');
System.out.println(list_postorderRecursively.toString());
System.out.println();
List<Integer> list_preorderIteratively = preorderIteratively(root);
System.out.print("preorderIteratively: "+'\t');
System.out.println(list_preorderIteratively.toString());
List<Integer> list_inorderIteratively = inorderIteratively(root);
System.out.print("inorderIteratively: "+'\t');
System.out.println(list_inorderIteratively.toString());
List<Integer> list_postorderIteratively = postorderIteratively(root);
System.out.print("postorderIteratively: "+'\t');
System.out.println(list_postorderIteratively.toString());
System.out.println();
List<Integer> list_levelorder = levelorder(root);
System.out.print("levelorder: "+'\t');
System.out.println(list_levelorder.toString());
}
}
運行結果
preorderRecursively: [1, 2, 3]
inorderRecursively: [1, 3, 2]
postorderRecursively: [3, 2, 1]
preorderIteratively: [1, 2, 3]
inorderIteratively: [1, 3, 2]
postorderIteratively: [3, 2, 1]
levelorder: [1, 2, 3]
