剑指offer 树

二叉树

完全二叉树

堆

二叉搜索树

AVL树

红黑树

Trie树

遍历

1.1 题目（面试题23）：分层打印二叉树

解法一：广度优先，借助队列数据结构

public class Solution {
public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
ArrayList<Integer> array=new ArrayList<Integer>();
if(root==null)
return array;
Queue<TreeNode> q=new LinkedList<TreeNode>();
q.offer(root);
while(!q.isEmpty()){
TreeNode temp=q.poll();
array.add(temp.val);
if(temp.left!=null){
q.offer(temp.left);
}
if(temp.right!=null){
q.offer(temp.right);
}
}
return array;
}
}

相关题目

题目1：分层打印成多行

public class Solution {
ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
ArrayList<ArrayList<Integer> > result=new ArrayList<ArrayList<Integer> > ();
if(pRoot==null)
return result;

Queue<TreeNode> q= new LinkedList<TreeNode>();
q.offer(pRoot);

while(!q.isEmpty()){
int start=0;
int end=q.size();
ArrayList<Integer> temp=new ArrayList<Integer>();

while(start<end){
TreeNode node=q.poll();
temp.add(node.val);
if(node.left!=null)
q.offer(node.left);
if(node.right!=null)
q.offer(node.right);
start++;
}
result.add(temp);
}
return result;
}
}

题目2：之字形打印二叉树

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

public class Solution {
public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
ArrayList<ArrayList<Integer> > result=new ArrayList<ArrayList<Integer> >();
if(pRoot==null)
return result;

Queue<TreeNode> q=new LinkedList<TreeNode>();
q.offer(pRoot);
int count=1;
while(!q.isEmpty()){
int start=0;
int end=q.size();
ArrayList<Integer> temp= new ArrayList<Integer>();
while(start<end){
TreeNode node=q.poll();
temp.add(node.val);
if(node.left!=null)
q.offer(node.left);
if(node.right!=null)
q.offer(node.right);
start++;
}
if(count%2==1)
result.add(temp);
else{
result.add(reverse(temp));
}
count++;
}
return result;
}

private  ArrayList<Integer> reverse( ArrayList<Integer> temp){
ArrayList<Integer> result=new ArrayList<Integer>();
for(int i=temp.size()-1;i>=0;i--){
result.add(temp.get(i));
}
return result;
}
}

1.2 题目（面试题6）：重建二叉树

解法一：递归，前序序列和中序序列或者后序序列和中序序列

import java.util.Arrays;
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
if(pre.length!=in.length || pre==null || in==null)
return null;
if(pre.length==0 && in.length==0)
return null;

TreeNode root=new TreeNode(pre[0]);
if(in.length==1)
return root;
int i=0;
for(;i<in.length;i++){
if(in[i]==root.val)
break;
}
if(i>0)
root.left=reConstructBinaryTree(Arrays.copyOfRange(pre,1,i+1),Arrays.copyOfRange(in,0,i));
if(i<in.length-1)
root.right=reConstructBinaryTree(Arrays.copyOfRange(pre,i+1,pre.length),Arrays.copyOfRange(in,i+1,in.length));
return root;
}
}

1.3 题目（面试题24）：二叉搜索树的后续遍历序列

import java.util.Arrays;
public class Solution {
public boolean VerifySquenceOfBST(int [] sequence) {
int len=sequence.length;
if(len==0 || sequence==null)
return false;
int root=sequence[len-1];
int i=0;
for(;i<len-1;i++){
if(sequence[i]>root)
break;
}
int j=i;
for(;j<len-1;j++){
if(sequence[j]<root)
return false;
}
boolean left=true;
boolean right=true;
if(i>0){
left=VerifySquenceOfBST(Arrays.copyOfRange(sequence, 0, i));
}
if(i<sequence.length-1)
right=VerifySquenceOfBST(Arrays.copyOfRange(sequence, i, sequence.length-1));
return (left && right);
}
}

相关题目：

输入一个数组，判断该数组是不是某二叉搜索树的前序遍历结果

1.4 题目（面试题58）：二叉树的下一个结点
1.5 题目（面试题64）：二叉搜索树的第K个结点
解法一：前序序列

public class Solution {
int k;
TreeNode KthNode(TreeNode pRoot, int k)
{
if(pRoot==null || k==0)
return null;
this.k=k;
return KthNodeRec(pRoot);
}
TreeNode KthNodeRec(TreeNode pRoot){
TreeNode target=null;
if(pRoot.left!=null)
target=KthNode(pRoot.left,k);
if(target==null){
if(k==1)
return target=pRoot;
k--;
}
if(target==null && pRoot.right!=null)
target=KthNode(pRoot.right,k);
return target;
}
}

查找

2.1 题目（面试题18）：树的子结构
解法一：前序遍历两个树，然后判断是否包含，空间复杂度是O(m+n);

import java.util.ArrayList;
public class Solution {
public boolean HasSubtree(TreeNode root1,TreeNode root2) {
if((root1==null)||(root2==null))
return false;
ArrayList<Integer> array1=new ArrayList<Integer>();

ArrayList<Integer> array2=new ArrayList<Integer>();

array1=preOrder(root1);
array2=preOrder(root2);

if(array1.containsAll(array2))
return true;
return false;
}

private ArrayList<Integer> preOrder(TreeNode root){
if(root==null)
return null;
ArrayList<Integer> temp=new ArrayList<Integer>();
temp.add(root.val);
ArrayList<Integer> left=preOrder(root.left);
if(left!=null)
temp.addAll(left);
ArrayList<Integer> right=preOrder(root.right);
if(right!=null)
temp.addAll(right);
return temp;
}
}

