二叉树终章

最新推荐文章于 2024-07-25 11:15:54 发布
最新推荐文章于 2024-07-25 11:15:54 发布
阅读量396 收藏 4
点赞数 9
分类专栏： 数据结构 新数据结构 文章标签： 链表 leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mu_tong_/article/details/125538281
版权

文章目录

二叉树终章

本文 还是 为 二叉树 的 练习题

查看源图像

来看第一个题

二叉树的最近公共祖先

在这里插入图片描述

附上代码

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {       
        if(root == null){
            return null;
        }
        if(p == root || q == root) {
            return root;
        }
        TreeNode leftTree = lowestCommonAncestor(root.left,p,q);
        TreeNode rightTree = lowestCommonAncestor(root.right,p,q);
        if(leftTree == null) {
            return rightTree;
        }
        if(rightTree == null) {
            return leftTree;
        }
        return root;
    }
}


逻辑清晰些

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null) return null;
        if(p == root || q == root) return root;
        TreeNode leftTree = lowestCommonAncestor(root.left,p,q);
        TreeNode rightTree = lowestCommonAncestor(root.right,p,q);
        if(leftTree != null && rightTree != null) {
            return root;
        }else if(leftTree != null) {
            // 左树不为空，右数为空，
            return leftTree;
        }else {
            // 右树不为空，左数为空
            return rightTree;
        }
    }

}

完成了 以上 那么 我们接下来 在来一种方法

在这里插入图片描述

接下来就 与 求 链表 交点一个思路 没啥难度，那么 你能自己完成吗？？？

附上代码

class Solution {
   
    public boolean  getPath(TreeNode root,TreeNode node,Stack<TreeNode> stack) {
        if(root == null || node == null) {
            return false;
        }
        stack.push(root);
        if(root == node) {
            return true;
        }
        boolean flg = getPath(root.left,node,stack);
        if(flg) {
            return true;
        }
        flg = getPath(root.right,node,stack);
        if(flg) {
            return true;
        }
        stack.pop();
        return false;
    }
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null) {
            return null;
        }
        Stack<TreeNode> stack1 = new Stack<>();
        Stack<TreeNode> stack2 = new Stack<>();
        getPath(root,p,stack1);
        getPath(root,q,stack2);
        int size1 = stack1.size();
        int size2 = stack2.size();
        if(size1 > size2) {
            int ret = size1 - size2;
            while(ret != 0) {
                stack1.pop();
                ret--;
            }
              while(!stack1.isEmpty() && !stack2.isEmpty()) {
                    if(stack1.peek() == stack2.peek()) {
                        return stack1.peek();
                    }
                    stack1.pop();
                    stack2.pop();
             }
        }else {
                 int ret = size2 - size1;
            while(ret != 0) {
                stack2.pop();
                ret--;
            }
              while(!stack1.isEmpty() && !stack2.isEmpty()) {
                    if(stack1.peek() == stack2.peek()) {
                        return stack1.peek();
                    }
                    stack1.pop();
                    stack2.pop();
             }
        }
        return null;
    }
}

二叉搜索树与双向链表

接下来我们 来看这道题

在这里插入图片描述

在这里插入图片描述

附上代码

public class Solution {
    TreeNode prev = null;
    public void inorder(TreeNode root) {
        if(root == null) {
            return;
        }
        inorder(root.left);
        root.left = prev;
      
        //这里如果 不加条件 root != null 
        // 就会出现 空指针异常
        if(prev != null) {
            prev.right = root;
        }
         prev = root;
        inorder(root.right);
       
       
    }
    public TreeNode Convert(TreeNode root) {
        // 创建完 了 双向链表那么就要 去找到 head 结点了
        if(root == null){
            return null;
        }
        inorder(root);
        TreeNode head = root;
        while(head.left != null) {
            head = head.left;
        }
        return head;
    }
}

从前序与中序遍历序列构造二叉树

在这里插入图片描述

附上代码

