精华内容
下载资源
问答
  • 给定一个排好序的数组,去构造二叉排序 array = [10,-3,0,5,9] 思路 找到数组的中点,然后递归构造左右。 代码 def array_build_tree(array): if len(array) == 0: return None mid = len(array)//2 root =...

    题目

    给定一个排好序的数组,去构造二叉排序树
    array = [10,-3,0,5,9]

    思路

    找到数组的中点,然后递归构造左右树。

    代码

    def array_build_tree(array):
      if len(array) == 0:
        return None
    
      mid = len(array)//2
      root = Node(array[mid])
    
      root._left = array_build_tree(array[:mid])
      root._right = array_build_tree(array[mid+1:])
      return root
    
    展开全文
  • 108. 将有序数组转换为二叉搜索树 难度简单621 将一个按照升序排列的有序数组,转换为一棵高度平衡二叉搜索树。 本题中,一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。 ...

    108. 将有序数组转换为二叉搜索树

    跟树_05重复了

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

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

    示例:

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

    解题思路

    参考:代码随想录
    可以回忆一下构造二叉树,那个相对复杂点,需要由中序+前序,或者中序+后序。找到数组的中间位置,然后以中间位置为界限,将数组分为左右两边的子数组。然后子数组递归做下去。
    这题构造BST也是一样的道理。

    需要注意的点有:

    1.求中间位置的时候使用int mid = l+(r-l)/2,而不是int mid = (l+r)/2,防止l,r都是很大的数值时操作越界。

    2.循环不变量,也就是如果使用区域时保持一种风格,比如前面左闭右闭,那么后面的也是左闭右闭。

    作者:jasscical
    链接:https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree/solution/108jiang-you-xu-shu-zu-gou-zao-er-cha-sou-suo-shu-/

    /**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
     * };
     */
    class Solution {
    public:
        TreeNode* traverse(vector<int>& nums, int l, int r)
        {
            if(l > r) return nullptr;
            int mid = l + (r-l)/2; //求中间位置
            TreeNode *root = new TreeNode(nums[mid]);
            
            root->left = traverse(nums, l, mid-1); //左边有序数组拿去构造BST
            root->right = traverse(nums, mid+1, r); //右边有序数组拿去构造BST
            return root;
        }
        TreeNode* sortedArrayToBST(vector<int>& nums) {
           //TreeNode *root = traverse(nums, 0, nums.size()-1);
           //return root;
           return traverse(nums, 0, nums.size()-1);
        }
    };
    

     

    展开全文
  • 1.将有序数组转换二叉搜索树 中序遍历二叉树:若二叉树为空,则空操作,否则①中序遍历左子树;②访问根节点;③中序遍历右子树。我们可以明确该问题的子问题是:构造树的每个节点以及该节点的左右子树。递归结束的...

    1.将有序数组转换二叉搜索树

    中序遍历二叉树:若二叉树为空,则空操作,否则①中序遍历左子树;②访问根节点;③中序遍历右子树。我们可以明确该问题的子问题是:构造树的每个节点以及该节点的左右子树。递归结束的条件是:当输入的递增数组为空时即左下标大于了右下标,只能构成一棵空树,此时返回空节点(空指针)。当构造节点的左右子树时,对递增数组进行拆分并进行递归调用。

    众所周知,一棵二叉搜索树是一棵有根二叉树并且对于所有节点满足特殊的性质:对于树中任意一个点,它的权值必然 ≥ 所有左子树节点的权值,≤ 所有右子树节点的权值。因为二叉树具有递归的子结构,二叉搜索树也同理:所有子树也是二叉搜索树。还要求根节点的值大于其左子树中任意一个节点的值,小于其右子树中任意一节点的值。

    class Solution {
    public:
    TreeNode* sortedArrayToBST(vector<int>& nums){
        return helper(nums,0,nums.size()-1);
    }
    TreeNode* helper(vector<int>& nums,int left,int right){
        if(left>right) return nullptr;
        int mid=(left+right+1)/2;
        TreeNode* root=new TreeNode(nums[mid]);
        root->left=helper(nums,left,mid-1);
        root->right=helper(nums,mid+1,right);
        return root;
    }
    };

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

    3.检查平衡性

    类的成员函数是指那些把定义和原型写在类定义内部的函数,就像类定义中的其他变量一样。类成员函数是类的一个成员,它可以操作类的任意对象,可以访问对象中的所有成员。平衡树的定义如下:任意一个节点,其两棵子树的高度差不超过 1。

    class Solution {
    public:
        int getheight(TreeNode* root){
        if(root==NULL) return 0;
        else return max(getheight(root->left),getheight(root->right))+1;
    }
     bool isBalanced(TreeNode* root){
         if(root==NULL) return true;
         stack <TreeNode*> s;
         s.push(root);
         while(!s.empty()){
            TreeNode* temp=s.top();
            //cout<<temp->val<<" ";
            if(abs(getheight(temp->left)-getheight(temp->right))>1) return false;
            s.pop();
            if(temp->right!=NULL){
                s.push(temp->right);
            }
            if(temp->left!=NULL){
                s.push(temp->left);
            }
        }
        return true;
     }
    };

    4.合法二叉搜索树

    检查一棵树是否为二叉搜索树。二叉排序树或者是一个空树;或者是具有下列性质的二叉树:①若它的左子树不空,则左子树上所有结点的值均小于它的根节点的值②若它的右子树不空,则右子树上所有结点的值均大于它的根节点的值③它的左,右子树也分别为二叉排序树。

    class Solution {
    public:
        bool isValidBST(TreeNode* root) {
     if(root==NULL) return true;
         TreeNode* maxleft=root->left, *minright=root->right;
         while(maxleft!=NULL&&maxleft->right!=NULL) maxleft=maxleft->right;
         while(minright!=NULL&&minright->left!=NULL) minright=minright->left;
         //判断这一层是否合法
         bool re=(maxleft==NULL||root->val>maxleft->val)&&(minright==NULL||root->val<minright->val);
         return re&&isValidBST(root->left)&&isValidBST(root->right);
        }
    };

    5.二叉搜索树的最近公共祖先

    参考https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-zui-jin-gong-gong-zu-xian-lcof/solution/mian-shi-ti-68-i-er-cha-sou-suo-shu-de-zui-jin-g-7/

    这个root也不特指根节点。根据定义最近祖先公共节点也可以是节点本身。怎么来判断,root,p,q的子树关系?注意所有节点的值都是唯一的

    class Solution {
    public:
        TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
            TreeNode* temp=root;//temp用来遍历
        while(temp!=NULL){
            if(p->val<temp->val&&q->val<temp->val) temp=temp->left;
            else if(p->val>temp->val&&q->val>temp->val) temp=temp->right;
            else break;
        }
        return temp;
        }
    };

     

    展开全文
  • 和 ⼆叉树:构造⼀棵最⼤的⼆叉树简单⼀些,因为有序数组构造⼆叉搜索树,寻找分割点就⽐较容易了。 分割点就是数组中间位置的节点。 那么为问题来了,如果数组⻓度为偶数,中间节点有两个,取哪⼀个? 取哪⼀个都...

    在这里插入图片描述数组构造⼆叉树,构成平衡树是⾃然⽽然的事情。本质就是寻找分割点,分割点作为当前节点,然后递归左区间和右区间。

    本题其实要⽐⼆叉树:构造⼆叉树登场! 和 ⼆叉树:构造⼀棵最⼤的⼆叉树简单⼀些,因为有序数组构造⼆叉搜索树,寻找分割点就⽐较容易了。

    分割点就是数组中间位置的节点。
    那么为问题来了,如果数组⻓度为偶数,中间节点有两个,取哪⼀个?
    取哪⼀个都可以,只不过构成了不同的平衡⼆叉搜索树。

    递归

    1、确定递归函数返回值及其参数
    除⼆叉树节点,增加⼆叉树节点,都是⽤递归函数的返回值来完成,这样是⽐较⽅便。那么本题要构造⼆叉树,依然⽤递归函数的返回值来构造中节点的左右孩⼦。

    再来看参数,⾸先是传⼊数组,然后就是左下表left和右下表right,我们在⼆叉树:构造⼆叉树登场! 中提过,在构造⼆叉树的时候尽量不要重新定义左右区间数组,⽽是⽤下表来操作原数组。

    // 左闭右闭区间[left, right] 也可以左闭右开
    TreeNode* traversal(vector<int>& nums, int left, int right)
    

    2、确定递归终⽌条件

    这⾥定义的是左闭右闭的区间,所以当区间 left > right的时候,就是空节点了。
    if (left > right) return nullptr;
    

    3、确定单层递归的逻辑
    ⾸先取数组中间元素的位置,不难写出 int mid = (left + right) / 2; , 这么写其实有⼀个问题,就是数值越界,例如left和right都是最⼤int,这么操作就越界了,在⼆分法中尤其需要注意!
    所以可以这么写: int mid = left + ((right - left) / 2);相当于是如果数组⻓度为偶数,中间位置有两个元素,取靠左边的。
    但本题leetcode的测试数据并不会越界,所以怎么写都可以。但需要有这个意识!

    取了中间位置,就开始以中间位置的元素构造节点,代码: TreeNode* root = new TreeNode(nums[mid]); 。
    接着划分区间, root的左孩⼦接住下⼀层左区间的构造节点,右孩⼦接住下⼀层右区间构造的节点。
    最后返回root节点,单层递归整体代码如下:

     TreeNode* traversal(vector<int>& nums,int left,int right){
     if(left>right) return nullptr;
     int rootvalue=nums[(right+left)/2];
     int delimit=(right+left)/2;
     TreeNode* root=new TreeNode(rootvalue);
     root->left=traversal(nums,left,delimit-1);
     root->right=traversal(nums,delimit+1,right);
     return root;
    
    class Solution {
    private:
        TreeNode* traversal(vector<int>& nums,int left,int right){
             if(left>right) return nullptr;
                 int rootvalue=nums[(right+left)/2];
                 int delimit=(right+left)/2;
                 TreeNode* root=new TreeNode(rootvalue);
                 root->left=traversal(nums,left,delimit-1);
                 root->right=traversal(nums,delimit+1,right);
                 return root;
        }
    public:
        TreeNode* sortedArrayToBST(vector<int>& nums) {
          return traversal(nums,0,nums.size()-1);
        }
    };
    

    迭代法 (。。。。。)

    class Solution {
    public:
    	TreeNode* sortedArrayToBST(vector<int>& nums) {
    		if (nums.size() == 0) return nullptr;
    		TreeNode* root = new TreeNode(0); // 初始根节点
    		queue<TreeNode*> nodeQue; // 放遍历的节点
    		queue<int> leftQue; // 保存左区间下表
    		queue<int> rightQue; // 保存右区间下表
    		nodeQue.push(root); // 根节点⼊队列
    		leftQue.push(0); // 0为左区间下表初始位置
    
    
    		rightQue.push(nums.size() - 1); // nums.size() - 1为右区间下表初始位置
    		while (!nodeQue.empty()) {
    			TreeNode* curNode = nodeQue.front();
    			nodeQue.pop();
    			int left = leftQue.front(); leftQue.pop();
    			int right = rightQue.front(); rightQue.pop();
    			int mid = left + ((right - left) / 2);
    			curNode->val = nums[mid]; // 将mid对应的元素给中间节点
    			if (left <= mid - 1) { // 处理左区间
    				curNode->left = new TreeNode(0);
    				nodeQue.push(curNode->left);
    				leftQue.push(left);
    				rightQue.push(mid - 1);
    			}
    			if (right >= mid + 1) { // 处理右区间
    				curNode->right = new TreeNode(0);
    				nodeQue.push(curNode->right);
    				leftQue.push(mid + 1);
    				rightQue.push(right);
    			}
    		}
    		return root;
    	}
    };
    		
    
    展开全文
  • //将有序数组转化为二叉搜索树 //二叉搜索树:每一个节点的值大于左孩子的值,小于右孩子的值,如果采用中序遍历,输出结果为从小到大的 public BinaryTree arrayToBST(T array[],int start,int end) { if(start...
  • 二维数组是最简单的数据结构,一张数据库表就可以看做一个二维数组,例如: 二维数组就是一个既有行又有列的表: 一行就表示一个主题(记录) 一列就是描述主题(记录)的一个特性 每一列存储同一个类型的数据...
  • C#使用数组实现二叉查找

    千次阅读 2014-11-08 21:08:37
    原创性申明: 本文地址是 ...二叉排序树 (Binary Sort Tree)又称二叉查找树(Binary Search Tree),亦称二叉搜索树。 它或者是一棵空树;或者是具有下列性质的二叉树: (1)若
  • [LeetCode] Convert Sorted Array to Binary Search Tree 将有序数组转为二叉搜索树 Given an array where elements are sorted in ascending order, convert it to a height balanced BST. For this problem, a...
  • 一、数组构建普通的二叉排序二、数组构建高度最小的二叉排序三、主函数进行测试 一、数组构建普通的二叉排序 普通的二叉排序只需要保证二叉树的根节点大于或等于其左子树,根节点小于其右子即可,具体的...
  • 大(小)根堆(heap),二叉搜索树(BST),树堆(treap) 注意这三个数据结构的复习,各种操作和变形最好要熟记。 poj练习解题报告 poj数算实习小组题目清单 »树状数组练习题(3题) Newest Problems...
  • 将一个按照升序排列的有序数组,转换为一棵高度平衡二叉搜索树。 本题中,一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。 示例: 给定有序数组: [-10,-3,0,5,9], 一个可能...
  • 数组实现二叉查找

    2014-07-15 18:47:02
    1,实例变量,构造器,数组扩展 private Object[] contents; private int count; public ArrayBinarySearchTree(Object root) { //Object[] contents = new Object[10]; 悲剧啊!!!!局部变量覆盖了类成员变量
  • 将有序数组转换为二叉搜索树 【easy】 给你一个整数数组 nums ,其中元素已经按 升序 排列,请你将其转换为一棵 高度平衡 二叉搜索树。 高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过...
  • 二叉搜索树的中序遍历是升序序列,题目给定的数组是按照升序排序的有序数组,因此可以确保数组二叉搜索树的中序遍历序列。 给定二叉搜索树的中序遍历,是否可以唯一地确定二叉搜索树?答案是否定的。 如果增加一个...
  • 二叉搜索树的中序遍历是升序序列,题目给定的数组是按照升序排序的有序数组,因此可以确保数组二叉搜索树的中序遍历序列。 给定二叉搜索树的中序遍历,是否可以唯一地确定二叉搜索树?答案是否定的。
  • 将一个按照升序排列的有序数组,转换为一棵高度平衡二叉搜索树(BST)。 本题中,一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。 2、代码详解 附:此题提交时必须注释掉...
  • 二叉搜索树的中序遍历是升序序列,题目给定的数组是按照升序排序的有序数组,因此可以确保数组二叉搜索树的中序遍历序列。 给定二叉搜索树的中序遍历,是否可以唯一地确定二叉搜索树?答案是否定的。如果没有要求...
  • LeetCode0108-将有序数组转换为二叉搜索树 题目: 代码: /** * 0108-将有序数组转换为二叉搜索树 * 将一个按照升序排列的有序数组,转换为一棵高度平衡二叉搜索树。 * <p> * 本题中,一个高度平衡二叉树...
  • 108:将有序数组转换为二叉搜索树 题目: 将一个按照升序排列的有序数组,转换为一棵高度平衡二叉搜索树。 本题中,一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。题目链接 ...
  • 其实就是构建一个二叉搜索树,对于搜索树,有三个特点: 1、根节点左边的都比根节点小。 2、根节点右边的都比根节点大。 3、左孩子和右孩子都是搜索树。 因此通过递归构建左孩子,右孩子。 class Solution...
  • //思路:每次都以中间靠左的数作为根节点,递归构造二叉搜索树 public TreeNode sortedArrayToBST(int[] nums) { if (nums == null || nums.length == 0) { return null; } return helper(nums,0,nums.length
  • 108 根据有序数组构造平衡的二叉排序 点击此处返回总目录 109 根据有序链表构造平衡的二叉排序 ... 一、108 根据有序数组构造平衡的二叉排序 【题目】 ...
  • 目录LeetCode 108: 将有序数组转换为二叉搜索树题目描述解题 LeetCode 108: 将有序数组转换为二叉搜索树 题目描述 将一个按照升序排列的有序数组,转换为一棵高度平衡二叉搜索树。 本题中,一个高度平衡二叉树是指一...
  • 4、如何构造二叉搜索树 选取根节点 构造该节点的左子树 构造该节点的右子树 5、要求构造高度平衡的二叉树 所以选择数组的中间节点作为根节点来保持平衡性 代码: class Solution { public TreeNode sortedArrayTo...
  • 给出一个有序数组(递增),使用该数组构造一个平衡二叉查找
  • title: leetcode-108 | 将有序数组转换为二叉搜索树 date: 2019-10-6 10:35:37 author: 无涯明月 toc: true categories: leetcode tags: - leetcode 简单难度 108. 将有序数组转换为二叉搜索树 题目描述 将一个按照...
  • 将有序数组转换为二叉搜索树 思路: 将数组转换为平衡树:每次取数组中间值构造根节点(对于偶数数组,不管取哪个都是平衡的,只是样子不同); 数组为有序:这样构造出来的树变成搜索树,而不是普通的二叉树 class...
  • 将有序数组转换为二叉搜索树(简单) 2020年5月7日 题目来源:力扣 将一个按照升序排列的有序数组,转换为一棵高度平衡二叉搜索树。 本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,000
精华内容 5,200
关键字:

数组构造二叉搜索树