解法二：递归解法，空间复杂度低

public class Solution {
public boolean HasSubtree(TreeNode root1,TreeNode root2) {
boolean result=false;
if(root1!=null && root2!=null){
if(root1.val==root2.val){
result=DoTree1HasTree2(root1,root2);
}
if(!result){
result=HasSubtree(root1.left,root2);
}
if(!result){
result=HasSubtree(root1.right,root2);
}
}
return result;
}
private boolean DoTree1HasTree2(TreeNode root1,TreeNode root2){
if(root2==null){
return true;
}
if(root1==null)
return false;
if(root1.val!=root2.val){
return false;
}
return DoTree1HasTree2(root1.left,root2.left)&&DoTree1HasTree2(root1.right,root2.right);
}
}

2.2 题目（面试题19）：二叉树的镜像

解法一：递归实现

public class Solution {
public void Mirror(TreeNode root) {
if(root==null)
return;
if(root.left==null && root.right==null)
return;
else {
TreeNode temp=root.right;
root.right=root.left;
root.left=temp;
Mirror(root.left);
Mirror(root.right);
}
}
}

相关题目：

题目1：对称二叉树，二叉树和它的镜像一样则为对称

public class Solution {
boolean isSymmetrical(TreeNode pRoot)
{
if(pRoot==null)
return true;
return rec(pRoot.left,pRoot.right);
}
private boolean rec(TreeNode left, TreeNode right){
if(left==null && right==null)
return true;
else if(left==null || right==null)
return false;
else if(left.val!=right.val)
return false;
return rec(left.right, right.left) && rec(left.left, right.right);
}
}

2.3 题目（面试题25）：二叉树中和为某一值的路径

public class Solution {
public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
ArrayList<ArrayList<Integer>> pathlist=new ArrayList<ArrayList<Integer>>();
if(root==null)
return pathlist;
Stack<Integer> stack=new Stack<Integer>();
FindPath(root,target,stack,pathlist);
return pathlist;
}

private void FindPath(TreeNode root,int target,Stack<Integer> path,ArrayList<ArrayList<Integer>> pathlist){
if(root==null)
return;
if(root.left==null && root.right==null){
if(root.val==target){
ArrayList<Integer> list= new ArrayList<Integer>();
for(int p:path){
list.add(new Integer(p));
}
list.add(new Integer(root.val));
pathlist.add(list);
}
}
else{
path.push(new Integer(root.val));
FindPath(root.left,target-root.val,path,pathlist);
FindPath(root.right,target-root.val,path,pathlist);
path.pop();
}
}
}

2.4 题目（面试题39）：二叉树的深度，最长的路径

public class Solution {
public int TreeDepth(TreeNode root) {
if(root==null)
return 0;
TreeNode left=root.left;
TreeNode right=root.right;
return Math.max(1+TreeDepth(left),1+TreeDepth(right));
}
}

相关题目：

题目1：平衡二叉树

解法一：基于二叉树的深度递归解法；

解法二：基于后序遍历的解法；

2.5 题目（面试题50）：最低公共祖先

2.6 题目（面试题27）：二叉搜索树与双向链表

方法二：递归版
解题思路：
1.将左子树构造成双链表，并返回链表头节点。
2.定位至左子树双链表最后一个节点。
3.如果左子树链表不为空的话，将当前root追加到左子树链表。
4.将右子树构造成双链表，并返回链表头节点。
5.如果右子树链表不为空的话，将该链表追加到root节点之后。
6.根据左子树链表是否为空确定返回的节点。
public TreeNode Convert(TreeNode root) {
if(root==null)
return null;
if(root.left==null&&root.right==null)
return root;
// 1.将左子树构造成双链表，并返回链表头节点
TreeNode left = Convert(root.left);
TreeNode p = left;
// 2.定位至左子树双链表最后一个节点
while(p!=null&&p.right!=null){
p = p.right;
}
// 3.如果左子树链表不为空的话，将当前root追加到左子树链表
if(left!=null){
p.right = root;
root.left = p;
}
// 4.将右子树构造成双链表，并返回链表头节点
TreeNode right = Convert(root.right);
// 5.如果右子树链表不为空的话，将该链表追加到root节点之后
if(right!=null){
right.left = root;
root.right = right;
}
return left!=null?left:root;
}
方法三：改进递归版
解题思路：
思路与方法二中的递归版一致，仅对第2点中的定位作了修改，新增一个全局变量记录左子树的最后一个节点。
// 记录子树链表的最后一个节点，终结点只可能为只含左子树的非叶节点与叶节点
protected TreeNode leftLast = null;
public TreeNode Convert(TreeNode root) {
if(root==null)
return null;
if(root.left==null&&root.right==null){
leftLast = root;// 最后的一个节点可能为最右侧的叶节点
return root;
}
// 1.将左子树构造成双链表，并返回链表头节点
TreeNode left = Convert(root.left);
// 3.如果左子树链表不为空的话，将当前root追加到左子树链表
if(left!=null){
leftLast.right = root;
root.left = leftLast;
}
leftLast = root;// 当根节点只含左子树时，则该根节点为最后一个节点
// 4.将右子树构造成双链表，并返回链表头节点
TreeNode right = Convert(root.right);
// 5.如果右子树链表不为空的话，将该链表追加到root节点之后
if(right!=null){
right.left = root;
root.right = right;
}
return left!=null?left:root;
}