class Solution {
    public  int preIndex = 0;
    public   TreeNode createTreeBypandI(int[]preorder,int[]inorder,int inbegin,int inend) {
        if(inbegin > inend) {
            return null;
        }
       int ret = preorder[preIndex];
       TreeNode root = new TreeNode(ret);
        
       int rootIndex = findIndexOfI(inorder,inbegin,inend,ret);
       if(rootIndex == -1) {
           return null;
       }
       preIndex++;
       root.left = createTreeBypandI(preorder,inorder,inbegin,rootIndex - 1);
       root.right = createTreeBypandI(preorder,inorder,rootIndex+1,inend);
       return root;
    }
    public int findIndexOfI(int[]inorder,int inbegin,int inend,int key) {
        for(int i = inbegin;i<= inend;i++) {
            if(inorder[i] == key) {
                return i;
            }
        }
        return -1;
    }
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder == null || inorder == null) {
            return null;
        }
        return createTreeBypandI(preorder,inorder,0,inorder.length-1);
    }
}

从中序与后序遍历序列构造二叉树

在这里插入图片描述

附上代码

class Solution {
    public static  int posIndex = 0;
    public TreeNode c(int[]inorder,int[]postorder,int inbegin ,int inend) {
        if(inbegin > inend) {
            return null;
        }
        int ret = postorder[posIndex];
        TreeNode root = new TreeNode(ret);
        int rootIndex = findIndex(inorder,inbegin,inend,ret);
        if(rootIndex == -1) {
            return null;
        }
        posIndex--;
        // 注意 后序遍历 是 左子树 --> 右子树 --> 根随
        // 随意 这里需要先创建 右子树
        root.right = c(inorder,postorder,rootIndex + 1,inend);
        root.left = c(inorder,postorder,inbegin,rootIndex-1);
        return root;
    }
    public int findIndex(int[] inorder,int inbegin, int inend,int key) {
        for(int i = inbegin;i <= inend; i++){
            if(inorder[i] == key) {
                return i;
            }
        }
        return -1;
    }
    public TreeNode buildTree(int[] inorder, int[] postorder) {
            if(inorder == null || postorder == null) {
                return null;
            }
            // 初始化全局变量 preIndex
            posIndex = postorder.length-1;
            // c 创建 二叉树
            return c(inorder,postorder,0,inorder.length - 1);
    }
}

根据二叉树创建字符串

在这里插入图片描述

附上代码

class Solution {
    public void trreeToString(TreeNode root,StringBuilder sb) {
        if(root == null) {
            return;
        }
        sb.append(root.val);
        if(root.left != null) {
            // 根据刚刚分析  只要 root.left != null 我们 就需要添加一个 （
            sb.append("(");
            trreeToString(root.left,sb);
            sb.append(")");
        }else {
            // root.left == null
            if(root.right == null) {
                // 这里我们 刚刚分析，如果 root.right == null 说明此时 需要添加一个 ） ，
                //我们可以放到递归返回的地方添加
                return;
            }else{
                // root.right != null 这里我们就需要 添加一个()
                sb.append("()");
            }
        }
        //左树走完 来 右树
        if(root.right != null) {
            sb.append("(");
            trreeToString(root.right,sb);
            sb.append(")");
        }else {
            //root.right == null
            // 此时 树为空直接 return 出去即可
            return;
        }
    }
    public String tree2str(TreeNode root) {
        if(root == null) {
            return null;
        }
        StringBuilder sb = new StringBuilder();
        trreeToString(root,sb);
        return sb.toString();
    }
}

二叉树的前序遍历非递归

在这里插入图片描述

附上代码

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()) {
            while(cur != null) {
                stack.push(cur);
                list.add(cur.val);
                cur = cur.left;
            }
            TreeNode top = stack.pop();
            cur = top.right;
        }
        return list;
    }
}

二叉树的中序遍历非递归

在这里插入图片描述

附上代码

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ret = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()) {
            while(cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            TreeNode top = stack.pop();
           // System.out.println(top.val+" ");
            ret.add(top.val);
            cur = top.right;
        }
        return ret;
    }
}

二叉树的后序遍历非递归

在这里插入图片描述

附上代码

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
         if(root == null) {
             return list;
         }
         TreeNode cur = root;
         TreeNode prev = null;
         while(cur != null || !stack.isEmpty()) {
             while(cur != null) {
                 stack.push(cur);
                 cur = cur.left;
             }
             TreeNode top = stack.peek();
             if(top.right == null || top.right == prev ) {
                 stack.pop();
                 list.add(top.val);
                prev = top;
             }else {
                 cur = top.right;
             }
         }
         return list;
    }
}

二叉树完结。
在这里插入图片描述

