04——二分搜索树

最新推荐文章于 2023-01-07 20:29:55 发布
最新推荐文章于 2023-01-07 20:29:55 发布
阅读量139 收藏
点赞数 1
分类专栏： # 【01】方法总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxt_1/article/details/85212522
版权
本文深入探讨了二分查找法及其变种，包括查找多个目标元素的策略，以及二分搜索树的基本概念、插入、查找、删除操作的实现细节。此外，还详细介绍了如何在二分搜索树中实现floor、ceil、predecessor和successor等功能。
摘要由CSDN通过智能技术生成

文章目录

1.二分查找法变种（要查找的元素有多个）

在这里插入图片描述

在这里插入图片描述

实现

// 二分查找法, 在有序数组arr中, 查找target
// 如果找到target, 返回第一个target相应的索引index
// 如果没有找到target, 返回比target小的最大值相应的索引, 如果这个最大值有多个, 返回最大索引
// 如果这个target比整个数组的最小元素值还要小, 则不存在这个target的floor值, 返回-1
template<typename T>
int floor(T arr[], int n, T target){

    // 寻找比target小的最大索引
    int l = -1, r = n-1;
    while( l < r ){
        int mid = l + (r-l+1)/2;
        if( arr[mid] >= target )
            r = mid - 1;
        else
            l = mid;
    }

    assert( l == r );

    // 如果该索引+1就是target本身, 该索引+1即为返回值
    if( l + 1 < n && arr[l+1] == target )
        return l + 1;

    // 否则, 该索引即为返回值
    return l;
}


// 二分查找法, 在有序数组arr中, 查找target
// 如果找到target, 返回最后一个target相应的索引index
// 如果没有找到target, 返回比target大的最小值相应的索引, 如果这个最小值有多个, 返回最小的索引
// 如果这个target比整个数组的最大元素值还要大, 则不存在这个target的ceil值, 返回整个数组元素个数n
template<typename T>
int ceil(T arr[], int n, T target){

    assert( n >= 0 );

    // 寻找比target大的最小索引值
    int l = 0, r = n;
    while( l < r ){
        // 使用普通的向下取整即可避免死循环
        int mid = l + (r-l)/2;
        if( arr[mid] <= target )
            l = mid + 1;
        else // arr[mid] > target
            r = mid;
    }

    assert( l == r );

    // 如果该索引-1就是target本身, 该索引+1即为返回值
    if( r - 1 >= 0 && arr[r-1] == target )
        return r-1;

    // 否则, 该索引即为返回值
    return r;
}

2.二分搜索树

2.1 定义（与堆区别）

在这里插入图片描述

2.2 插入

在这里插入图片描述

实现

 // 向二分搜索树中插入一个新的(key, value)数据对
void insert(Key key, Value value){
    root = insert(root, key, value);
}

// 向以node为根的二分搜索树中, 插入节点(key, value)
// 返回插入新节点后的二分搜索树的根
Node* insert(Node *node, Key key, Value value){

   if( node == NULL ){
       count ++;
       return new Node(key, value);
   }

   if( key == node->key )
       node->value = value;
   else if( key < node->key )
       node->left = insert( node->left , key, value);
   else    // key > node->key
       node->right = insert( node->right, key, value);

   return node;
}

2.3 查找（contain、search）

// 查看二分搜索树中是否存在键key
bool contain(Key key){
     return contain(root, key);
 }

// 查看以node为根的二分搜索树中是否包含键值为key的节点
bool contain(Node* node, Key key){

    if( node == NULL )
        return false;

    if( key == node->key )
        return true;
    else if( key < node->key )
        return contain( node->left , key );
    else // key > node->key
        return contain( node->right , key );
}

// 在二分搜索树中搜索键key所对应的值。如果这个值不存在, 则返回NULL
Value* search(Key key){
    return search( root , key );
}

// 在以node为根的二分搜索树中查找key所对应的value
// 若value不存在, 则返回NULL
Value* search(Node* node, Key key){

    if( node == NULL )
        return NULL;

    if( key == node->key )
        return &(node->value);
    else if( key < node->key )
        return search( node->left , key );
    else // key > node->key
        return search( node->right, key );
}

2.4 删除

删除最小值

在这里插入图片描述

在这里插入图片描述

实现

// 删除掉以node为根的二分搜索树中的最小节点
// 返回删除节点后新的二分搜索树的根
Node* removeMin(Node* node){

    if( node->left == NULL ){

        Node* rightNode = node->right;
        delete node;
        count --;
        return rightNode;
    }

    node->left = removeMin(node->left);
    return node;
}
删除最大值

