AVL、B-TREE、B+TREE及算法可视化网站

已于 2023-05-23 16:28:56 修改
阅读量529 收藏 2
点赞数 2
分类专栏： C++开发后端基础知识 文章标签： 数据结构 算法
于 2023-02-16 16:11:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IS_MOKE/article/details/129064014
版权

目录

二分查找

在这里插入图片描述

平衡二叉树

在这里插入图片描述
缺点：
树的高度较大
需要找出>5的数需要遍历树，效率低

btree/b-tree

在这里插入图片描述

减少树的高度（每一个节点都存储在磁盘中，每次对比后找下一个节点是一次磁盘寻址。树的深度大，磁盘寻址就要多次。）
缺点：
范围查找：需要找出>5的数需要遍历树，效率低

一颗M阶B树， 满足以下条件：(M 是一个节点最大能有M颗子树)
1.每个结点至多拥有M颗子树
2.根结点至少拥有两颗子树
3.除了根结点以外，其余每个分支结点至少拥有M/2颗子树
4.所有的叶结点都在同一层上
5.有k颗子树的分支结点，则存在k-1个关键字，关键字按照递增顺序进行排序；（代码中一般不会要求递增）
6.关键字数量满足ceil(M/2)-1<=n<=M-1

#define DEGREE		3
typedef int KEY_VALUE;

typedef struct _btree_node {
	KEY_VALUE *keys;//一维数组
	struct _btree_node **childrens;//二维数组
	int num;//当前节点存储的数据
	int leaf;//是否为叶子节点，是为1，否为0
} btree_node;

typedef struct _btree {
	btree_node *root;
	int t;
} btree;

btree_node *btree_create_node(int t, int leaf) {

	btree_node *node = (btree_node*)calloc(1, sizeof(btree_node));//自带清零(malloc没有)，防止内存不够
	if (node == NULL) assert(0);

	node->leaf = leaf;
	node->keys = (KEY_VALUE*)calloc(1, (2*t-1)*sizeof(KEY_VALUE));
	node->childrens = (btree_node**)calloc(1, (2*t) * sizeof(btree_node*));
	node->num = 0;

	return node;
}
void btree_destroy_node(btree_node *node) {

	assert(node);

	free(node->childrens);
	free(node->keys);
	free(node);
	
}

btree的添加

（M一般为偶数，k=m-1就为奇数，可以将最中间的节点作为key）
在这里插入图片描述
先分裂，再添加。
在这里插入图片描述
在这里插入图片描述

分裂代码：

在这里插入图片描述
在这里插入图片描述


void btree_split_child(btree *T, btree_node *x, int i) {
	int t = T->t;

	btree_node *y = x->childrens[i];
	btree_node *z = btree_create_node(t, y->leaf);//新建一个z，把后面的几个节点放入到z中

	z->num = t - 1;

	int j = 0;
	for (j = 0;j < t-1;j ++) {
		z->keys[j] = y->keys[j+t];//新建一个z，把后面的几个节点放入到z中
	}
	if (y->leaf == 0) {//不是叶子节点，是内节点
		for (j = 0;j < t;j ++) {
			z->childrens[j] = y->childrens[j+t];
		}
	}
	
	//把x提上去，x的子树进行更新
	y->num = t - 1;
	for (j = x->num;j >= i+1;j --) {
		x->childrens[j+1] = x->childrens[j];
	}

	x->childrens[i+1] = z;

	for (j = x->num-1;j >= i;j --) {
		x->keys[j+1] = x->keys[j];
	}
	x->keys[i] = y->keys[t-1];
	x->num += 1;
	
}

在这里插入图片描述

//节点为根节点，而且根节点已经满了，做一个空节点在根节点上方在进行分裂
void btree_insert(btree *T, KEY_VALUE key) {
	//int t = T->t;

	btree_node *r = T->root;
	if (r->num == 2 * T->t - 1) {
		
		btree_node *node = btree_create_node(T->t, 0);
		T->root = node;

		node->childrens[0] = r;

		btree_split_child(T, node, 0);

		int i = 0;
		if (node->keys[0] < key) i++;
		btree_insert_nonfull(T, node->childrens[i], key);
		
	} else {
		btree_insert_nonfull(T, r, key);
	}
}

btree的删除：

先借位或者合并，然后再删除；
向右借位
FI的key数量2，是M/2-1的时候就需要借位。
在这里插入图片描述
借位借不到的时候就进行合并。
在这里插入图片描述

合并代码：

在这里插入图片描述

