b+树时间复杂度_leetCode. 二叉搜索树专题(4)

最新推荐文章于 2024-02-25 13:52:03 发布

weixin_39598941

最新推荐文章于 2024-02-25 13:52:03 发布

阅读量314

点赞数

文章标签： b+树时间复杂度 l2-004 这是二叉搜索树吗? pta 是否完全二叉搜索树

高度平衡的二叉搜索树简介

什么是一个高度平衡的二叉搜索树?

树结构中的常见用语:
1.节点的深度 - 从树的根节点到该节点的边数
2.节点的高度 - 该节点和叶子之间最长路径上的边数
3.树的高度 - 其根节点的高度

一个高度平衡的二叉搜索树（平衡二叉搜索树）是在插入和删除任何节点之后，可以自动保持其高度最小。也就是说，有N个节点的平衡二叉搜索树，它的高度是logN。并且，每个节点的两个子树的高度不会相差超过1。

为什么是logN呢?

一个高度为h的二叉树

换言之，一个有N个节点，且高度为h的二叉树:

所以：

.下面是一个普通二叉搜索树和一个高度平衡的二叉搜索树的例子:

根据定义, 我们可以判断出一个二叉搜索树是否是高度平衡的 (平衡二叉树)。

正如我们之前提到的, 一个有N个节点的平衡二搜索叉树的高度总是logN。因此，我们可以计算节点总数和树的高度，以确定这个二叉搜索树是否为高度平衡的。

同样，在定义中，我们提到了高度平衡的二叉树一个特性: 每个节点的两个子树的深度不会相差超过1。我们也可以根据这个性质，递归地验证树。

为什么需要用到高度平衡的二叉搜索树?

我们已经介绍过了二叉树及其相关操作, 包括搜索、插入、删除。当分析这些操作的时间复杂度时，我们需要注意的是树的高度是十分重要的考量因素。以搜索操作为例，如果二叉搜索树的高度为h，则时间复杂度为O(h)。二叉搜索树的高度的确很重要。

所以，我们来讨论一下树的节点总数N和高度h之间的关系。对于一个平衡二叉搜索树, 我们已经在前文中提过,

。但对于一个普通的二叉搜索树，在最坏的情况下, 它可以退化成一个链。

因此，具有N个节点的二叉搜索树的高度在logN到N区间变化。也就是说，搜索操作的时间复杂度可以从logN变化到N。这是一个巨大的性能差异。

所以说，高度平衡的二叉搜索树对提高性能起着重要作用。

如何实现一个高度平衡的二叉搜索树?

有许多不同的方法可以实现。尽管这些实现方法的细节有所不同，但他们有相同的目标:

采用的数据结构应该满足二分查找属性和高度平衡属性。
采用的数据结构应该支持二叉搜索树的基本操作，包括在O(logN)时间内的搜索、插入和删除，即使在最坏的情况下也是如此。

我们提供了一个常见的的高度平衡二叉树列表供您参考：红黑树、AVL树、伸展树、树堆。

高度平衡的二叉搜索树的实际应用

高度平衡的二叉搜索树在实际中被广泛使用，因为它可以在O(logN)时间复杂度内执行所有搜索、插入和删除操作。

平衡二叉搜索树的概念经常运用在Set和Map中。 Set和Map的原理相似。我们将在下文中重点讨论Set这个数据结构。

Set(集合)是另一种数据结构，它可以存储大量key(键)而不需要任何特定的顺序或任何重复的元素。它应该支持的基本操作是将新元素插入到Set中，并检查元素是否存在于其中。

通常，有两种最广泛使用的集合：散列集合(Hash Set)和树集合(Tree Set)。树集合, Java中的Treeset或者C++中的set，是由高度平衡的二叉搜索树实现的。因此，搜索、插入和删除的时间复杂度都是O(logN)。散列集合, Java中的HashSet或者C++中的unordered_set，是由哈希实现的, 但是平衡二叉搜索树也起到了至关重要的作用。当存在具有相同哈希键的元素过多时，将花费O(N)时间复杂度来查找特定元素，其中N是具有相同哈希键的元素的数量。通常情况下，使用高度平衡的二叉搜索树将把时间复杂度从 O(N) 改善到 O(logN)。哈希集和树集之间的本质区别在于树集中的键是有序的。

总结

高度平衡的二叉搜索树是二叉搜索树的特殊表示形式，旨在提高二叉搜索树的性能。了解高度平衡二叉搜索树的的基本概念，以及如何运用它帮助你进行算法设计是非常有用的。

leetCode 110. 平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树 每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