在这里插入图片描述

在这里插入图片描述

实现

// 删除掉以node为根的二分搜索树中的最大节点
// 返回删除节点后新的二分搜索树的根
Node* removeMax(Node* node){

    if( node->right == NULL ){

        Node* leftNode = node->left;
        delete node;
        count --;
        return leftNode;
    }

    node->right = removeMax(node->right);
    return node;
}
删除任意值

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

实现

// 删除掉以node为根的二分搜索树中键值为key的节点
// 返回删除节点后新的二分搜索树的根
Node* remove(Node* node, Key key){

    if( node == NULL )
        return NULL;

    if( key < node->key ){
        node->left = remove( node->left , key );
        return node;
    }
    else if( key > node->key ){
        node->right = remove( node->right, key );
        return node;
    }
    else{   // key == node->key

        if( node->left == NULL ){
            Node *rightNode = node->right;
            delete node;
            count --;
            return rightNode;
        }

        if( node->right == NULL ){
            Node *leftNode = node->left;
            delete node;
            count--;
            return leftNode;
        }

        // node->left != NULL && node->right != NULL
        Node *successor = new Node(minimum(node->right));
        count ++;

        successor->right = removeMin(node->right);
        successor->left = node->left;

        delete node;
        count --;

        return successor;
    }
}

2.5 实现floor、celi

// 寻找key的floor值
// 如果不存在key的floor值(key比BST中的最小值还小), 返回NULL
Key* floor(Key key){

    if( count == 0 || key < minimum() )
        return NULL;

    Node *floorNode = floor(root, key);
    return &(floorNode->key);
}

// 在以node为根的二叉搜索树中, 寻找key的floor值所处的节点, 递归算法
Node* floor(Node* node, Key key){

    if( node == NULL )
        return NULL;

    // 如果node的key值和要寻找的key值相等
    // 则node本身就是key的floor节点
    if( node->key == key )
        return node;

    // 如果node的key值比要寻找的key值大
    // 则要寻找的key的floor节点一定在node的左子树中
    if( node->key > key )
        return floor( node->left , key );

    // 如果node->key < key
    // 则node有可能是key的floor节点, 也有可能不是(存在比node->key大但是小于key的其余节点)
    // 需要尝试向node的右子树寻找一下
    Node* tempNode = floor( node->right , key );
    if( tempNode != NULL )
        return tempNode;

    return node;
}




// 寻找key的ceil值
// 如果不存在key的ceil值(key比BST中的最大值还大), 返回NULL
Key* ceil(Key key){

    if( count == 0 || key > maximum() )
        return NULL;

    Node *ceilNode = ceil(root, key);
    return &(ceilNode->key);
}

// 在以node为根的二叉搜索树中, 寻找key的ceil值所处的节点
Node* ceil(Node* node, Key key){

    if( node == NULL )
        return NULL;

    // 如果node的key值和要寻找的key值相等
    // 则node本身就是key的ceil节点
    if( node->key == key )
        return node;

    // 如果node的key值比要寻找的key值小
    // 则要寻找的key的ceil节点一定在node的右子树中
    if( node->key < key )
        return ceil( node->right , key );

    // 如果node->key > key
    // 则node有可能是key的ceil节点, 也有可能不是(存在比node->key小但是大于key的其余节点)
    // 需要尝试向node的左子树寻找一下
    Node* tempNode = ceil( node->left , key );
    if( tempNode != NULL )
        return tempNode;

    return node;
}

2.6 实现predecessor、successor

// 查找key的前驱
// 如果不存在key的前驱(key不存在, 或者key是整棵二叉树中的最小值), 则返回NULL
Key* predecessor(Key key){

    Node *node = search(root, key);
    // 如果key所在的节点不存在, 则key没有前驱, 返回NULL
    if(node == NULL)
        return NULL;

    // 如果key所在的节点左子树不为空,则其左子树的最大值为key的前驱
    if(node->left != NULL)
        return &(maximum(node->left)->key);

    // 否则, key的前驱在从根节点到key的路径上, 在这个路径上寻找到比key小的最大值, 即为key的前驱
    Node* preNode = predecessorFromAncestor(root, key);
    return preNode == NULL ? NULL : &(preNode->key);
}

