剑指——树

简单

二叉树的镜像

操作给定的二叉树，将其变换为源二叉树的镜像。

思路：利用递归将左右子树对调即可

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

二叉树深度

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
**思路：**利用递归，选出左右子树中最长的长度即可。

import java.util.*;
public class Solution {
    public int TreeDepth(TreeNode root) {
        if(root==null)
            return 0;
        int l=TreeDepth(root.left);
        int r=TreeDepth(root.right);
        int result=Math.max(l,r)+1;
        return result;
    }
}

二叉树深度扩充（平衡二叉树）

输入一棵二叉树，判断该二叉树是否是平衡二叉树。
平衡二叉树（Balanced Binary Tree），具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
**思路：**利用递归，计算所有子树是否为平衡二叉树。

import java.util.*;
public class Solution {
	//求二叉树深度的函数（上题）
    public int depth(TreeNode root) {
        if(root==null)
            return 0;
        int l=depth(root.left);
        int r=depth(root.right);
        int result=Math.max(l,r)+1;
        return result;
    }
    
    public boolean IsBalanced_Solution(TreeNode root) {
        if(root==null)
            return true;
        int l=depth(root.left);
        int r=depth(root.right);
        if(l-r>1||l-r<-1)
            return false;
        return IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right);
        }
    }

二叉搜索树的第K个节点

给定一棵二叉搜索树，请找出其中的第k小的结点。
**思路：**利用搜索二叉树的性质，中序遍历获得按序排列的链表，选取节点K+1即可。

import java.util.*;
public class Solution {
    ArrayList<TreeNode> list = new ArrayList<>();
    void addNode(TreeNode root){
        if(root!=null){
            addNode(root.left);
            list.add(root);
            addNode(root.right);
        }
    }
    TreeNode KthNode(TreeNode pRoot, int k){
        addNode(pRoot);
        if(k>=1&&list.size()>=k){
            return list.get(k-1);
        }
        return null;
    }
}

中等

二叉搜索树与双向链表

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
**思路：**利用二叉搜索树的性质，中序排列获得按序排列的链表，再对链表加指针即可

import java.util.*;
public class Solution {
    public TreeNode Convert(TreeNode pRootOfTree) {
        if(pRootOfTree == null){
            return null;
        }
        ArrayList<TreeNode> list = new ArrayList<>();
        Convert(pRootOfTree, list);
        return Convert(list);
    }
    //中序遍历，在list中按遍历顺序保存
    public void Convert(TreeNode pRootOfTree, ArrayList<TreeNode> list){
        if(pRootOfTree.left != null){
            Convert(pRootOfTree.left, list);
        }
        list.add(pRootOfTree);
        if(pRootOfTree.right != null){
            Convert(pRootOfTree.right, list);
        }
    }
    
    //遍历list，修改指针
    public TreeNode Convert(ArrayList<TreeNode> list){
        for(int i = 0; i < list.size() - 1; i++){
            list.get(i).right = list.get(i + 1);
            list.get(i + 1).left = list.get(i);
        }
        return list.get(0);
    }
}

重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回
思路：

1. 根据前序序列第一个结点确定根结点
2. 根据根结点在中序序列中的位置分割出左右两个子序列
3. 对左子树和右子树分别递归使用同样的方法继续分解

例如：
前序序列{1,2,4,7,3,5,6,8} = pre
中序序列{4,7,2,1,5,3,8,6} = in
根据当前前序序列的第一个结点确定根结点，为 1
找到 1 在中序遍历序列中的位置，为 in[3]
切割左右子树，则 in[3] 前面的为左子树， in[3] 后面的为右子树
则切割后的左子树前序序列为：{2,4,7}，切割后的左子树中序序列为：{4,7,2}；切割后的右子树前序序列为：{3,5,6,8}，切割后的右子树中序序列为：{5,3,8,6}
对子树分别使用同样的方法分解

import java.util.*;
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        if (pre.length == 0 || in.length == 0) {
            return null;
        }
        TreeNode root = new TreeNode(pre[0]);
        // 在中序中找到前序的根
        for (int i = 0; i < in.length; i++) {
        	//根据前序遍历的第一个元素得到根节点，找到其在中序遍历中的位置，左边为左子树，右边为右子树
            if (in[i] == pre[0]) {
                // 左子树，注意 copyOfRange 函数，左闭右开，舍弃i
                root.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i + 1), Arrays.copyOfRange(in, 0, i));
                // 右子树，注意 copyOfRange 函数，左闭右开，舍弃i
                root.right = reConstructBinaryTree(Arrays.copyOfRange(pre, i + 1, pre.length), Arrays.copyOfRange(in, i + 1, in.length));
                break;
            }
        }
        return root;
    }
}

二叉树的下一个节点

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
**思路：**根据已给节点找到根节点，对根节点进行中序遍历，找到目标节点下一个即可

import java.util.*;
public class Solution {
    ArrayList<TreeLinkNode>list=new ArrayList<>();
    
    public TreeLinkNode GetNext(TreeLinkNode pNode)
    {
        TreeLinkNode root =pNode;
        while(root.next!=null){
            root=root.next;
        }
        in(root);
        for(int i=0;i<list.size();i++){
            if(list.get(i)==pNode && list.size()>=i+2)
                return list.get(i+1);
        }
        return null;
    }
    public void in (TreeLinkNode root){
        if(root!=null){
            in(root.left);
            list.add(root);
            in(root.right);
        }
    }
}

把二叉树打印成多行

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
**思路：**套用BPS模板即可（注意二维动态数组的赋值）

import java.util.*;
public class Solution {
    ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> thelist = new ArrayList<ArrayList<Integer>>();
        if(pRoot==null)return thelist; //这里要求返回thelist而不是null
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(pRoot);
        while(!queue.isEmpty()){
            ArrayList<Integer> list = new ArrayList<Integer>();
            int size = queue.size();
            for(int i=0;i<size;i++){
            TreeNode temp = queue.remove();
            list.add(temp.val);
            if(temp.left!=null)queue.add(temp.left);
            if(temp.right!=null)queue.add(temp.right);
            }
            thelist.add(list);
        }
        return thelist;
    }
}