作者:学Java的冬瓜
博客主页:☀冬瓜的主页🌙
专栏:【Java 数据结构】
分享:宇宙的最可理解之处在于它是不可理解的,宇宙的最不可理解之处在于它是可理解的。——《乡村教师》
主要内容:二叉树的各类OJ习题,面试题
刷题网站:【牛客网】 【LeetCode官网】
文章目录
题一:判断二叉树是否完全相同
0、链接:
1、思路:
分析:分为p,q两棵树都空,一棵树空,另一棵树不空。两棵树都不空三种情况。再详细分析
2、代码:
法一:使用 if-else
// 法一:
class Solution {
public boolean isSameTree(TreeNode p, TreeNode q) {
//1、两棵树都是空树
if(p == null && q == null){
return true;
}
//2、结构不同(一棵空,一棵非空)
else if((p == null && q != null) || (p != null && q == null)){
return false;
}
//3、都非空
else{
// 值不同
if(p.val != q.val){
return false;
}
// 值相同
return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
}
}
}
法二:使用 if 排除
// 法二:
public boolean isSameTree(TreeNode p, TreeNode q) {
//1、两棵树都是空树
if(p == null && q == null){
return true;
}
//2、结构不同(一棵空,一棵非空)
if((p == null && q != null) || (p != null && q == null)){
return false;
}
//3、都非空
// 值不同
if(p.val != q.val){
return false;
}
// 值相同
return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
}
3、时间复杂度:
// m为p的节点数,n为q的节点数
O(min(m,n))
//因为当一棵树遍历完,另一棵树还有节点,
//那就返回false,所以时间复杂度是二者之间的较小值。
题二:判断另一棵树的子树
0、链接:
1、思路:
分析:
1> 判断两棵树是否相等,相等就可看做subRoot为root子树成立
2> 不等时进入递归循环查找是否符合subRoot是roor的左子树或者右子树。
2、代码:
法一:使用 if-else
// 法一:
class Solution {
public boolean isSubtree(TreeNode root, TreeNode subRoot) {
//1、判断两棵树相同
if(isSameTree(root,subRoot)){
return true;
}
//2、两棵树不同,但root=null
else if(root == null){
return false;
}
//3、两棵树不同,进入递归判断左子树或者右子树有无和subRoot树相同
else{
return isSubtree(root.left,subRoot) || isSubtree(root.right,subRoot);
}
}
// 判断两棵树是否相同
public static boolean isSameTree(TreeNode p, TreeNode q) {
//1、两棵树都是空树
if(p == null && q == null){
return true;
}
//2、结构不同(一棵空,一棵非空)
else if((p == null && q != null) || (p != null && q == null)){
return false;
}
//3、都非空
else{
// 值不同
if(p.val != q.val){
return false;
}
// 值相同
return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
}
}
}
法二:使用 if 排除
// 法二:
class Solution {
public boolean isSubtree(TreeNode root, TreeNode subRoot) {
//1、排除在查找过程中root树空了的情况
if(root == null){
return false;
}
//2、判断两棵树相同
if(isSameTree(root,subRoot)){
return true;
}
//3、进入递归查看每个节点的左子树是否和subRoot相同
if(isSubtree(root.left,subRoot)){
return true;
}
//4、进入递归查看每个节点的右子树是否和subRoot相同
if(isSubtree(root.right,subRoot)){
return true;
}
return false;
}
//判断两棵树是否相同
public boolean isSameTree(TreeNode p, TreeNode q) {
//1、两棵树都是空树
if(p == null && q == null){
return true;
}
//2、结构不同(一棵空,一棵非空)
if((p == null && q != null) || (p != null && q == null)){
return false;
}
//3、都非空
// 值不同
if(p.val != q.val){
return false;
}
// 值相同
return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
}
3、时间复杂度:
// root有r个节点 subRoot有s个节点
O(r*s)
// 分析:首先root最坏情况要遍历完,
//其次subRoot每次都要和root的根节点开始的树进行比较
//是一个一个节点的比较。所以最终结果为r*s
题三:翻转二叉树
0、链接:
1、思路:
分析:从视觉上看是反转了二叉树每一层的数据。其实就是交换了每一个结点的左右子树
2、代码:
class Solution {
public TreeNode invertTree(TreeNode root) {
// 1、判断树是否为空,包含最开始时和访问叶子节点后的空
if(root == null){
return null;
}
// 2、先把根节点的左子树和右子树交换
TreeNode tmp = root.left;
root.left = root.right;
root.right = tmp;
// 3、进入子树递归交换左右子树
invertTree(root.left);
invertTree(root.right);
return root;
}
}
3、时间复杂度:
//很明显,最多把每个节点遍历一遍,所以时间复杂度为
O(N)
题四:判断平衡二叉树
0、链接:
1、思路:
分析:
要求这棵树是平衡二叉树,那么必须是这棵树的左右子树都为平衡二叉树。
当root=null时,要么是根节点为空,返回true;要么是叶子节点的子节点为空,说明这个空的父节点们满足isBalance条件,所以也返回true。
2、代码+复杂度:
法一:使用双重递归
// 法一
// 缺陷:时间复杂度为O(N^2)
// 因为求高度的复杂度为O(N)
// 每个节点都求高度,所以约等于O(N^2)
class Solution {
public boolean isBalanced(TreeNode root) {
// 1、找到空或root本身就是null
if(root == null){
return true;
}
// 2、求该节点左右子树的高度
int leftDepth = treeDepth(root.left);
int rightDepth = treeDepth(root.right);
// 3、当前符合条件的节点,和递归判断左右子树是否平衡
// 简单的写法:Matn.abs(leftDepth-rightDepth) <= 1
int sub = leftDepth - rightDepth;
return sub >= -1 && sub <=1 && isBalanced(root.left) && isBalanced(root.right);
}
// 求树的高度的方法
public int treeDepth(TreeNode root){
if(root == null){
return 0;
}
int leftDepth = treeDepth(root.left);
int rightDepth = treeDepth(root.right);
return leftDepth > rightDepth ? leftDepth+1 : rightDepth+1;
}
}
法二:只使用深度递归同时判断平衡
// 法二:强烈推荐
// 时间复杂度只有O(N)
// 思路就是把isBalance递归方法和treeDepth方法递归两个递归变成一个递归。用treeDepth返回值来确定是否平衡和求高度两个任务。
class Solution {
public boolean isBalanced(TreeNode root) {
// 1、找到空
if(root == null){
return true;
}
// 2、非空时,直接把树root传进去,满足平衡就会返回这棵树的深度,否则返回-5
return treeDepth(root) >= 0;
}
// 求树的高度的方法
public int treeDepth(TreeNode root){
if(root == null){
return 0;
}
int leftDepth = treeDepth(root.left);
int rightDepth = treeDepth(root.right);
// 注意:相对于法一改变的部分,
//要在这里满足leftDepth>=0 && rightDepth>=0,因为会进入递归
//且左右高度不能出现等于负数,否则直接return false
if(leftDepth >=0 && rightDepth >= 0 && Math.abs(leftDepth - rightDepth) < 2){
return leftDepth > rightDepth ? leftDepth+1 : rightDepth+1;
}else{
return -5;
}
}
}
题五:二叉树的层序遍历(非递归)
0、链接:
简单的中序遍历,再打印可以参考这篇C语言博客:
【二叉树基础习题】
1、思路:
说明:
1>先创建一个队列,先把树的根节点入队列
2>然后队列不空就把队头元素取出,再把这个元素的左右子树的非空的根节点入队列
3>最后队列为空时结束
2、代码:
// 注意:值得注意的是,这道OJ题要求用List<List<>>返回。所以要分好节点在哪一层。
// 这里是用计算队列大小的方式,求出当前节点所在层数的元素个数
// 再根据这个元素个数,来界定层数
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
//0、准备返回值
List<List<Integer>> lists = new ArrayList<>();
// 1、空树
if (root == null){
return lists;
}
// 2、非空,先把root树根节点入队列
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()){
// 3、计算此时队列里有多少个元素
int cnt = queue.size();
// 4、把队列里的元素拿出一个,再把这个元素的左右子树的根入队列
// 循环直到这一层的元素全从队列拿出来(以cnt=0为结束标志)
List<Integer> list = new ArrayList<>();
while(cnt > 0){
TreeNode out = queue.poll();
if(out != null){
list.add(out.val);
}
// 注意:out的左右子树的根不为空,则入队
if(out.left != null){
queue.offer(out.left);
}
if(out.right != null){
queue.offer(out.right);
}
// 注意:每出队列一个元素,cnt-1
cnt--;
}
// 5、把一维集合放进二维集合
lists.add(list);
}
// 6、返回类似于二维数组的集合
return lists;
}
}
题六:判断完全二叉树
1、思路:
说明:这道题不是OJ题,方法和层序遍历非递归的方法非常相似。
思路:
1>按照非递归层序遍历的方式,把所以节点入队列包括null。
2>当遇到null时,退出循环,再判断此时队列中是否有非null的元素,如有非null元素,则不是完全二叉树,返回false。
3>若不断出队,最后队列为空了,也还没返回false,则是完全二叉树,返回true。
注意:在C语言中NULL不能入队,所以这个方法不能用C语言实现。
2、代码:
public static boolean isCompleteTree(TreeNode root){
// 1、空树
if (root == null){
return false;
}
// 2、非空,把根节点入队列
Queue<TreeNode> qu = new LinkedList<>();
qu.offer(root);
while (!qu.isEmpty()){
// 3、把树的所有节点包括叶子结点的null,
//按照层序遍历的方式入队列和出队列,遇到null就退出循环
TreeNode cur = qu.poll();
if (cur != null){
qu.offer(cur.left);
qu.offer(cur.right);
}else{
break;
}
}
// 特别注意:程序进行到这里,必定是从上面循环break出来的,即出队元素遇到了null,所以退出循环
// 4、这里要做的就是判断队列剩下的元素中是否有非null元素,有非nill元素则返回false;
while(!qu.isEmpty()){
if(qu.poll() != null){
return false;
}
}
// 5、不断出队,最后队列为空了,也还没返回false,则是完全二叉树,返回true。
return true;
}
题七:二叉树创建和遍历
0、链接:
1、代码:
分析法一:
方法一:
定义全局变量,来控制当前的字符位置,但是在多线程中,容易错误,因为线程是不断在切换的。不推荐使用。
法一:利用全局变量i
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
// 内部类定义树的节点
static class TNode{
char val;
TNode left;
TNode right;
public TNode(char value){
this.val = value;
}
}
// 定义全局变量,来控制当前的字符位置,但是在多线程中,容易错误
static int i = 0;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String s = in.nextLine();
TNode root = createTree(s);
inOrder(root);
}
// 创建二叉树
private static TNode createTree(String s){
char ch = s.charAt(i++);
if(ch == '#'){
return null;
}
TNode node = new TNode(ch);
node.left = createTree(s);
node.right = createTree(s);
return node;
}
// 中序遍历二叉树
private static void inOrder(TNode root){
if(root == null){
return;
}
inOrder(root.left);
System.out.print(root.val + " ");
inOrder(root.right);
}
}
分析法二:
方法二:
在main方法中,把字符串放入队列,由队列进行操作。相当于用队列代替了用i遍历字符串的任务。因为队列遍历remove后,不会因为递归而回到上一个字符(如果用局部变量i则会出这个问题)。但是效率比法一低,看情况取舍。
注意:
若需要该题C语言版的,这篇博客步骤讲的更详细一点,可以点以下链接:【牛客.二叉树遍历】-C语言
法二:使用队列解决法一带来的多线程问题
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
static class TNode{
char val;
TNode left;
TNode right;
public TNode(char value){
this.val = value;
}
}
// 在main方法中,把字符串放入队列,由队列进行操作
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String s = in.nextLine();
Queue<Character> queue = new LinkedList<>();
// 注意:要把字符串变成字符数组才能用foreach
for(char ch : s.toCharArray()){
queue.offer(ch);
}
TNode root = createTree(queue);
inOrder(root);
}
private static TNode createTree(Queue<Character> queue){
char ch = queue.remove();
if(ch == '#'){
return null;
}
TNode node = new TNode(ch);
node.left = createTree(queue);
node.right = createTree(queue);
return node;
}
// 中序遍历
private static void inOrder(TNode root){
if(root == null){
return;
}
inOrder(root.left);
System.out.print(root.val + " ");
inOrder(root.right);
}
}
题八:二叉树前序遍历
注解:在之前我写过一篇关于二叉树的各种遍历问题的博客,不太懂的小伙伴可以去看看这篇博客
链接:【二叉树的各种遍历问题】
0.链接
1.代码
法一:递归
// 法一:递归
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
preOrder(root,list);
return list;
}
// 递归实现前序遍历,把数据放进list中
private static TreeNode preOrder(TreeNode root,List<Integer> list){
if(root == null){
return null;
}
list.add(root.val);
preOrder(root.left,list);
preOrder(root.right,list);
return root;
}
}
法二:非递归
// 法二:非递归
// 思路:先一直往根节点左走,边打印,边入栈,直到遇到空,再出栈,访问这个出栈的元素的右边。
//只有cur=null 且 栈空,才退出访问。
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
TreeNode cur = root;
List<Integer> list = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();
while(cur!=null || !stack.isEmpty()){
if(cur != null){
//System.out.print(cur.val + " ");
stack.push(cur);
list.add(cur.val);
cur = cur.left;
}else{
cur = stack.pop();
cur = cur.right;
}
}
return list;
}
}
题九:二叉树中序遍历
说明:中序遍历的递归算法和前序遍历算法差不多,这里就不再做过多赘述,有疑问,则看题七中的链接。
0、链接
1、代码
// 非递归,方法和前序遍历非递归很像,可以对照学习
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
TreeNode cur = root;
Stack<TreeNode> stack = new Stack<>();
List<Integer> list = new ArrayList<>();
while(cur!=null || !stack.isEmpty()){
if(cur != null){
stack.push(cur);
cur = cur.left;
}else{
cur = stack.pop();
list.add(cur.val);
cur = cur.right;
}
}
return list;
}
}
题十:二叉树后序遍历
0、链接
1、代码
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
TreeNode cur = root;
TreeNode prev = null;
Stack<TreeNode> stack = new Stack<>();
List<Integer> list = new ArrayList<>();
while(cur!=null || !stack.isEmpty()){
if(cur!=null){
stack.push(cur);
cur = cur.left;
}else{
TreeNode top = stack.peek();
if(top.right == null || top.right==prev){
cur = stack.pop();
list.add(cur.val);
// prev 记录前一个已经访问过的节点
prev = cur;
//重点:这一步很关键,目的是top左孩子为null时
//top右孩子为null或者已经访问,则标记以cur为根节点的树已经全部访问
cur = null;
}else{
// top左孩子为空时,如果不满足top右孩子为null,或者有孩子等于prev,就去访问右孩子。
cur = top.right;
}
}
}
return list;
}
}
题十一:二叉树的最近公共祖先
0、链接:
1、代码:
法一:利用双栈
原理:
从祖先节点到p或者q节点的深度是确定的,我们用两个栈来分别储存最近祖先节点到p和q的所有节点。
方法:
1> 用pstack储存根节点到p节点的路径,pstack的元素个数就是p的深度。用qstack储存根节点到q节点的路径,qstack的元素个数就是q的深度。
2> 把pstack和qstack中元素个数大的出栈,变成和小的一样的个数,这一步的目的是让搜索来到同一高度。
3> pstack和qstack出栈,然后比较元素是否相等,如果相等就是最近公共祖先,返回该节点;如果都空栈了还不相等就返回null。
4> 要使用后序遍历非递归中栈的使用方法,才能把节点按照p或者q的路径存进栈中,然后遇到p或者要到q时,break跳出循环。
非递归
class Solution {
public static TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if (root == null) {
return null;
}
//初始准备
Stack<TreeNode> ps = new Stack<>();
TreeNode pre1 = null;
TreeNode cur1 = root;
Stack<TreeNode> qs = new Stack<>();
TreeNode pre2 = null;
TreeNode cur2 = root;
// 获取两个节点的路劲
while(cur1 != null || !ps.isEmpty()){
if(cur1 == p){
ps.push(cur1);
break;
}
if(cur1 != null){
ps.push(cur1);
cur1 = cur1.left;
}else{
TreeNode top = ps.peek();
if(top.right == null || top.right==pre1){
cur1 = ps.pop();
pre1 = cur1;
cur1 = null;
}else{
cur1 = top.right;
}
}
}
while(cur2 != null || !qs.isEmpty()){
if(cur2 == q){
qs.push(cur2);
break;
}
if(cur2 != null){
qs.push(cur2);
cur2 = cur2.left;
}else{
TreeNode top = qs.peek();
if(top.right == null || top.right==pre2){
cur2 = qs.pop();
pre2 = cur2;
cur2 = null;
}else{
cur2 = top.right;
}
}
}
// 让两个栈的size和小栈的size相等
int psize = ps.size();
int qsize = qs.size();
if(psize > qsize){
int size = psize - qsize;
while(size>0){
ps.pop();
size--;
}
}else{
int size = qsize - psize;
while(size>0){
qs.pop();
size--;
}
}
// 从两个栈中依次取出元素比较,元素相等,就是原始两个节点p和q的公共祖先
while (!ps.isEmpty()){
TreeNode ptnode = ps.pop();
TreeNode qtnode = qs.pop();
if(ptnode == qtnode){
return ptnode;
}
}
return null;
}
}
利用递归(路径函数)
class Solution {
public static TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if (root == null) {
return null;
}
//初始准备+把数据入栈(利用getPath方法)
Stack<TreeNode> ps = new Stack<>();
getPath(root,p,ps);
Stack<TreeNode> qs = new Stack<>();
getPath(root,q,qs);
// 让两个栈的size和小栈的size相等
int psize = ps.size();
int qsize = qs.size();
if(psize > qsize){
int size = psize - qsize;
while(size>0){
ps.pop();
size--;
}
}else{
int size = qsize - psize;
while(size>0){
qs.pop();
size--;
}
}
// 从两个栈中依次取出元素比较,元素相等,就是原始两个节点p和q的公共祖先
while (!ps.isEmpty()){
TreeNode ptnode = ps.pop();
TreeNode qtnode = qs.pop();
if(ptnode == qtnode){
return ptnode;
}
}
return null;
}
// 求根节点到node节点的路径,然后放在栈中
private static boolean getPath(TreeNode root,TreeNode node, Stack<TreeNode> stack){
// 1、既作为开始判断,有作为递归过程中的判断。
if(root == null || node == null){
return false;
}
// 2、在下一步当前节点返回上一层递归前,入栈截至节点
stack.push(root);
// 3、满足条件,开始递归返回
if(root == node){
return true;
}
// 4、在每一层递归里,走到这里说明root!=null && root!=node。所以递归看当前节点的左右子树
boolean left = getPath(root.left,node,stack);
if(left == true){
return true;
}
boolean right = getPath(root.right,node,stack);
if(right == true){
return true;
}
// 5、到这里说明当前节点左右子树中都没找到
// 但是当前节点以及入栈,所以先出栈,在返回false
stack.pop();
return false;
}
}
法二:分情况讨论
分析:
可以大致分为,三种情况。
1> p和q有一个是根节点
2> p和q在根节点的两侧
3> p和q在根节点的一侧
方法:
在递归里,我只需要关心在当前节点的子树当中找没找到p或者q如果p和q都在根节点的左边,需要两个节点都找到,才能返回公共祖先。
如果p和q在根节点的左右两侧,那就根节点是公共祖先
如果p和q都在根节点右侧,那先找到的那个节点就是公共祖先。
// 法二:分情况讨论
class Solution {
// 法二:分情况讨论
public static TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
// 这里代表找到了树的当前方向的尽头
// 比如到了叶子节点的左右子树,则返回null
if(root == null || p == null || q == null){
return null;
}
// 第一种情况:p和q有一个在根节点
// 还有一个含义是:满足条件时返回这个节点或者q
if(root == p || root == q){
return root;
}
// 走到这里,说明 root!=null && p!=null &&q!=null,且p和q均不是根节点。
// 进入递归查看左右子树
TreeNode leftNode = lowestCommonAncestor(root.left,p,q);
TreeNode rightNode = lowestCommonAncestor(root.right,p,q);
//第二种:p和q在root两边
if(leftNode != null && rightNode != null){
return root;
}
// 第三种:p和q在root的同一侧,且都不在根节点
// 重点注意:如果都在root的右侧,那先找到的那一个节点就是最近公告祖先
else if (leftNode != null) {
return leftNode;
} else if (rightNode != null) {
return rightNode;
}
// 注意:这一步是为了防止p和q都在某个节点的右侧时发生错误。
// 也可以理解为已经访问的节点没找到p或者q的标记,比如访问到叶子节点,但它不是p或者q
else{
return null;
}
}
}
题十二:二叉搜索树与双向链表
0、链接:
1、思路:
说明:
1> 根据一个convertChild函数,加上prev属性引用(类似于指针传址),去中序递归实现前驱和后继的改变。
2> 要注意最后的双向链表是中序遍历第一个节点left(前驱)为null(在代码上可以表现出来),中序遍历最后一个节点right(后继)为null,代码上体现不出来,但是这个节点的right本身在树中就是null。
3> 返回值是中序遍历的第一个节点,即节点的left为null的就是返回节点。
2、代码:利用prev引用
// 二叉搜索树与双向链表
public class Solution {
public TreeNode Convert(TreeNode pRootOfTree) {
if(pRootOfTree == null){
return null;
}
convertChild(pRootOfTree);
// 注意:找到二叉搜索树改变为双向链表的头,并返回
TreeNode head = pRootOfTree;
while(head.left != null){
head = head.left;
}
return head;
}
// 注意:这个prev要定义在递归之外,相当于指针传地址,改变指针指向
private TreeNode prev = null;
// 递归方法实现前驱后继的改变
private void convertChild(TreeNode pcur){
if(pcur == null){
return ;
}
convertChild(pcur.left);
pcur.left = prev;
if(prev != null){ // 重点注意:排除中序遍历第一个节点执行下面一行代码时,空指针异常
prev.right = pcur;
}
prev = pcur;
convertChild(pcur.right);
}
}
题十三:从前序和中序遍历序列构造二叉树
0、链接:
1、思路:
说明:
1> 根据前序和中序构造二叉树,首先要确定的是前序依次从左往右的元素就是根节点,然后在中序中找到根节点位置,从这个位置左右拆分。
2> 因为每一段区间都是相同的操作,所以用递归实现。
3> 因为前序遍历是,根左右。所以我们根据前序和中序创建二叉树也是按照根左右来的,因为需要根据根的顺序创建二叉树。
2、代码:
class Solution {
// 根据前序、中序创建二叉树
public TreeNode buildTree(int[] preorder, int[] inorder) {
return buildTreeChild(preorder,inorder,0,inorder.length-1);
}
// 递归前序创建二叉树
int preindex = 0; // 重点1:定义全局变量,取消递归的干扰,从而保证从前到后依次遍历preorder数组
private TreeNode buildTreeChild(int[] preorder,int[] inorder,int begindex,int Endindex){
// 重点2:递归结束条件,也防止数组越界
if(begindex > Endindex){
return null;
}
TreeNode root = new TreeNode(preorder[preindex]);
// 求前序遍历的节点在中序遍历中作为根节点的位置
int rootindex_inorder = findIndex(preorder,inorder);
// 重点三:查完前序的节点在中序中根节点位置,再把遍历前序的下标preindex+1
preindex++;
root.left = buildTreeChild(preorder,inorder,begindex,rootindex_inorder-1);
root.right = buildTreeChild(preorder,inorder,rootindex_inorder+1,Endindex);
return root;
}
// 求前序的节点在中序遍历的位置
private int findIndex(int[] preorder,int[] inorder){
int i = 0;
while(i<inorder.length){
if(preorder[preindex] == inorder[i]){
return i;
}
i++;
}
return -1;
}
}
题十四:从中序和后序遍历序列构造二叉树
0、链接:
1、思路:
说明:
1> 大部分思路和上一道题相同
2> 不同点就是这里根节点序列的后序遍历顺序是,左右根。但是我们判断时是把这个序列倒起来看的,从而顺序找出根节点,所以创建二叉树的顺序就是根右左。
2、代码:
class Solution {
int postIndex = 0;
public TreeNode buildTree(int[] inorder, int[] postorder) {
postIndex = postorder.length-1;
return buildTreeChild(inorder,postorder,0,inorder.length-1);
}
private TreeNode buildTreeChild(int[] inorder, int[] postorder, int begindex, int endindex){
if(begindex>endindex){
return null;
}
TreeNode root = new TreeNode(postorder[postIndex]);
int rootindex_inorder = findIndex(inorder,postorder);
postIndex--;
root.right = buildTreeChild(inorder,postorder,rootindex_inorder+1,endindex);
root.left = buildTreeChild(inorder,postorder,begindex,rootindex_inorder-1);
return root;
}
private int findIndex(int[] inorder, int[] postorder){
int i = 0;
while(i<inorder.length){
if(inorder[i] == postorder[postIndex]){
return i;
}
i++;
}
return -1;
}
}
题十五:根据二叉树创建字符串
0、链接:
1、思路:
说明:要把左右子树的递归,放在if-else逻辑里面。分以下几种情况:
判断左边加什么:
1> 左边不为null,加数值 然后进入左递归 再加 “(”
2> 左边为null,右边不为null,加 “()”
3> 左边为null,右边直接返回,不加东西。
判断右边加什么:
1> 右边不为空,加数值 然后进入右递归 再加 “(”
2> 右边为null,直接返回(因为在不为空时已经加上了 “)” )
2、代码:
class Solution {
public String tree2str(TreeNode root) {
StringBuilder sb = new StringBuilder();
treeToStr(root,sb);
return sb.toString();
}
private void treeToStr(TreeNode root, StringBuilder sb){
if(root == null){
return ;
}
// 判断左边的情况
sb.append(root.val);
if(root.left != null){
sb.append("(");
treeToStr(root.left,sb);
sb.append(")");
}else{
if(root.right == null){
return ;
}else{
sb.append("()");
}
}
// 判断右边的情况
if(root.right != null){
sb.append("(");
treeToStr(root.right,sb);
sb.append(")");
}else{
return ;
}
}
}