// 在以node为根的二叉搜索树中, 寻找key的祖先中,比key小的最大值所在节点
// 算法调用前已保证key存在在以node为根的二叉树中
Node* predecessorFromAncestor(Node* node, Key key){

    if(node->key == key)
        return NULL;

    if(key < node->key)
        // 如果当前节点大于key, 则当前节点不可能是比key小的最大值
        // 向下搜索到的结果直接返回
        return predecessorFromAncestor(node->left, key);
    else{
        assert(key > node->key);
        // 如果当前节点小于key, 则当前节点有可能是比key小的最大值
        // 向右继续搜索, 将结果存储到tempNode中
        Node* tempNode = predecessorFromAncestor(node->right, key);
        if(tempNode)
            return tempNode;
        else
            // 如果tempNode为空, 则当前节点即为结果
            return node;
    }
}

    



// 查找key的后继
// 如果不存在key的后继(key不存在, 或者key是整棵二叉树中的最大值), 则返回NULL
Key* successor(Key key){

    Node *node = search(root, key);
    // 如果key所在的节点不存在, 则key没有前驱, 返回NULL
    if(node == NULL)
        return NULL;

    // 如果key所在的节点右子树不为空,则其右子树的最小值为key的后继
    if(node->right != NULL)
        return &(minimum(node->right)->key);

    // 否则, key的后继在从根节点到key的路径上, 在这个路径上寻找到比key大的最小值, 即为key的后继
    Node* sucNode = successorFromAncestor(root, key);
    return sucNode == NULL ? NULL : &(sucNode->key);
}