返回 true 。示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

返回 false 。

Solution1. C

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
int abs(int num) {
    return (num < 0 ? -num : num);
}

int max(int a, int b) {
    return (a > b ? a : b);
}

int depth(struct TreeNode* node) {
    if(node == NULL)
        return 0;
    return max(depth(node->left), depth(node->right)) + 1;
}

bool isBalanced(struct TreeNode* root) {
    if(root == NULL)
        return true;
    int leftDepth = depth(root->left);
    int rightDepth = depth(root->right);
    return abs(leftDepth - rightDepth) <= 1 && isBalanced(root->left) && isBalanced(root->right);
}

Solution2. C++

/**
 * 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:
    int checkHeight(TreeNode* root) {
        if(root == NULL)
            return 0;
        int leftHeight = checkHeight(root->left);
        if(leftHeight == -1)
            return -1;
        int rightHeight = checkHeight(root->right);
        if(rightHeight == -1)
            return -1;
        if(abs(leftHeight - rightHeight) > 1)
            return -1;
        return max(leftHeight, rightHeight) + 1;
    }
    
    bool isBalanced(TreeNode* root) {
        return checkHeight(root) != -1;
    }
};

Solution3. Java

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    private int checkHeight(TreeNode root) {
        if(root == null)
            return 0;
        int leftHeight = checkHeight(root.left);
        if(leftHeight == -1)
            return -1;
        int rightHeight = checkHeight(root.right);
        if(rightHeight == -1)
            return -1;
        if(Math.abs(leftHeight - rightHeight) > 1)
            return -1;
        return Math.max(leftHeight, rightHeight) + 1;
    }
    
    public boolean isBalanced(TreeNode root) {
        return checkHeight(root) != -1;
    }
}

Solution4. Python3

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def depth(self, root):
        if not root:
            return 0
        return max(self.depth(root.left), self.depth(root.right)) + 1
    
    def isBalanced(self, root: TreeNode) -> bool:
        if not root:
            return True
        leftDepth = self.depth(root.left)
        rightDepth = self.depth(root.right)
        return abs(leftDepth-rightDepth)<=1 and self.isBalanced(root.left) and self.isBalanced(root.right)

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

将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。
本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。示例:

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

      0
     / 
   -3   9
   /   /
 -10  5

Solution1. C

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
struct TreeNode* sortedArrayToBSTHelper(int* nums, int left, int right) {
    if(left > right)
        return NULL;
    int mid = (left + right) / 2;
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = nums[mid];
    root->left = sortedArrayToBSTHelper(nums, left, mid-1);
    root->right = sortedArrayToBSTHelper(nums, mid+1, right);
    return root;
}

struct TreeNode* sortedArrayToBST(int* nums, int numsSize) {
    if(nums == NULL || numsSize == 0)
        return NULL;
    return sortedArrayToBSTHelper(nums, 0, numsSize-1);
}

Solution2. Java

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        if(nums.length == 0)
            return null;
        return sortedArrayToBSTHelper(nums, 0, nums.length-1);
    }
    
    private TreeNode sortedArrayToBSTHelper(int[] nums, int left, int right) {
        if(left > right)
            return null;
        int mid = (left + right) / 2;
        TreeNode node = new TreeNode(nums[mid]);
        node.left = sortedArrayToBSTHelper(nums, left, mid-1);
        node.right = sortedArrayToBSTHelper(nums, mid+1, right);
        return node;
    }
}

Solution3. Python3

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        if not nums:
            return None
        return self.sortedArrayToBSTHelper(nums, 0, len(nums)-1)
    
    def sortedArrayToBSTHelper(self, nums, left, right):
        if left > right:
            return None
        mid = (left + right) // 2
        root = TreeNode(nums[mid])
        root.left = self.sortedArrayToBSTHelper(nums, left, mid-1)
        root.right = self.sortedArrayToBSTHelper(nums, mid+1, right)
        return root

weixin_39598941

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
b+树时间复杂度_leetCode. 二叉搜索树专题(4)

高度平衡的二叉搜索树简介什么是一个高度平衡的二叉搜索树?树结构中的常见用语:1.节点的深度 - 从树的根节点到该节点的边数2.节点的高度 - 该节点和叶子之间最长路径上的边数3.树的高度 - 其根节点的高度一个高度平衡的二叉搜索树（平衡二叉搜索树）是在插入和删除任何节点之后，可以自动保持其高度最小。也就是说，有N个节点的平衡二叉搜索树，它的高度是logN。并且，每个节点的两个子树的高度不会相...
复制链接

扫一扫