【C语言】B树查找、插入、删除以及代码实现

最新推荐文章于 2024-05-20 11:50:49 发布
最新推荐文章于 2024-05-20 11:50:49 发布
阅读量1.3k 收藏 18
点赞数 3
文章标签： b树 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44348253/article/details/128569865
版权

文章目录

B树

基本原理

B树是一种平衡的多路查找树，结点最大的孩子数目称为B树的阶。例如2-3树是3阶B树，2-3-4树是4阶b树。一个m阶B树具有如下属性：

  • 如果根结点不是叶子结点，则其至少有两颗子树。
  • 每一个非根的分支结点都有k-1个元素和k个孩子，其中ceil(m/2) ≤ k ≤ m。每一个叶子结点m都有k-1个元素，其中ceil(m/2) ≤ k ≤ m。
  • 所有叶子结点都位于同一层次。
  • 所有分支结点包含下列信息数据（n， A 0 A_0 A0​， K 1 K_1 K1​， A 1 A_1 A1​， K 2 K_2 K2​， A 2 A_2 A2​，…， K n K_n Kn​， A n A_n An​），其中： K i K_i Ki​（i=1，2，…，n）为关键字，且 K i K_i Ki​ < K i + 1 K_i+1 Ki​+1（i=1，2，…，n-1）； A i A_i Ai​（i=0，1，2，…，n）为指向子树根结点的指针，且指针 A i − 1 A_i-1 Ai​−1所指子树中所有结点的关键字均小于 K i K_i Ki​（i=1，2，…，n）， A n A_n An​所指子树中所有结点的关键字均大于 K n K_n Kn​，n（ceil(m/2)-1 ≤ n ≤ m-1）为关键字的个数（或n+1为子树的个数）。

查找

在m阶B树T上查找关键字Key，从根结点找起，在每个结点内做遍历查找，找到对应的关键字则返回对应关键字在结点中的序号，以及指向该结点的指针。若未找到，则返回关键字所在区间的子树的指针，继续在子树中查找。

插入

先依据查找算法找到对应关键字应在B树中的所在的位置，并将key值插入。检查该结点关键字个数是否超出规定（ceil(m/2) ≤ keyNum ≤ m-1）。若超出，则以结点中间关键字为界，之前的作为中间关键字的左子树，之后的作为中间关键字的右子树。将中间关键字插入到结点的父亲结点的相应位置。继续检查父亲结点的关键字个数是否满足要求。

删除

先依据查找算法找到对应关键字在B树中所在的位置。之后，判断该结点是否为叶子结点。

  • 若是叶子结点：先直接删除该关键字，之后对该结点进行平衡判断，看关键字数目是否满足要求。
  • 若不是叶子结点：则判断该关键字的左子树或右子树是否富有（即关键字数目 > ceil(m/2)）。若左子树富有，则将左子树中提取最大关键字放到该结点中替换要删除的关键字。若右子树富有，则将右子树中提取最小关键字放到该结点中替换要删除的关键字。若左右子树都不富有，则合并左右子树。然后删除结点的关键字，再对该结点进行平衡判断。

平衡判断：若该结点的关键字数目不满足最小要求。则找到该关键字的右兄弟结点或左兄弟结点看是否富有。若右兄弟富有则进行左旋操作，若左兄弟富有则进行右旋操作。若都不富有，则将该结点和其左右兄弟的其中一个以及父亲结点中的分隔符合并。

代码实现

/*
 * @Author: Xyh4ng
 * @Date: 2023-01-02 20:24:30
 * @LastEditors: Xyh4ng
 * @LastEditTime: 2023-01-05 20:17:06
 * @Description:
 * Copyright (c) 2023 by Xyh4ng 503177404@qq.com, All Rights Reserved.
 */
#include <stdio.h>
#include <stdlib.h>

#define M 3 // B树的阶
#define MIN_KEYNUM (M + 1) / 2 - 1

typedef struct BTreeNode
{
    int keyNum;               // 结点中关键字的数量
    struct BTreeNode *parent; // 指向双亲结点
    struct Node               // 存放关键字以及其孩子节点指针，正常结点最多存放m个孩子，但在插入判断时会多存放一个
    {
        int key;
        struct BTreeNode *ptr;
    } node[M + 1]; // key的0号单元未使用
} BTreeNode, *BTree;