//{child[idx], key[idx], child[idx+1]} 
void btree_merge(btree *T, btree_node *node, int idx) {

	btree_node *left = node->childrens[idx];
	btree_node *right = node->childrens[idx+1];

	int i = 0;

	/data merge
	left->keys[T->t-1] = node->keys[idx];//把c拷贝到B后面
	for (i = 0;i < T->t-1;i ++) {
		left->keys[T->t+i] = right->keys[i];
	}
	if (!left->leaf) {
		for (i = 0;i < T->t;i ++) {
			left->childrens[T->t+i] = right->childrens[i];
		}
	}
	left->num += T->t;

	//destroy right
	btree_destroy_node(right);

	//node： C没有了FI要前移
	for (i = idx+1;i < node->num;i ++) {
		node->keys[i-1] = node->keys[i];
		node->childrens[i] = node->childrens[i+1];
	}
	node->childrens[i+1] = NULL;
	node->num -= 1;

	if (node->num == 0) {
		T->root = left;
		btree_destroy_node(node);
	}
}

完整代码：



#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <assert.h>

#define DEGREE		3
typedef int KEY_VALUE;

typedef struct _btree_node {
	KEY_VALUE *keys;
	struct _btree_node **childrens;
	int num;
	int leaf;
} btree_node;

typedef struct _btree {
	btree_node *root;
	int t;
} btree;

btree_node *btree_create_node(int t, int leaf) {

	btree_node *node = (btree_node*)calloc(1, sizeof(btree_node));//自带清零，防止内存不够
	if (node == NULL) assert(0);

	node->leaf = leaf;
	node->keys = (KEY_VALUE*)calloc(1, (2*t-1)*sizeof(KEY_VALUE));//自带清零，防止内存不够
	node->childrens = (btree_node**)calloc(1, (2*t) * sizeof(btree_node*));
	node->num = 0;

	return node;
}

void btree_destroy_node(btree_node *node) {

	assert(node);

	free(node->childrens);
	free(node->keys);
	free(node);
	
}


void btree_create(btree *T, int t) {
	T->t = t;
	
	btree_node *x = btree_create_node(t, 1);
	T->root = x;
	
}


void btree_split_child(btree *T, btree_node *x, int i) {
	int t = T->t;

	btree_node *y = x->childrens[i];
	btree_node *z = btree_create_node(t, y->leaf);

	z->num = t - 1;

	int j = 0;
	for (j = 0;j < t-1;j ++) {
		z->keys[j] = y->keys[j+t];
	}
	if (y->leaf == 0) {
		for (j = 0;j < t;j ++) {
			z->childrens[j] = y->childrens[j+t];
		}
	}

	y->num = t - 1;
	for (j = x->num;j >= i+1;j --) {
		x->childrens[j+1] = x->childrens[j];
	}

	x->childrens[i+1] = z;

	for (j = x->num-1;j >= i;j --) {
		x->keys[j+1] = x->keys[j];
	}
	x->keys[i] = y->keys[t-1];
	x->num += 1;
	
}

void btree_insert_nonfull(btree *T, btree_node *x, KEY_VALUE k) {

	int i = x->num - 1;

	if (x->leaf == 1) {
		
		while (i >= 0 && x->keys[i] > k) {
			x->keys[i+1] = x->keys[i];
			i --;
		}
		x->keys[i+1] = k;
		x->num += 1;
		
	} else {
		while (i >= 0 && x->keys[i] > k) i --;

		if (x->childrens[i+1]->num == (2*(T->t))-1) {
			btree_split_child(T, x, i+1);
			if (k > x->keys[i+1]) i++;
		}

		btree_insert_nonfull(T, x->childrens[i+1], k);
	}
}


//节点为根节点，而且根节点已经满了，做一个空节点在根节点上方在进行分裂
void btree_insert(btree *T, KEY_VALUE key) {
	//int t = T->t;

	btree_node *r = T->root;
	if (r->num == 2 * T->t - 1) {
		
		btree_node *node = btree_create_node(T->t, 0);
		T->root = node;

		node->childrens[0] = r;

		btree_split_child(T, node, 0);

		int i = 0;
		if (node->keys[0] < key) i++;
		btree_insert_nonfull(T, node->childrens[i], key);
		
	} else {
		btree_insert_nonfull(T, r, key);
	}
}

void btree_traverse(btree_node *x) {
	int i = 0;

	for (i = 0;i < x->num;i ++) {
		if (x->leaf == 0) 
			btree_traverse(x->childrens[i]);
		printf("%C ", x->keys[i]);
	}

	if (x->leaf == 0) btree_traverse(x->childrens[i]);
}