在这里插入图片描述

牧..
关注
  • 9
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
C++ 彻底搞懂指针（终章）
GodJhin的博客
07-05 625
int (*f[ ])(int)，从 f 开始理解，先运算(*f[ ])，在(*f[ ])中，[ ]的优先级更高，f[ ]表明 f 是一个数组，*f[ ] 表明这是一个指针数组，然后剩下的 int(int)是指针数组中每个指针所指向的类型，是一个原型为 int func(int) 的函数，所以 f 是一个函数指针数组，int* (*f[ ])(int)类似，只不过函数原型为 int* func(int)。比如要创建一个存储10个int类型数据的数组，可以使用malloc函数，此时需要进行强制类型转换。
二叉树 基础
03-08
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
二叉树（终章）
2302_80378107的博客
05-27 646
1.二叉树的销毁2.二叉树的层序遍历3.判断二叉树是否为完全二叉树4.二叉树的性质。
终章排序算法
weixin_45969832的博客
02-16 232
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法： 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列； 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列； 堆排序的平均时间复杂度为 Ο(nlogn)。 1. 算法步骤 创建一个堆 H[0……n-1]
树--终章
qq_35917517的博客
04-25 67
目 录一、线索二叉树二、使用步骤1.引入库2.读入数据总结 一、线索二叉树 之前学习的二叉树，都是自顶向下的，仿佛有一种 开弓没有回头箭的感觉，那么是否可以回头呢？ 此外，让我们来看看画图表示链式存储 是不是发现，很多 ^ 。这些空指针被闲置了，浪费空间。 所以，我们可以用这些空着的地方，指向某些节点，开弓也有回头箭。 既然要指向某节点，就得遵循一定的规律，这里我们按照此前学习过的“中序遍历”的顺序： 右边的空余地方，统一指向按照中序遍历接下来要去往的那个节点； 左边的空域地方，也可以统一指向来之前的节点
【二叉树】练习题终章
yyqzjw的博客
12-02 143
二叉树练习题
mysql 性能优化 | 终章
谢文峰的博客
08-28 185
mysql5.7版本 《mysql性能优化系列文章》 mysql 性能优化 | 第一篇 mysql B+Tree 1.介绍索引的原理 2.介绍二叉树、平衡二叉树、绝对平衡树B-Tree、mysql索引的B+Tree 3.比较树之间的优势和mysql选择B+Tree的原因 mysql 性能优化 | 第二篇 MySql Myisam和innodb对比 索引优化建议 1.介绍MyISAM引擎和...
终章：二叉查找树和红黑树的性能比较
主要研究图形学相关领域
06-01 630
BST和红黑树的性能比较
【算法集训 | 暑期刷题营】终章
runofsun的博客
07-31 183
【算法集训 | 暑期刷题营】终章
【数据结构】二叉树的销毁 & 二叉树系列所有源代码（终章）
m0_71676870的博客
09-26 2263
数据结构】二叉树的销毁 & 二叉树系列所有源代码（终章） 一，二叉树的销毁 二，二叉树系列所有源代码 BTee.h BTee.c Queue.h Queue.c
有值二叉树
04-15
根据给定的信息，“有值二叉树”这一概念在IT领域通常是指一种特殊的二叉树结构，其中每个节点都包含具体的数值或者数据信息。在计算机科学中，二叉树是一种非常重要的数据结构，广泛应用于算法设计、数据组织与管理...
线索二叉树
04-10
通过前序序列创建线索二叉树 1:中序遍历 2:查找节点前驱后继 3:插入节点 4:删除节点 0:退出
平衡二叉树
03-03
平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 881
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
C++ | Leetcode C++题解之第283题移动零
Ddddddd_158的博客
07-25 355
C++ | Leetcode C++题解之第283题移动零
LeetCode707 设计链表
最新发布
daishabby2486的博客
07-25 620
LeetCode707 设计链表的解题记录。
Leetcode—769. 最多能完成排序的块【中等】
Atticus的博客
07-25 366
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
二叉树详解与应用
"二叉树学习PPT涵盖了关于树和二叉树的全面知识，包括定义、术语、遍历算法、线索化二叉树、树与森林的转换、哈夫曼树及其编码计算等核心概念。" 二叉树是树形数据结构的一种特殊类型，具有以下关键知识点： 1. **...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值