typedef struct Result
{
    int tag;       // 查找成功的标志
    BTreeNode *pt; // 指向查找到的结点
    int i;         // 结点在关键字中的序号
} Result;

int Search(BTree T, int K)
{
    int i = 0;
    for (int j = 1; j <= T->keyNum; j++)
    {
        if (T->node[j].key <= K)
        {
            i = j;
        }
    }
    return i;
}

/* 在m阶B树T上查找关键字K，返回结果(pt,i,tag)。若查找成功，则特征值tag=1，指针pt所指结点中第i个关键字等于K；否则特征值tag=0，等于K的关键字应插入在指针Pt所指结点中第i和第i+1个关键字之间。 */
Result SearchBTree(BTree T, int K)
{
    BTree p = T, q = NULL; /*  初始化，p指向待查结点，q指向p的双亲  */
    int found = 0;
    int index = 0;
    Result r;
    while (p && !found)
    {
        index = Search(p, K); // p->node[index].key ≤ K < p->node[index+1].key
        if (index > 0 && p->node[index].key == K)
            found = 1;
        else
        {
            q = p;
            p = p->node[index].ptr;
        }
    }
    r.i = index;
    if (found) // 查找成功
    {
        r.tag = 1;
        r.pt = p;
    }
    else
    {
        r.tag = 0;
        r.pt = q;
    }
    return r;
}

void Insert(BTree *q, int key, BTree ap, int i)
{
    for (int j = (*q)->keyNum; j > i; j--) // 空出(*q)->node[i+1]
    {
        (*q)->node[j + 1] = (*q)->node[j];
    }
    (*q)->node[i + 1].key = key;
    (*q)->node[i + 1].ptr = ap;
    (*q)->keyNum++;
}

// 将结点q分裂成两个结点，mid之前的结点保留，mid之后结点移入新生结点ap
void Split(BTree *q, BTree *ap)
{
    int mid = (M + 1) / 2;
    *ap = (BTree)malloc(sizeof(BTreeNode));
    (*ap)->node[0].ptr = (*q)->node[mid].ptr;
    if ((*ap)->node[0].ptr)
    {
        (*ap)->node[0].ptr->parent = *ap;
    }

    for (int i = mid + 1; i <= M; i++)
    {
        (*ap)->node[i - mid] = (*q)->node[i];
        if ((*ap)->node[i - mid].ptr)
        {
            (*ap)->node[i - mid].ptr->parent = *ap;
        }
    }
    (*ap)->keyNum = M - mid;
    (*ap)->parent = (*q)->parent;
    (*q)->keyNum = mid - 1;
}

// 生成含信息(T,r,ap)的新的根结点&T，原T和ap为子树指针
void NewRoot(BTree *T, int key, BTree ap)
{
    BTree p;
    p = (BTree)malloc(sizeof(BTreeNode));
    p->node[0].ptr = *T; // 根结点孩子数最小为2，则将T作为左孩子，ap作为右孩子
    *T = p;
    if ((*T)->node[0].ptr)
    {
        (*T)->node[0].ptr->parent = *T;
    }
    (*T)->parent = NULL;
    (*T)->keyNum = 1;
    (*T)->node[1].key = key;
    (*T)->node[1].ptr = ap;
    if ((*T)->node[1].ptr)
    {
        (*T)->node[1].ptr->parent = *T;
    }
}

/*  在m阶B树T上结点*q的key[i]与key[i+1]之间插入关键字K的指针r。若引起结点过大,则沿双亲链进行必要的结点分裂调整,使T仍是m阶B树。 */
void InseartBTree(BTree *T, int key, BTree q, int i)
{
    BTree ap = NULL;
    int finished = 0;
    int rx = key; // 需要插入的关键字的值
    int mid;
    while (q && !finished)
    {
        Insert(&q, rx, ap, i);
        if (q->keyNum < M)
            finished = 1;
        else // 结点关键字数超出规定
        {
            int mid = (M + 1) / 2; // 结点的中间关键字序号
            rx = q->node[mid].key;
            Split(&q, &ap); // 将q->key[mid+1..M],q->ptr[mid..M]移入新结点*ap
            q = q->parent;
            if (q)
                i = Search(q, rx);
        }
    }
    if (!finished)
    {
        NewRoot(T, rx, ap);
    }
}