void btree_print(btree *T, btree_node *node, int layer)
{
	btree_node* p = node;
	int i;
	if(p){
		printf("\nlayer = %d keynum = %d is_leaf = %d\n", layer, p->num, p->leaf);
		for(i = 0; i < node->num; i++)
			printf("%c ", p->keys[i]);
		printf("\n");
#if 0
		printf("%p\n", p);
		for(i = 0; i <= 2 * T->t; i++)
			printf("%p ", p->childrens[i]);
		printf("\n");
#endif
		layer++;
		for(i = 0; i <= p->num; i++)
			if(p->childrens[i])
				btree_print(T, p->childrens[i], layer);
	}
	else printf("the tree is empty\n");
}


int btree_bin_search(btree_node *node, int low, int high, KEY_VALUE key) {
	int mid;
	if (low > high || low < 0 || high < 0) {
		return -1;
	}

	while (low <= high) {
		mid = (low + high) / 2;
		if (key > node->keys[mid]) {
			low = mid + 1;
		} else {
			high = mid - 1;
		}
	}

	return low;
}


//{child[idx], key[idx], child[idx+1]} 
void btree_merge(btree *T, btree_node *node, int idx) {

	btree_node *left = node->childrens[idx];
	btree_node *right = node->childrens[idx+1];

	int i = 0;

	/data merge
	left->keys[T->t-1] = node->keys[idx];//把c拷贝到B后面
	for (i = 0;i < T->t-1;i ++) {
		left->keys[T->t+i] = right->keys[i];
	}
	if (!left->leaf) {
		for (i = 0;i < T->t;i ++) {
			left->childrens[T->t+i] = right->childrens[i];
		}
	}
	left->num += T->t;

	//destroy right
	btree_destroy_node(right);

	//node： C没有了FI要前移
	for (i = idx+1;i < node->num;i ++) {
		node->keys[i-1] = node->keys[i];
		node->childrens[i] = node->childrens[i+1];
	}
	node->childrens[i+1] = NULL;
	node->num -= 1;

	if (node->num == 0) {
		T->root = left;
		btree_destroy_node(node);
	}
}

void btree_delete_key(btree *T, btree_node *node, KEY_VALUE key) {

	if (node == NULL) return ;

	int idx = 0, i;

	while (idx < node->num && key > node->keys[idx]) {
		idx ++;
	}

	if (idx < node->num && key == node->keys[idx]) {

		if (node->leaf) {
			
			for (i = idx;i < node->num-1;i ++) {
				node->keys[i] = node->keys[i+1];
			}

			node->keys[node->num - 1] = 0;
			node->num--;
			
			if (node->num == 0) { //root
				free(node);
				T->root = NULL;
			}

			return ;
		} else if (node->childrens[idx]->num >= T->t) {

			btree_node *left = node->childrens[idx];
			node->keys[idx] = left->keys[left->num - 1];

			btree_delete_key(T, left, left->keys[left->num - 1]);
			
		} else if (node->childrens[idx+1]->num >= T->t) {

			btree_node *right = node->childrens[idx+1];
			node->keys[idx] = right->keys[0];

			btree_delete_key(T, right, right->keys[0]);
			
		} else {

			btree_merge(T, node, idx);
			btree_delete_key(T, node->childrens[idx], key);
			
		}
		
	} else {

		btree_node *child = node->childrens[idx];
		if (child == NULL) {
			printf("Cannot del key = %d\n", key);
			return ;
		}

		if (child->num == T->t - 1) {

			btree_node *left = NULL;
			btree_node *right = NULL;
			if (idx - 1 >= 0)
				left = node->childrens[idx-1];
			if (idx + 1 <= node->num) 
				right = node->childrens[idx+1];

			if ((left && left->num >= T->t) ||
				(right && right->num >= T->t)) {

				int richR = 0;
				if (right) richR = 1;
				if (left && right) richR = (right->num > left->num) ? 1 : 0;

				if (right && right->num >= T->t && richR) { //borrow from next
					child->keys[child->num] = node->keys[idx];
					child->childrens[child->num+1] = right->childrens[0];
					child->num ++;

					node->keys[idx] = right->keys[0];
					for (i = 0;i < right->num - 1;i ++) {
						right->keys[i] = right->keys[i+1];
						right->childrens[i] = right->childrens[i+1];
					}

					right->keys[right->num-1] = 0;
					right->childrens[right->num-1] = right->childrens[right->num];
					right->childrens[right->num] = NULL;
					right->num --;
					
				} else { //borrow from prev

					for (i = child->num;i > 0;i --) {
						child->keys[i] = child->keys[i-1];
						child->childrens[i+1] = child->childrens[i];
					}

					child->childrens[1] = child->childrens[0];
					child->childrens[0] = left->childrens[left->num];
					child->keys[0] = node->keys[idx-1];
					
					child->num ++;

					node->key[idx-1] = left->keys[left->num-1];
					left->keys[left->num-1] = 0;
					left->childrens[left->num] = NULL;
					left->num --;
				}

			} else if ((!left || (left->num == T->t - 1))
				&& (!right || (right->num == T->t - 1))) {

				if (left && left->num == T->t - 1) {
					btree_merge(T, node, idx-1);					
					child = left;
				} else if (right && right->num == T->t - 1) {
					btree_merge(T, node, idx);
				}
			}
		}

		btree_delete_key(T, child, key);
	}
	
}