// 在以node为根的二叉搜索树中, 寻找key的祖先中,比key大的最小值所在节点
// 算法调用前已保证key存在在以node为根的二叉树中
Node* successorFromAncestor(Node* node, Key key){

    if(node->key == key)
        return NULL;

    if(key > node->key)
        // 如果当前节点小于key, 则当前节点不可能是比key大的最小值
        // 向下搜索到的结果直接返回
        return successorFromAncestor(node->right, key);
    else{
        assert(key < node->key);
        // 如果当前节点大于key, 则当前节点有可能是比key大的最小值
        // 向左继续搜索, 将结果存储到tempNode中
        Node* tempNode = predecessorFromAncestor(node->left, key);
        if(tempNode)
            return tempNode;
        else
            // 如果tempNode为空, 则当前节点即为结果
            return node;
    }
}
神秘的火柴人
关注
专栏目录
算法设计与分析——最优二分搜索树（动态规划）
karin_0的博客
11-03 4042
贪心算法
左小右大的树形结构——二分搜索树（Binary Search Tree）
啦啦啦小骑士的博客
11-20 2400
设计背景 在链表（LinkedList）中，每一个节点都存储着一个元素，还有一个指向下一个节点的指针。与这种特性类似，我们把“每一个节点都拥有两个指向不同节点的指针”的结构称之为二叉树（Binary Tree）；从形状上来看，这两个指针所指向的节点分别叫做“左子树”（left subtree）和“右子树”(right subtree)，而这个节点就是左右子树（亦可称作左右孩子）的父亲节点（fath...
二分查找未找到目标值
massive_jiang的博客
04-13 746
对于目标值tag，目标数组中未出现该目标值是，一定会有board[i]<tag<board[j]或者tag<board[0]或者tag>board[size-1] 1.明白二分查找循环条件beg<=end,即：未找到tag时，beg>end不再循环； 2.整个 二分查找过程，都在缩小tag所在的区间范围，end=mod-1或者beg=mod+1，故最后tag其实...
详细图文——二分搜索树
带翅膀的猫的博客
11-22 8583
上一篇→树与二叉树 &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;与普通的二叉树相比，二叉搜索树中的数据是有序的，它遵循以下规则：根结点值大于它的左孩子，根结点的值小于它的右孩子，同时每一棵子树也是二叉搜索树。如下图是一棵二叉搜索树。 二叉搜索树初步 &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nb
C++——《算法分析与设计》实验报告——二分搜索算法
无限迭代中......
05-07 2439
实验名称: 二分搜索算法 实验地点： 实验目的： 理解分治算法的概念和基本要素； 理解递归的概念； 掌握设计有效算法的分治策略； 通过二分搜索技术学习分治策略设计技巧； 实验原理 二分搜索算法也称为折半查找法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完...
分治算法——二分查找法
a1351937368的博客
04-05 7682
分治算法——二分查找法 分治算法在维基百科中的解释如下： 在计算机科学中，分治法是建基于多项分支递归的一种很重要的算法范式。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。 这个技巧是很多高效算法的基础，如排序算法（归并排序、快速排序）、傅立叶变换（快速傅立叶变换）。 另一方面，理解及设计分治法算...
【算法】二分搜索
最新发布
代码星辰的博客
01-07 4556
本文对二分搜索算法进行了详细地介绍，包括概述、代码实现和应用。
二分搜索树（Binary Search Tree）
小孙的博客
03-18 2028
本身是二叉树，只不过对于二分搜索树的每一个结点而言 大于其左子树的所有结点的值 小于其右子树的所有结点的值 同样，其子树也是一颗二分搜索树 那么该树中的元素要具有可比性不包含重复元素 ...
LeetCode450——删除二叉搜索树中的节点
清风阁
09-02 2092
我的LeetCode代码仓：https://github.com/617076674/LeetCode 原题链接：https://leetcode-cn.com/problems/delete-node-in-a-bst/description/ 题目描述： 知识点：二分搜索树 思路：二分搜索树删除节点的经典操作 本题考查的完全是数据结构的知识，二分搜索树的删除节点操作是二分搜索树中...
PTA - 二叉搜索树的结构 (30 分)——建树，输入处理
Mr_dimple的博客
04-01 2841
二叉搜索树的结构 (30 分) 文章目录题意：思路：1. 如何建树？2. 如何解决输入问题？完整Code：经验： 题意： 定义：二叉搜索树是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉搜索树。 给定一系列互不相等的整数，将它们顺次插入一棵初始为空的二叉搜索树。 给出 m 个对结果树的结构的描述，判断给定的描述是否正确。 描述有以下6种： A is the
数据结构——平衡搜索树（AVL、红黑树、B树）
sduihoal的博客
01-13 701
一、搜索数据结构 1. 概述 1）搜索/查找： ①遍历查找 O(n) ②二分查找 O(log(n)) ③哈希表 O(1) ④搜索树(平衡搜索树) 几种查找方式的比较： 哈希表实现线程安全还算容易，但树要实现线程安全不太容易 2. AVL树 1）节点结构： 必须是二叉树，必须是搜索树，任取树上节点且该节点的左右子树高度差不超过1（BF∈(-1,0,1)）。是二叉搜索树的一种进化版本。 class AVLTreeNode{ Key key; Value value; AVLTreeNode left;
图论系列（一）——图的基本概念和基本表示
神秘的火柴人的专栏
02-08 644
1. 图的分类 2. 图的基本概念（联通分量、联通图的生成树） 3. 图的基本表示（无向无权图为例） 实现代码： import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; public class AdjMatrix { priv...
图论系列（三）——图的深度优先遍历的应用1
神秘的火柴人的专栏
02-15 596
1. 联通分量 统计一个图中联通分量个数 判断两点是否联通 求每个联通分量中包含点编号 import java.util.ArrayList; //Connected Component —— 联通分量 public class CC { private Graph G; private int[] visited; //将 boolean型改为 int...
图论系列（五）——图的广度优先遍历及应用1
神秘的火柴人的专栏
03-29 486
1. 树的广度优先遍历与图的广度优先遍历对比
03——堆、堆排序(O(nlogm))
神秘的火柴人的专栏
12-16 483
文章目录1.二叉堆的定义（最大堆）2.二叉堆的存储3.操作3.1 插入元素（shift up）3.2 取出元素（shift down）4.堆的实现5.堆排序优化1（heapify）优化2（原地堆排序） 1.二叉堆的定义（最大堆） 2.二叉堆的存储 3.操作 3.1 插入元素（shift up） 插入前： 插入后： 3.2 取出元素（shift down） 取出前： 调整后： ...
02——归并排序、快速排序(O(nlogn))
神秘的火柴人的专栏
12-16 448
文章目录1.mergeSort优化应用：逆序对2.quickSort2.1 一次partition操作2.2 partition操作方式1实现方式优化2.3 存在问题（数组近乎有序、数组存在大量重复元素）2.3.1 数组近乎有序解决方法（换图。。。）2.3.2 数组存在大量重复元素解决方法1解决方法2 1.mergeSort 优化 应用：逆序对 // merge函数求出在arr[l....
LRU实现
神秘的火柴人的专栏
06-16 407
LRU(Least Recnetly Used)最近最少使用 淘汰最长时间未被使用的页面 思路： 依次插入A，B，C： 插入A： 先从哈希表中查找到A的value，存储的是该节点的地址； 在双端队列中将该A节点移到末尾 插入D： 取出head指向的节点，取出其中的key为B； 删除head指向的节点，同时在哈希表中删除； 将D插入到末尾 class LRUC...
图论系列（二）——图的深度优先遍历
神秘的火柴人的专栏
02-08 344
1. 树的深度优先遍历与图的深度优先遍历对比 2. 代码实现（递归版） import java.util.ArrayList; public class GraphDFS { private Graph G; private boolean[] visited; private ArrayList<Integer> order = new ArrayLis...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值