void Delete(BTree *q, int index)
{
    for (int i = index; i <= (*q)->keyNum; i++)
    {
        (*q)->node[index] = (*q)->node[index + 1];
    }
    (*q)->keyNum--;
}

void LeftRotation(BTree *q, BTree *p, int i)
{
    // 将父亲结点转移至q结点的末尾
    (*q)->keyNum++;
    (*q)->node[(*q)->keyNum].key = (*p)->node[i + 1].key;
    // 将q结点的右兄弟的第一个关键字转移至父亲结点的分隔符位置
    BTree rightBroPtr = (*p)->node[i + 1].ptr;
    (*p)->node[i + 1].key = rightBroPtr->node[1].key;
    // 将右结点的关键字前移
    for (int j = 1; j < rightBroPtr->keyNum; j++)
    {
        rightBroPtr->node[j] = rightBroPtr->node[j + 1];
    }
    rightBroPtr->keyNum--;
}

void RightRotation(BTree *q, BTree *p, int i)
{
    // 将q结点向后移动空出第一个关键字的位置
    for (int j = (*q)->keyNum; j >= 1; j--)
    {
        (*q)->node[j + 1] = (*q)->node[j];
    }
    // 将父亲结点移动至q结点的第一个关键字的位置
    (*q)->node[1].key = (*p)->node[i].key;
    (*q)->node[1].ptr = NULL;
    (*q)->keyNum++;
    // 将左兄弟结点的最后一个关键字移动至父亲结点的分隔符位置
    BTree leftBroPtr = (*p)->node[i - 1].ptr;
    (*p)->node[i].key = leftBroPtr->node[leftBroPtr->keyNum].key;
    leftBroPtr->keyNum--;
}

void BalanceCheck(BTree *q, int key);

void MergeNode(BTree *q, BTree *p, int i)
{
    BTree rightBroPtr = NULL, leftBroPtr = NULL;
    if (i + 1 <= (*p)->keyNum)
    {
        rightBroPtr = (*p)->node[i + 1].ptr;
    }
    if (i - 1 >= 0)
    {
        leftBroPtr = (*p)->node[i - 1].ptr;
    }
    if (rightBroPtr)
    {
        // 将父亲结点的分隔符移动至q结点的最后
        (*q)->keyNum++;
        (*q)->node[(*q)->keyNum].key = (*p)->node[i + 1].key;
        // 将右兄弟结点都移动到q结点上
        (*q)->node[(*q)->keyNum].ptr = rightBroPtr->node[0].ptr;
        for (int j = 1; j <= rightBroPtr->keyNum; j++)
        {
            (*q)->keyNum++;
            (*q)->node[(*q)->keyNum] = rightBroPtr->node[j];
        }
        // 将父亲结点的分隔符删除
        int key = (*p)->node[i + 1].key;
        for (int j = i + 1; j < (*p)->keyNum; j++)
        {
            (*p)->node[j] = (*p)->node[j + 1];
        }
        (*p)->keyNum--;
        if (!(*p)->parent && !(*p)->keyNum)
        {
            // 判断父亲结点是否为根结点，且关键字为空
            // 让q结点作为根结点
            (*q)->parent = NULL;
            (*p) = (*q);
        }
        BalanceCheck(p, key);
    }
    else if (leftBroPtr)
    {
        // 将父亲结点的分隔符移动至左兄弟结点的最后
        leftBroPtr->keyNum++;
        leftBroPtr->node[leftBroPtr->keyNum].key = (*p)->node[i].key;
        // 将q结点都移动到左兄弟结点上
        leftBroPtr->node[leftBroPtr->keyNum].ptr = (*q)->node[0].ptr;
        for (int j = 1; j <= (*q)->keyNum; j++)
        {
            leftBroPtr->keyNum++;
            leftBroPtr->node[leftBroPtr->keyNum] = (*q)->node[j];
        }
        // 将父亲结点的分隔符删除
        int key = (*p)->node[i].key;
        for (int j = i; j < (*p)->keyNum; j++)
        {
            (*p)->node[j] = (*p)->node[j + 1];
        }
        (*p)->keyNum--;
        if (!(*p)->parent && !(*p)->keyNum)
        {
            // 判断父亲结点是否为根结点，且关键字为空
            // 让q结点作为根结点
            (*q)->parent = NULL;
            (*p) = (*q);
        }
        BalanceCheck(p, key);
    }
}

