精华内容
下载资源
问答
  • 将一个按照升序排列的有序数组,转换为一棵高度平衡二叉搜索树。本题中,一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。示例:给定有序数组: [-10,-3,0,5,9],一个可能的答案是:...

    将一个按照升序排列的有序数组,转换为一棵高度平衡二叉搜索树。

    本题中,一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。

    示例:

    给定有序数组: [-10,-3,0,5,9],

    一个可能的答案是:[0,-3,9,-10,null,5],它可以表示下面这个高度平衡二叉搜索树:

    0

    / \

    -3 9

    / /

    -10 5

    思路1: 遍历链表,获得链表长度,找到链表中间的值,形成根结点,根据left,right ,递归寻找结点的左子树和右子树。

    因为每次递归都要遍历链表,时间复杂度非常高,

    /**

    * Definition for singly-linked list.

    * public class ListNode {

    * int val;

    * ListNode next;

    * ListNode(int x) { val = x; }

    * }

    */

    /**

    * Definition for a binary tree node.

    * public class TreeNode {

    * int val;

    * TreeNode left;

    * TreeNode right;

    * TreeNode(int x) { val = x; }

    * }

    */

    class Solution {

    public TreeNode sortedListToBST(ListNode head) {

    if(head==null)return null;

    ListNode l1=head,l2=head;

    int count=;

    while(l1!=null){

    l1=l1.next;

    count++; //得到链表的长度

    }

    // for(int i=0;i

    // l2=l2.next; //得到链表的中点

    // }

    return buildBST(head,,count-);

    }

    public TreeNode buildBST(ListNode head,int l,int r){

    if(l>r)return null;

    int mid=(l+r)/;

    ListNode tem=head;

    for(int i=;i

    TreeNode root=new TreeNode(tem.val);

    root.left=buildBST(head,l,mid-);

    root.right=buildBST(head,mid+,r);

    return root;

    }

    }

    思路2:先转化为数组,再转化为有序数组转换二叉探索树。

    参考:

    class Solution {

    public TreeNode sortedListToBST(ListNode head) {

    if(head==null)return null;

    int count=;

    ListNode l1=head;

    while(l1!=null){

    l1=l1.next;

    count++;

    }

    int[] nums=new int[count];

    for(int i=;i

    nums[i]=head.val;

    head=head.next; //转化为数组

    }

    return buildBST(nums,,count-); //将排序数组转为二叉探索树

    }

    public TreeNode buildBST(int[] nums,int l,int r){

    if(l>r)return null;

    int mid=(l+r)/;

    TreeNode root=new TreeNode(nums[mid]);

    root.left=buildBST(nums,l,mid-);

    root.right=buildBST(nums,mid+,r);

    return root;

    }

    }

    新的思路:

    使用快慢指针解决,慢指针遍历之后处于链表中间位置,slow位置就是根结点,slow->next就是二叉树的右子树,

    左边就是左子树。  要将左子树和右子树之间的链表断裂last.next=null  ,fast=slow.next;  左右子树都不包含根结点

    class Solution {

    public TreeNode sortedListToBST(ListNode head) {

    //注意若子树只有两个节点,只需以首节点为根构造右子节点为其后节点的子树

    if(head==null)return null;

    if(head.next==null)return new TreeNode(head.val);

    ListNode fast=head,slow=head,last=slow;

    while(fast.next!=null&&fast.next.next!=null){

    last=slow; //这里执行到最后一步的时候,last只比slow慢一个指针。

    slow=slow.next;

    fast=fast.next.next;

    }

    TreeNode root=new TreeNode(slow.val);

    fast=slow.next;//fast部分的链表转化为右子树

    if(slow!=last){

    last.next=null;

    root.left=sortedListToBST(head);

    }

    root.right=sortedListToBST(fast);

    return root;

    }

    }

    Java实现 LeetCode 109 有序链表转换二叉搜索树

    109. 有序链表转换二叉搜索树 给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树. 本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1. ...

    LeetCode109. 有序链表转换二叉搜索树

    109. 有序链表转换二叉搜索树 问题描述 给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树. 本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超 ...

    LeetCode(109):有序链表转换二叉搜索树

    Medium! 题目描述: 给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树. 本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1. 示例: ...

    LeetCode 109. 有序链表转换二叉搜索树(Convert Sorted List to Binary Search Tree)

    题目描述 给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树. 本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1. 示例: 给定的有序链表: ...

    [LeetCode] 109. 有序链表转换二叉搜索树

    题目链接 : https://leetcode-cn.com/problems/convert-sorted-list-to-binary-search-tree/ 题目描述: 给定一个单链表,其中的 ...

    LeetCode 中级 - 有序链表转换二叉搜索树(109)

    给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树. 本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1. 示例: 给定的有序链表: [-10 ...

    [LeetCode题解]109. 有序链表转换二叉搜索树 | 快慢指针 + 递归

    题目描述 给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树. 本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1. 示例: 给定的有序链表: ...

    [Swift]LeetCode109. 有序链表转换二叉搜索树 | Convert Sorted List to Binary Search Tree

    Given a singly linked list where elements are sorted in ascending order, convert it to a height bala ...

    Leetcode109. Convert Sorted List to Binary Search Tree有序链表转换二叉搜索树

    给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树. 本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1. 示例: 给定的有序链表: [-10 ...

    随机推荐

    ssh自动输入密码脚本 切换目录脚本

    利用expect的,首先查看expect,命令:which expect #!/usr/bin/expect -f spawn ssh 用户名@ip地址 expect "assword:&q ...

    DataTable插件指定某列不可排序

    datatable是一个jQuery扩展的表格插件.其提供了强大的表格功能. 官方地址:http://www.datatables.NET/ DataTable提供的表格样式里面,第一行都是会有排序功 ...

    Autodesk的照片建模云服务—Autodesk ReCap 360 photo

    现实捕捉技术方兴未艾,简单的讲现实捕捉技术就是把现实中的现状信息数字化到计算机中以便做进一步的处理.对于不同的应用目的会有不同的捕捉设备,工程或传媒娱乐行业中经常用到的肯定就是三维模型了.那如何得到三 ...

    记录一下centos安装httpd+php+mysql的过程

    1.安装apache httpd 这个貌似安装完centos后自带了,如果没有,也可以用yum安装 yum -y install httpd 2.安装php yum -y install php ph ...

    char 和 varchar

    固定长度或可变长度的字符数据类型. char [ ( n ) ] 固定长度,非 Unicode 字符数据,长度为 n 个字节.n 的取值范围为 1 至 8,000,存储大小是 n 个字节.char 的 ...

    基于visual Studio2013解决C语言竞赛题之1011对称

         题目 解决代码及点评 /* 11. 判断一个给定的5×5方阵是否以第3列为轴线对称? */ #include #include

    微信公众平台开发,图文回复、access_token生成调用、以及微信SDK的实现(2)

    上一节课,我给大家分享了微信API接入以及事件推送的回复,这是微信开发的第二节课,重点给说一说单图文回复,多图文回复,access_token,微信SDK. 公众号消息回复很多种形式,常见的形式有,文 ...

    Docker学习笔记 - Docker的简介

    传统硬件虚拟化:虚拟硬件,事先分配资源,在虚拟的硬件上安装操作系统,虚拟机启动起来以后资源就会被完全占用. 操作系统虚拟化:docker是操作系统虚拟化,借助操作系统内核特性(命名空间.cgroups ...

    Mybatis判断map参数是否存在

    主机连接虚拟机的mysql 记录

    检查远程的虚拟机是否可以ping通过 查看虚拟机IP为192.168.38.128 cmd窗口ping 192.168.38.128,出现如下界面说明是可以的 检查虚拟机mysql的端口号是否对外开通 ...

    展开全文
  • 给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树。 本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。 示例: 给定的有序链表: [-10, -3, 0, 5,...

    题目描述:
    给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树。

    本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

    示例:

    给定的有序链表: [-10, -3, 0, 5, 9],
    一个可能的答案是:[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树:
    在这里插入图片描述

    链接:https://leetcode-cn.com/problems/convert-sorted-list-to-binary-search-tree

    思路分析:链表寻找中间值是很麻烦的,将链表中的值存储到vector<int>中,这样支持随机访问,然后进行构造即可。

    代码:

    class Solution {
    public:
        vector<int> v;//vector数组
        TreeNode* FormBST(int start, int end)
        {
            if(start >= end)//终止条件
                return nullptr;
            int cur = (start + end) >> 1;//中间节点
            TreeNode* root = new TreeNode(v[cur]);//根节点
            root->left = FormBST(start,cur);//左子树
            root->right = FormBST(cur + 1,end);//右子树
            return root;
        }
        TreeNode* sortedListToBST(ListNode* head) {
            if(head == nullptr)
                return nullptr;
            while(head != nullptr)
            {
                v.push_back(head->val);
                head = head->next;
            }
            return FormBST(0,v.size());//构造bst,然后返回
        }
    };
    
    展开全文
  • 有序链表转换二叉搜索树(java实现)1. 题目2. 读题(需要重点注意的东西)3. 解法4. 可能有帮助的前置习题5. 所用到的数据结构与算法思想6. 总结 1. 题目 2. 读题(需要重点注意的东西) 需要注意的是,要建立的...

    1. 题目

    在这里插入图片描述

    2. 读题(需要重点注意的东西)

    • 需要注意的是,要建立的是一颗二叉搜索树,而二叉搜索树的建立,类似于二分查找法
    • 难点在于如何对链表进行二分查找(链表不具有数组那样能直接访问的特性)(快慢指针,具体请看下方代码)
    • 树的建立过程还是如下代码所示,关键就在于如何得到中间的节点mid
    // 建立根节点
    TreeNode root = new TreeNode(slow.val);
    // 递归建立左子树
    root.left = helper(start,mid);
    // 递归建立右子树
    root.right = helper(mid+1,end);
    

    3. 解法

    解法:递归

    /**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode() {}
     *     ListNode(int val) { this.val = val; }
     *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
     * }
     */
    /**
     * Definition for a binary tree node.
     * public class TreeNode {
     *     int val;
     *     TreeNode left;
     *     TreeNode right;
     *     TreeNode() {}
     *     TreeNode(int val) { this.val = val; }
     *     TreeNode(int val, TreeNode left, TreeNode right) {
     *         this.val = val;
     *         this.left = left;
     *         this.right = right;
     *     }
     * }
     */
    // 链表构建一棵树与数组的不同之处在于链表不能直接访问其中的对象
    // 链表求中点的方法:快慢指针(快指针每次走两步,慢指针每次走一步,当快指针走到null时,慢指针指向的值就是中点)
    class Solution {
        public TreeNode sortedListToBST(ListNode head) {
            if(head == null) return null;
            return helper(head,null);
        }
        private TreeNode helper(ListNode start, ListNode end){
            if(start == end) return null;
    
            ListNode slow = start;
            ListNode fast = start;
    		// 当快指针走到终点时,慢指针指向的节点,即为链表的中间节点
            while(fast != end && fast.next != end){
            	// 慢指针一次走一步
                slow = slow.next;
                // 快指针一次走两步
                fast = fast.next.next;
            }
    
            TreeNode root = new TreeNode(slow.val);
            // 左半部分递归
            root.left = helper(start, slow);
            // 右半部分递归
            root.right = helper(slow.next, end);
            return root;
        }
    }
    

    4. 可能有帮助的前置习题

    [LeetCode]108. 将有序数组转换为二叉搜索树(java实现)

    5. 所用到的数据结构与算法思想

    • 二叉搜索树(BST)的性质(主要是类似二分查找的左小右大性质)
    • 如何得到链表的中间节点—快慢指针
    • 递归法

    6. 总结

    • 二叉搜索树相关问题,最主要的思路是利用二叉搜索树的性质:即左子树的节点都比根节点小,右子树的节点值都比根节点大(因此经过中序遍历就是一个从小到大排列的数组,中序遍历翻转就能得到从大到小排列的数组),这种性质与二分查找的思想也是一致的,因此一颗BST的建立,靠的就是二分查找的思想。

    • 同时,要知道如何用代码实现一棵树的建立,即建立根节点
      new TreeNode(val)
      再递归建立左右子树
      root.left = creatTree(root.left);
      root.right= creatTree(root.right);

    • 最后,需要知道得到链表中间节点的方法—快慢指针

    展开全文
  • 有序链表转换二叉搜索树 https://leetcode-cn.com/problems/convert-sorted-list-to-binary-search-tree/ 给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树。 本题中,一个高度平衡二叉树...

    有序链表转换二叉搜索树

    https://leetcode-cn.com/problems/convert-sorted-list-to-binary-search-tree/

    给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树。

    本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

    示例:

    给定的有序链表: [-10, -3, 0, 5, 9],

    一个可能的答案是:[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树:

          0
         / \
       -3   9
       /   /
     -10  5

    /**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode() {}
     *     ListNode(int val) { this.val = val; }
     *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
     * }
     */
    /**
     * Definition for a binary tree node.
     * public class TreeNode {
     *     int val;
     *     TreeNode left;
     *     TreeNode right;
     *     TreeNode() {}
     *     TreeNode(int val) { this.val = val; }
     *     TreeNode(int val, TreeNode left, TreeNode right) {
     *         this.val = val;
     *         this.left = left;
     *         this.right = right;
     *     }
     * }
     */
    class Solution {
        public TreeNode sortedListToBST(ListNode head) {
            if(head==null){
                return null;
            }
            //链表转数组
            ListNode temp=head;
            int len=1;
            while(temp.next!=null){
                temp=temp.next;
                len++;
            }
            int[] num=new int[len];
            temp=head;
            for(int i=0;i<len;i++){
                num[i]=temp.val;
                temp=temp.next;
            }
            //构造树
            return buildtree(num,0,len-1);
        }
        public TreeNode buildtree(int[] num,int left,int right){
            if(left>right){
                return null;
            }
            //根节点为中点
            int middle=(left+right)/2;
            TreeNode root=new TreeNode(num[middle]);
            //递归构造左右子树
            root.left=buildtree(num,left,middle-1);
            root.right=buildtree(num,middle+1,right);
            return root;
        }
    }

     

    展开全文
  • 有序链表转换二叉搜索树 给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树。 本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。 示例: 给定的有序...
  • 给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树。 本题中,一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。 示例: 快慢指针解决 二叉搜索树的特点...
  • 109. 有序链表转换二叉搜索树 - 力扣(LeetCode) LeetCode第 108 题:将有序数组转化为二叉搜索树(C++)_zj-CSDN博客的进阶。 一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。 ...
  • 109. 有序链表转换二叉搜索树 给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树。 本题中,一个高度平...
  • 给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树。 本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。 示例: 给定的有序链表: [-10, -3, 0, 5, ...
  • 思路: ...先转换为数组存储元素的值,然后深度优先遍历重建, 代码: class Solution { private: vector<int> v; TreeNode* build(int left,int right){ if(left>right) r..
  • 给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树。 本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。 示例: 给定的有序链表:[-10,-3,0,5,9...
  • 有序链表转换二叉搜索树 这道题需要定义三个指针,通过快慢指针找出中点,作为根节点,然后从head-&amp;gt;last这段链表再递归调用,从slow指针写一个节点开始到最后,作为后一个链表再进行递归调用函数。 /** ...
  • /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * };... * Definition for binary tree * str...
  • 和108一样 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} ... * Definition for a binary tr...
  • 109. 有序链表转换二叉搜索树 给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树。 本题中,一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。 示例: ...
  • 二叉搜索树,二分查找
  • 原题链接:...1、二分法+递归 TreeNode* sortedListToBST(ListNode* head) { vector<int> v; while(head!=NULL){//先将链表值存入数组中 ...
  • 给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树。 本题中,一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。 示例: 给定的有序链表: [-10, ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,953
精华内容 3,581
关键字:

有序链表转换二叉搜索树