int btree_delete(btree *T, KEY_VALUE key) {
	if (!T->root) return -1;

	btree_delete_key(T, T->root, key);
	return 0;
}


int main() {
	btree T = {0};

	btree_create(&T, 3);
	srand(48);

	int i = 0;
	char key[26] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	for (i = 0;i < 26;i ++) {
		//key[i] = rand() % 1000;
		printf("%c ", key[i]);
		btree_insert(&T, key[i]);
	}

	btree_print(&T, T.root, 0);

	for (i = 0;i < 26;i ++) {
		printf("\n---------------------------------\n");
		btree_delete(&T, key[25-i]);
		//btree_traverse(T.root);
		btree_print(&T, T.root, 0);
	}
	
}

b+tree

区别：
b-tree：所有节点存储数据。当有非常多的节点时，有一些节点是存储在内存中的，btree会找一次后，还会找下一次。
b+tree：叶子节点存储数据，内节点索引用的。可以把所有索引放入内存，数据不会放在内存中，找到需要的，就一次寻址就可以再磁盘中找到数据。b+bree更加适合做磁盘索引。
内节点就是有子节点。
场景：mysql（InnoDB、MangoDB、等等）
在这里插入图片描述
除了叶子节点其他的节点都没有地址
减少树的高度
范围查找：需要找出>5的数不需要遍历树，效率高

算法可视化网站：
https://www.cs.usfca.edu/~galles/visualization/Algorithms.html
在这里插入图片描述