void BalanceCheck(BTree *q, int key)
{
    if ((*q)->keyNum < MIN_KEYNUM) // 该结点不满足最小关键字数目要求
    {

        BTree p = (*q)->parent;
        int i = Search(p, key);                                            // 找到q结点在父亲结点中的索引
        if (i + 1 <= p->keyNum && p->node[i + 1].ptr->keyNum > MIN_KEYNUM) // 看q结点的右兄弟是否存在多余结点
        {
            LeftRotation(q, &p, i);
        }
        else if (i - 1 >= 0 && p->node[i - 1].ptr->keyNum > MIN_KEYNUM) // 看q结点的左兄弟是否存在多余结点
        {
            RightRotation(q, &p, i);
        }
        else // q结点的左右兄弟都不存在多余结点
        {
            // 将q结点和其左右兄弟的其中一个以及父亲结点中的分隔符合并
            MergeNode(q, &p, i);
        }
    }
}

void MergeBro(BTree *left, BTree *right)
{
    if (!(*left)->node[((*left)->keyNum)].ptr)
    {
        // 如果左子树为叶子结点
        (*left)->node[(*left)->keyNum].ptr = (*right)->node[0].ptr;
        for (int j = 1; j <= (*right)->keyNum; j++)
        {
            (*left)->keyNum++;
            (*left)->node[(*left)->keyNum] = (*right)->node[j];
        }
    }
    else
    {
        // 左子树不是叶子结点，则先将左子树最后一个子结点和右子树第一个子结点合并
        MergeBro(&(*left)->node[(*left)->keyNum].ptr, &(*right)->node[0].ptr);
        for (int j = 1; j <= (*right)->keyNum; j++)
        {
            (*left)->keyNum++;
            (*left)->node[(*left)->keyNum] = (*right)->node[j];
        }
    }
    // 合并完对左子树关键字数目进行判断
    if ((*left)->keyNum >= M)
    {
        int mid = (M + 1) / 2; // 结点的中间关键字序号
        int rx = (*left)->node[mid].key;
        BTree ap = NULL;
        Split(&(*left), &ap); // 将q->key[mid+1..M],q->ptr[mid..M]移入新结点*ap
        BTree p = (*left)->parent;
        int i = Search(p, rx);
        Insert(&p, rx, ap, i);
    }
}

void DeleteBTreeNode(BTree *T, int key)
{
    Result res = SearchBTree(*T, key);
    if (res.tag) // 查找成功
    {
        // 判断该结点是否是叶子结点
        if (!res.pt->node[res.i].ptr)
        {
            // 若是叶子结点，则直接删除，然后对该结点进行平衡判断
            Delete(&res.pt, res.i);
            BalanceCheck(&res.pt, key);
        }
        else
        {
            // 若不是叶子节点
            BTree leftChildPtr = res.pt->node[res.i - 1].ptr;
            BTree rightChildPtr = res.pt->node[res.i].ptr;
            if (leftChildPtr->keyNum > MIN_KEYNUM) // 左子树富有，则将左子树中提取最大值放到该结点中替换要删除的关键字
            {
                res.pt->node[res.i].key = leftChildPtr->node[leftChildPtr->keyNum].key;
                leftChildPtr->keyNum--;
            }
            else if (rightChildPtr->keyNum > MIN_KEYNUM) // 右子树富有，则将右子树中提取最小值放到该结点中替换要删除的关键字
            {
                res.pt->node[res.i].key = rightChildPtr->node[1].key;
                for (int j = 1; j < rightChildPtr->keyNum; j++)
                {
                    rightChildPtr->node[j] = rightChildPtr->node[j + 1];
                }
                rightChildPtr->keyNum--;
            }
            else // 左右子树都不富有，则合并左右子树
            {
                MergeBro(&leftChildPtr, &rightChildPtr);
                // 删除结点的关键字
                res.i = Search(res.pt, key); // 合并结点可能会改变结点中关键字的次序，重新查序
                for (int j = res.i; j < res.pt->keyNum; j++)
                {
                    res.pt->node[j] = res.pt->node[j + 1];
                }
                res.pt->keyNum--;
                // 对结点进行平衡判断
                BalanceCheck(&res.pt, key);
            }
        }
    }
    else // 查找失败
    {
        printf("您删除的元素不存在");
    }
}

