二叉树的遍历总结
二叉树是一种非常常用的数据结构,也是面试的热门词。而二叉树最常见的考点莫过于遍历,剑指offer的第60页介绍树时也着重强调了二叉树遍历的重要性,但书中并未实现。本文将完整地实现二叉树遍历。
方法名称 | 主要功能更呢 |
---|---|
preorderRecursively | 前序遍历递归版 |
inorderRecursively | 中序遍历递归版 |
postorderRecursively | 后序遍历递归版 |
preorderIteratively | 前序遍历非递归版 |
inorderIteratively | 中序遍历非递归版 |
postorderIteratively | 后序遍历非递归版 |
levelorder | 层序遍历/宽度优先遍历 |
Java参考代码如下:
package chapter2;
import java.util.*;
public class P60_TraversalOfBinaryTree {
public static class TreeNode{
int val;
TreeNode left;
TreeNode right;
TreeNode(int val){
this.val=val;
this.left=null;
this.right=null;
}
}
//前序遍历递归版
public static ArrayList<Integer> preorderRecursively(TreeNode root){//递归
ArrayList<Integer> result=new ArrayList<>();
preoder(root,result);
return result;
}
public static void preoder(TreeNode root,ArrayList<Integer> result){
if(root==null) return;
result.add(root.val);
if(root.left!=null) preoder(root.left,result);
if(root.right!=null) preoder(root.right,result);
}
//中序遍历递归版
public static ArrayList<Integer> inorderRecursively(TreeNode root){
ArrayList<Integer> result=new ArrayList<>();
inorder(root,result);
return result;
}
public static void inorder(TreeNode root,ArrayList<Integer> result){//递归
if(root==null) return;
if(root.left!=null) inorder(root.left,result);
result.add(root.val);
if(root.right!=null) inorder(root.right,result);
}
//后序遍历递归版
public static ArrayList<Integer> postorderRecursively(TreeNode root){
ArrayList<Integer> result=new ArrayList<>();
postorder(root,result);
return result;
}
public static void postorder(TreeNode root,ArrayList<Integer> result){//递归
if(root==null) return;
if(root.left!=null) postorder(root.left,result);
if(root.right!=null) postorder(root.right,result);
result.add(root.val);
}
//前序遍历非递归版
public static ArrayList<Integer> preorderIteratively(TreeNode root){//非递归
ArrayList<Integer> result=new ArrayList<>();
Stack<TreeNode> stack=new Stack<>();//ArrayDeque.addFirst\.pollFirst
TreeNode p=root;
while (!stack.isEmpty()||p!=null){
if(p!=null){
stack.add(p);
result.add(p.val);
p=p.left;
}else {
TreeNode t=stack.pop();
p=t.right;
}
}
return result;
}
//中序遍历非递归版
public static ArrayList<Integer> inorderIteratively(TreeNode root){//非递归
ArrayList<Integer> result=new ArrayList<>();
Stack<TreeNode> stack=new Stack<>();//ArrayDeque.addFirst\.pollFirst
TreeNode p=root;
while(!stack.isEmpty()||p!=null){
if(p!=null){
stack.add(p);
p=p.left;
}else {
TreeNode t=stack.pop();
result.add(t.val);
p=t.right;
}
}
return result;
}
//后序遍历非递归版
public static ArrayList<Integer> postorderIteratively(TreeNode root){//非递归
ArrayList<Integer> result=new ArrayList<>();
Stack<TreeNode> stack=new Stack<>();//ArrayDeque.addFirst\.pollFirst
TreeNode p=root;
while(!stack.isEmpty()||p!=null){
if(p!=null){
stack.add(p);
result.add(0,p.val);//从头插入,可用ArrayDeque,addFirst快。
p=p.right;
}else {
TreeNode t=stack.pop();
p=t.left;
}
}
return result;
}
//层序遍历
public static ArrayList<Integer> levelorder(TreeNode root){
ArrayList<Integer> result=new ArrayList<>();
ArrayDeque<TreeNode> queue=new ArrayDeque<>();
queue.addLast(root);
while (!queue.isEmpty()){
//for(int i=queue.size();i>=0;i--)//level
TreeNode p=queue.pollFirst();
result.add(p.val);
if(p.left!=null)
queue.addLast(p.left);
if(p.right!=null)
queue.addLast(p.right);
}
return result;
}
public static void main(String[] args){
TreeNode root=new TreeNode(1);
root.left=new TreeNode(2);
root.right=new TreeNode(3);
root.left.left=new TreeNode(4);
root.left.right=new TreeNode(5);
root.right.left=new TreeNode(6);
root.right.right=new TreeNode(7);
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());
}
}
参考:
https://www.jianshu.com/p/362d4ff42ab2
http://www.cnblogs.com/grandyang/p/4146981.html
http://www.cnblogs.com/grandyang/p/4297300.html