在三年之后
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
b+tree数据结构可视化_数据结构之B+树
weixin_39928768的博客
12-22 174
title: 数据结构之B+树date: 2018-11-04 20:39:00tags: 数据结构与算法之美一、 浅谈B-树索引1.B-树的特性一棵m阶B-树，或者是空树，或者是满足以下性质的m叉树根结点至少有两个分支；除根以外的非叶结点，每个结点包含分支数范围[[m/2],m]，即关键字字数的范围是[[m/2]-1,m-1]，其中[m/2]表示取大于等于m/2的最小整数所有叶子结点都在树的同一...
cjing-interview:C ++面试； 基本算法数据结构提示
04-06
基础算法和数据结构：DSA 可视化算法：视觉算法 C ++面试：Huihut采访 BTree实现：B-Tree C ++对象模型线段树：SegmentTree C ++面试总结（多方面） C＃面试总结（基础） 线段树：SegmentTree 算法 种类 QuickSort ...
『数据结构与算法』B树图文详解（含完整代码）
人生就是一个不断学习的过程
12-30 1834
GitHub源码分享 微信搜索：码农StayUp 主页地址：https://gozhuyinglong.github.io 源码分享：https://github.com/gozhuyinglong/blog-demos 1. 前言 迄今为止，已经介绍了《 二叉查找树 》和《 AVL树 》，我们始终假设可以把整个数据结构存储在内存中。可是，如果数据多到内存装不下，这就意味着必须把数据放在磁盘上，显然这些数据结构不再适用。 问题在于磁盘的I/O速度是远远不如内存访问速度的，然而从一棵树中查找到某个元素，.
算法工具 B+Tree 可视化
官
04-29 565
通过B+Tree 可视化直观操作理解下B+Tree的插入，查找，更新和删除过程 https://www.cs.usfca.edu/~galles/visualization/BPlusTree.html 数据结构可视化： https://www.cs.usfca.edu/~galles/visualization/Algorithms.html ...
可视化B树详细代码实现
最新发布
qq_62617798的博客
08-08 359
本次实验将实现一棵具备完整功能且正常运行的B树，并用dot脚本语言实现B树的可视化，能够根据操作实时进行B树的结构变换。
b树与b+树的区别_一篇文章理清B树、B-树、B+树、B*树索引之间的区别与联系
weixin_39915605的博客
11-28 335
概述相信对于B树、B-树、B+树、B*树索引这几个大家都很容易混淆，下面单独对这几个索引做下分类总结。B树即二叉搜索树：1.所有非叶子结点至多拥有两个儿子(Left和Right)；2.所有结点存储一个关键字；3.非叶子结点的左指针指向小于其关键字的子树，右指针指向大于其关键字的子树；B树的搜索，从根结点开始，如果查询的关键字与结点的关键字相等，那么就命中；否则，如果查询关键字比结点关键字小，就进入...
AVL.rar_tree
09-14
5. 展示（打印）AVL树的函数，以可视化树结构。 6. 可能还有其他辅助函数，如计算节点高度、平衡因子等。 总的来说，AVL树通过保持高度平衡，提高了二叉查找树的性能。理解和实现AVL树对于理解数据结构和算法有着...
avl.rar_One Tree
09-24
AVL树是数据结构中的一个重要概念，它是一种自平衡二叉...- 可能还有打印树的功能，用于可视化AVL树的结构。 通过理解和实现AVL树，开发者可以深入理解数据结构和算法，这对于提高编程技能和解决实际问题非常有帮助。
AVL_tree.rar_AVL树_avl
09-20
4. 遍历操作（Traversal）：包括前序遍历（根-左-右）、中序遍历（左-根-右）和后序遍历（左-右-根），这些遍历方法有助于理解和可视化AVL树的结构。 5. 平衡调整（Balance Adjustment）：理解和实现四种旋转操作，...
ds-visualization:数据结构和算法的可视化
04-06
5. **树（Tree）**：分层数据结构，包括二叉树、平衡二叉树（如AVL树、红黑树）、B树等。可视化可以显示树的遍历（前序、中序、后序）和节点操作。 6. **图（Graph）**：由节点和边组成的数据结构，常用于表示关系...
可视化B-树演示系统
01-03
可视化B-树演示系统，使用MFC制作，包括创建、删除、插入
B树基本操作flash动画演示
03-02
B树基本操作flash动画演示，很简单易懂
cpp-QT实现B树可视化
08-16
QT实现B树可视化
用Qt编写的B树的图形化显示
12-05
用Qt编写的B树的图形化显示，能够建立指定的B树，添加删除节点，一切都是图形化显示的。可用于B树的学习。
B+ Tree 增删改查 可视化
05-24
可视化增删改查数据
数据结构可视化网站（B-tree & B+tree）
weixin_49383196的博客
04-27 425
数据结构可视化（B-tree & B+tree）：以一种快速动态且通俗易懂的动画方法去演示数据的存储过程，让学习者一目了然。
看完就知道什么是数据库索引
zheng2780071070的博客
09-21 609
一、索引是什么 索引是在表的列上创建。索引是一种数据结构--索引包含一个表中列的值，并且这些值存储在一个数据结构中。 二、索引分类 聚集索引(主键索引)：在数据库里面，所有行数都会按照主键索引进行排序。 非聚集索引：给普通字段加上索引。 联合索引：好几个字段组成的复合索引。联合索引使用原则：最左原则，有A、B、C三个字段建立的联合索引，如果A字段在查询时为空，那么这个联合索引不生效；如果A字段不为空，B、C不管为不为空，那么联合索引都是生效的。 三、为什么要...
b+tree数据结构可视化_数据结构: B+Tree及其应用
weixin_39616216的博客
12-22 123
在前面的文章中我们已经介绍了B-Tree的一些特性，以及B-Tree的插入及删除操作。今天我们介绍一下B-Tree的一个变种 --> B+Tree。B+Tree是一种非常重要的数据结构，它广泛应用于文件系统，及数据库索引中。既然它是B-Tree的一个变种，自然他有很多特性和B-Tree就是一样的，但它们也有以下两点不同：第一：在 B-Tree中一个含有n个子树的节点有n-1个关键字(key)...
B+树真的不难，楼下菜大爷都能学得会的B+树！（数据结构可视化神器推荐）
热门推荐
菜菜bu菜的博客
09-11 2万+
楼下菜大爷直呼 牛逼 详情->
2021春计算机科学：B-树与查找算法详解
总结来说，第五章深入讲解了查找在数据结构中的核心作用，并通过实例展示了AVL树和B-树这两种重要的查找数据结构，它们在处理大量数据时能有效提升系统的性能和响应速度，是数据库管理和高效检索算法的基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值