int main()
{
    int r[16] = {22, 16, 41, 58, 8, 11, 12, 16, 17, 9, 23, 13, 52, 58, 59, 61};
    BTree T = NULL;
    Result s;
    int i;
    for (int i = 0; i < 16; i++)
    {
        s = SearchBTree(T, r[i]);
        if (!s.tag)
            InseartBTree(&T, r[i], s.pt, s.i);
    }

    while (1)
    {
        printf("\n请输入要删除的关键字: ");
        scanf("%d", &i);
        DeleteBTreeNode(&T, i);
    }
}
xyh_h
关注
  • 3
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
B树之C语言实现（包括查找、删除、插入）
GDUT小铭的博客
01-25 4698
我在大二上学期的数据结构实验设计中选择了B树这个题目，该B树的数据结构实现采用了C语言。趁现在寒假整理完写一篇博文记录我的学习。文末提供了项目源代码的地址。 B树的定义 一棵m阶B树（Balanced Tree of order m），或为空树，或为满足下列特性对的m叉树。 树中每个结点最多含有m棵子树。 若根结点不是叶子结点，则至少有2个子树。 除根结点之外的所有非终端结点至...
B树C语言实现-创建、插入、删除
Meikongggg的博客
11-21 1666
1. 课程设计题目标题:  B树的基本操作算法（创建、插入、删除） 问题描述:  在计算机科学中，B树在查找、访问、插入、删除操作上时间复杂度为O（log2~n），与自平衡二叉查找树不同的是B树对大块数据读写的操作有更优的性能，其通常在数据库和文件系统中被使用。   对于一棵B树，对其进行创建、插入、删除的基本操作。 2. 算法描述 (1) 总体思路(最初的算法) 一棵m阶的B树
B树代码实现
aq64824的博客
08-22 120
B树代码实现
【C语言】B 树全代码实现与超超详细思路解读（五天的呕心沥血，绝对原创每个细节，详解查找、插入与删除）
Ice__Clean的博客
12-05 1985
本文详细解读了 B 树的查找、插入与删除代码，其中代码有大量的注释，同时还附上了个人的编写思路、代码总体思路、应该注意的地方以及需要避开的坑等等。对于某些需要解释的参数，也都做了详细的说明。相信看完本篇博客，即便不参考文中的代码，手撕一份 B 树也是没问题的啦
【数据结构】B树和B+树（定义 查找 删除 插入）解析+完整代码
最新发布
m0_61628700的博客
05-20 893
5叉查找树查找方式：顺序查找每个灰框里的元素，找不到则去孩子那里找。如何保证查找效率？若每个结点内关键字太少，导致树变高，要查更多层结点，效率低。解决策略：1.m叉树中，规定除了根节点外，任何结点至少有⌈m2⌉⌈m/2⌉，即至少含有⌈m2⌉−1⌈m/2⌉−1个关键词。2.m叉查找树中，规定对于任何结点，其所有子树的高度都要相同。B树定义B树，又称多路平衡查找树，B树中被允许的孩子个数的最大值称为B树的阶，通常用m表示。
b树简单实现（插入和查找）
m0_52439806的博客
04-05 150
【代码】b树简单实现（插入和查找）
B树的基本操作
shijiemoxing的专栏
08-14 1052
/* *B树的基本操作 */ #include #include #define m 3//B树的阶 #define N 16//数据元素个数 #define MAX 5//字符串最大长度+1 typedef int KeyType;//设关键字域为整型
B-树的实现（第九章 P239 算法9.13,9.14）
但行好事，莫问前程
04-16 562
文章论述部分转自：https://blog.csdn.net/qq_35644234/article/details/66969238 1、背景知识 二叉查找树查询的时间复杂度是，从算法逻辑上来讲，二叉查找树的查找速度和比较次数都是最小的。但是，我们不得不考虑一个现实问题：磁盘 IO 。数据库索引是存储在磁盘上的，当数据量比较大的时候，索引的大小可能有几个 G 甚至更多。当我们利...
数据结构与算法分析-C++描述 第4章 B树
qq_37172182的博客
03-27 361
B树的性质： 1）树中每个结点最多含有m棵子树； 2）若根结点不是叶子结点，则至少有2个子树； 3）除根结点之外的所有非终端结点至少有棵子树； 4）每个非终端结点中包含信息：，其中： 1）为关键字，且关键字按升序排序； 2）指针指向子树的根结点，指向子树中所有结点的关键字均小于，且大于； 3）关...
数据结构C语言实现代码.zip
10-22
B树则常用于数据库和文件系统，因为它支持大范围的高效查找、插入和删除操作。 3. **图数据结构**：图是由顶点和边组成的，可以表示各种复杂关系，如邻接矩阵和邻接表是两种常见的图表示方式。图的遍历算法，如深度...
C语言开发 BTREE 数据文件索引程序库.rar_B+树索引_C璇█_C语言_搜索_查找
09-20
这个名为"C语言开发 BTREE 数据文件索引程序库.rar"的压缩包内容似乎包含了一个C语言实现的B+树索引库，能够支持基本的查找、插入和删除操作。 B+树是一种自平衡的多路搜索树，它的特点在于所有叶子节点都在同一层...
Ｂ树的Ｃ语言实现，代码比较条理
09-21
5. **查找、插入、删除操作**：B树支持高效的查找、插入和删除操作，通常在O(log n)的时间复杂度内完成，其中n是树中元素的数量。 **C语言实现** C语言是一种静态类型、编译型、通用的、大小写敏感的、不仅支持...
B树+B树实现的图书管理系统(C语言)(广东工业大学课程设计2019).zip
01-11
在信息技术领域，数据结构是构建高效算法的基础，而B树作为一种自平衡的查找树，因其高效的查找、插入和删除性能，在数据库系统和文件系统中广泛应用。本项目以C语言为基础，结合2019年广东工业大学的课程设计，实现...
链表的C语言实现之单链表的查找运算
08-03
在计算机科学中，链表是一种线性数据结构，它...总的来说，理解和掌握单链表的查找、插入和删除操作对于学习数据结构和C语言编程至关重要。通过熟练运用这些基础知识，可以构建更复杂的数据结构和算法，解决实际问题。
B+树的插入与删除
naturerun的博客
12-05 2747
B+树删除(仅考虑阶数m>=3的情形，注意叶节点合并时需要修改叶节点顺序链表的链接指针，下文并未提到) 删除仅在叶节点上进行,在叶节点上删除给定关键码后，如果叶节点为根节点则删除操作结束(此时删除后的B+树可能为空树).如果不为根节点且含有的关键码树>=ceil(m/2)[ceil表示向上取整]则删除操作结束，如果删除的是叶节点最右侧的关键码，还需用新的最右侧关键码沿叶节点至根节点的路径向上更新父节点指向叶节点，父节点的父节点-指向父节点—–的索引项，直到根节点的索引项被更新或被更新的索引项不
B树的原理及代码实现、B+树和B*树介绍及应用
weixin_61857742的博客
01-03 1897
B树主要用于磁盘文件的检索操作。众所周知，平衡二叉树（AVL树、红黑树）搜索的时间复杂度是O(log^n)。虽然很快，但如果数据在磁盘中且有上亿量级的数据，即便只有30次左右的IO操作，速度也是非常慢的。因为磁盘IO速度极慢，主要是寻道操作影响，平均8ms左右。因此，磁盘数据的检索不适合使用平衡二叉树，B树正式上线。B树可以看成是压缩版的平衡二叉树，每一个节点上都有保存有多个值，且有多个叶子节点。一般而言，B树的检索次数在个位量级，这取决于每个节点上能保存多少个值。
数据结构-考研难点代码突破（C++实现树型查找 - B树插入与遍历，B+树基本概念）
dodamce的博客
02-28 1409
B树，又称多路平衡查找树，B树中所有结点的孩子个数的最大值称为B树的阶，通常用m表示。
数据结构-二叉查找（排序）树的插入，创建，查找，删除（含全部代码）
关注网络安全、云原生安全
01-18 8630
主要函数： BST_Insert(BSTree &T, TElemType data) 参数T，二叉查找树根节点 作用：插入数据data,保证中序非严格递增（即可重复） PreOrder(BSTree T) 参数T，二叉查找树根节点 作用：先序遍历二叉查找树，递归方式 InOrder(BSTree T) 参数T，二叉查找树根节点 作用：中序遍历二叉查找树，递归方式 PostOrd...
B树C语言代码实现
weixin_34414650的博客
09-30 545
2019独角兽企业重金招聘Python工程师标准>>> ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值