【Java 数据结构】-二叉树OJ题

已于 2023-03-03 02:02:46 修改
阅读量533 收藏 2
点赞数 2
分类专栏： 【Java 数据结构与算法理解及刷题】 文章标签： java 数据结构 开发语言
于 2022-12-24 12:00:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63979882/article/details/128298928
版权

作者：学Java的冬瓜
博客主页：☀冬瓜的主页🌙
专栏：【Java 数据结构】
分享：宇宙的最可理解之处在于它是不可理解的，宇宙的最不可理解之处在于它是可理解的。——《乡村教师》
主要内容：二叉树的各类OJ习题，面试题
刷题网站：【牛客网】 【LeetCode官网】

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

文章目录

题一：判断二叉树是否完全相同

0、链接：

LeetCode100.相同的树

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、链接：

LeetCode572.另一棵树的子树

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、链接：

LeetCode226.翻转二叉树

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、链接：

LeetCode110.平衡二叉树

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、链接：

LeetCode102.二叉树的层序遍历

简单的中序遍历，再打印可以参考这篇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、链接：

牛客网KY11.二叉树遍历

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.链接

LeetCode144.二叉树前序遍历

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、链接

LeetCode94.二叉树中序遍历

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、链接

LeetCode145.二叉树后序遍历

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、链接：

LeetCode236.二叉树的最近公共祖先

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、链接：

牛客JZ36.二叉搜索树与双向链表

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、链接：

LeetCode105.从中序和后序遍历序列构造二叉树

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、链接：

LeetCode106.从中序和后序遍历序列构造二叉树

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、链接：

LeetCode606.根据二叉树创建字符串

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 ;
        }
    }
}
学Java的冬瓜
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
【数据结构】--二叉树OJ题
weixin_52563203的博客
08-13 289
二叉树Oj
数据结构--二叉树OJ习题2
qq_35297945的博客
02-20 275
1 单值二叉树 1.1 题目介绍 1.2 题目分析 1.2.1 基本思路 1.2.2 关键变量 1.3 程序代码 1.4 运行结果
Java数据结构-二叉树
QUIXOTIC_的博客
04-19 938
二叉树、二叉树OJ题
数据结构-二叉树（java实现）及相关的oj题
2301_77993957的博客
08-03 716
树是一种数据结构，对比于生活中常见的树，其逻辑结构是倒立着的:树是由n个节点组成的有限集，（当n==0时，称此树为空树），对于任何一棵非空树，只有唯一的根节点root.当n>1时，除去根节点，剩余节点可以分为m个有限集（m>0),这些有限集互不相交，其中每个集合又是一棵树，称为根的子树。
Java数据结构与算法，笔试题，OJ.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
mooc-清华数据结构与算法(邓俊辉) OJ习题.zip
06-16
数据结构与算法是计算机科学中的核心课程，尤其对于C/C++、Java以及Python等编程语言的学习者来说，理解和掌握它们至关重要。"mooc-清华数据结构与算法(邓俊辉) OJ习题.zip"这个压缩包文件包含了清华大学邓俊辉教授...
Algorithm-by-Company:数据结构，OJ问题
05-14
本资源"Algorithm-by-Company:数据结构，OJ问题"显然聚焦于通过具体公司的角度来探讨这些问题，特别是与Airbnb（爱彼迎）相关的算法挑战。在Java编程语言的背景下，我们将深入学习和理解这些关键概念。 首先，让...
LeetCode-OJ-Solutions
06-29
《LeetCode OJ 解决方案：Java篇》 ...通过阅读和理解这些解决方案，你可以深入了解Java数据结构的使用，熟悉各种算法，并提升编程思维。同时，这也是一个自我挑战和不断提升的过程，对于提升职业竞争力具有重要意义。
程序设计基础 OJ 题库 NUIST
10-22
在OJ题库中，常见的数据结构包括数组、链表、栈、队列、树（二叉树、平衡树如AVL和红黑树等）、哈希表等。理解并熟练运用这些数据结构可以有效地组织和操作数据，实现高效的算法。 在NUIST的"程序设计基础"课程中，...
（javaweb）请求响应postman
2301_79144798的博客
08-08 519
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 492
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 526
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
集合（1）
supercool7的博客
08-12 791
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
构造方法，JavaBean，对象内存图，基础数据类型和引用数据类型
最新发布
qq_63126439的博客
08-14 208
栈内存处理完数据之后会退出，指向推内存的箭头都会消失，当没有人指向他的时候，堆内存中的数据也会被移除。带参构造方法和无参数构造方法，两者方法名相同，但参数不同，这叫做构造方法的重载。方法区，新增元空间，把原来的方法区的多种功能进行了拆分。创造对象的时候，虚拟机会自动调用构造方法，作用是给成员变量进行初始化的。只要是看见new就会在堆内存创建新的空间，两个空间是独立的，互不影响。基础数据类型，在变量当中存储真实的数据值，和其他空间没有任何关系。使用其他空间的数值，自己的空间存储的是地址值。
Java：继承，this，super
m0_75257168的博客
08-10 408
可以同名，但参数列表不能相同（有参无参构造）
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 510
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
基于JAVA生产制造执行系统设计与实现(源码+论文+讲解等)
程序员阿龙的博客
08-13 654
当下，如果 还依然使用纸质文档来记录并且管理相关信息，可能会出现很多问题，比如原始文件的丢失，因为采用纸质文档，很容易受潮或者怕火，不容易备份，需要花费大量的人员和资金来管理用纸质文档存储的信息，最重要的是数据出现问题寻找起来很麻烦，并且修改也困难，如果还这样操作会造成很大的资源浪费和经济损失。所以，对于本课题研究的产品生产制造信息的管理就需要有一款软件来代替手工操作，因此MES生产制造执行系统就应运而生。MES生产制造执行系统运用的工具包括Eclipse，Tomcat以及Navicat等。
SpringBoot中生成条形码的方案实战
2301_76419561的博客
08-14 751
ZXing库是一个用于解析和生成多种格式的一维和二维条形码的开源Java库。ZXing（“zebra crossing”的缩写）库提供了多种条形码格式的支持，包括但不限于QR码、Data Matrix、EAN、UPC和Codabar等。它不仅能够在Java平台上使用，还提供了其他编程语言的端口，如C++、ObjC（用于iOS开发）以及ActionScript等。ZXing的设计旨在支持复杂的条形码识别功能，并能够通过摄像头捕获条形码图像进行解码。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

学Java的冬瓜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值