2-3树的基本操作实现

最新推荐文章于 2024-09-30 07:00:00 发布
原创 最新推荐文章于 2024-09-30 07:00:00 发布 · 1.2k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了2-3树的概念，这是一种插入和删除操作时间复杂性为O(logn)的数据结构。2-3树的内部节点度数为2或3，分为2结点和3结点。文章重点讨论了2-3树的插入和删除操作，包括结点拆分、数据转移和结点合并等，并提供了相关操作的代码实现。

            通过引入结点度大于2的查找树，可以得到一种插入算法和删除算法都比AVL树简单的树结构，且这些算法的时间复杂性是O(logn)。这种树结构称为2-3树。2-3树的名字反映了2-3树具有如下性质：一棵2-3树中每个内部结点的度或者是2，或者是3。其中度为2的结点称为2结点，度为3的结点称为3结点。

定义：一棵2-3树（2-3 Tree）是一棵查找树，该查找树或者为空，或者满足如下性质：

1，每个内部结点或者是一个2结点，或者是一个3结点。一个2结点存放一个元素，而一个3结点存放两个元素。

2，令lchild和mchild表示2结点的两个儿子，datal表示该节点存放的元素，且datal.key是该元素的关键字。以lchild为根的子树中所有结点的关键字都小于datal.key，而以mchild为根的子树中所有结点的关键字都大于datal.key。

3，零lchild,mchild和rchild表示3结点的三个儿子，datal和datar表示该节点存放的左右两个元素，且datal.key < datar.key。以lchild为根的子树的所有结点的关键字都小于datal.key，以mchild为根的子树的所有结点的关键子都大于datal.key而小于datar.key，而以rchild为根的子树中所有结点的关键字都大于datar.key。

4，所有外部结点位于同一层。

        2-3树的查询操作不用细说，实现比较容易，重点在于2-3树的插入和删除操作，2-3树的插入操作涉及结点拆分，删除操作涉及数据的转移（或者称为旋转吧）以及结点合并（三种情况的旋转以及三种情况的合并，详细见REF[1]的2-3树章节）等等操作。


具体的插入和删除的原理可以可以参考文章《2-3树删除和插入操作的小结》，后面的代码主要是对REF[1]中的算法的实现：

代码：

#include <iostream>
#include <stack>

using namespace std;

typedef struct Tree23Node * Tree23;

typedef struct Tree23Node {
	int datal;
	int datar;
	Tree23 lchild,mchild,rchild;
} Tree23Node;

#define  INT_MAX 0x3f3f3f3f

stack<Tree23> s;

int compare(int x, Tree23 t)
{
	if (x < t->datal)
		return 1;
	else if (x > t->datar)
		return 3;
	else if ( x < t->datar && x > t->datal)
		return 2;
	else 
		return 4; 
}

Tree23 createNode(int key)
{
	Tree23 t = new Tree23Node;
	t->datal = key;
	t->datar = INT_MAX;
	t->lchild = t->mchild = t->rchild = NULL;
	return t;
} 
void newRoot(Tree23 *root,int key,Tree23 midSub)
{
	Tree23 t = createNode(key);
	t->lchild = *root;
	t->mchild = midSub;
	*root = t;		
}

bool isleaf(Tree23 root)
{
	if (root && root->datal < INT_MAX && root->lchild == NULL && 
		root->mchild == NULL && root->rchild == NULL)
		return true;
	return false;
}

Tree23 findNode(Tree23 root, int key)
{
	Tree23 t = NULL;
	while (root){
		if (!isleaf(root))
			s.push(root);
		if (isleaf(root))
			t = root;
		switch (compare(key,root)) {
			case 1:	root = root->lchild;
					break;
			case 2:	root = root->mchild;
					break;
			case 3: root = root->rchild;
					break;
			case 4: return NULL;
		}
	}
	return t;
}

void put(Tree23 *root, int key,Tree23 q)
{
	if (key < (*root)->datal){
		(*root)->datar = (*root)->datal;
		(*root)->datal = key;
		(*root)->rchild = (*root)->mchild;
		(*root)->mchild = q;
	}
	else {
		(*root)->datar = key;
		(*root)->rchild = q;
	}
} 

void split(Tree23 p,int *key,Tree23 *q)
{
	Tree23 t = createNode(INT_MAX);
	 
	if (*key < p->datal) {
		t->datal = p->datar;
		/*swap *key and p->datal */
		p->datar = *key;
		*key = p->datal;
		p->datal = p->datar;
		/* set p->datar to non sense */
		p->datar = INT_MAX; 
	}
	else if (*key > p->datar) {
		t->datal = *key;
		*key = p->datar;
		p->datar = INT_MAX;
	}
	else {
		t->datal = p->datar;
		p->datar = INT_MAX;
	}
	t->lchild = p->rchild;
	p->rchild = NULL;
	t->mchild = *q;
	*q = t;
}

Tree23 del()
{
	if (!s.empty()){
		Tree23 t = s.top();
		s.pop();
		return t;
	}
	return NULL;
}

void insert23(Tree23 *root,int key)
{
	Tree23 p,q,temp;
	
	if (*root == NULL) {
		/* tree is empty */
		newRoot(root,key,NULL);
	}
	else {
		/* insert into an empty tree */
		p = findNode(*root,key);
		if (p == NULL) {
			cout<<"The key is currently in the tree."<<endl;
			return;
		}
		q = NULL;
		for(;;) {
			if (p->datar == INT_MAX) {
				/* two sub node */
				put(&p,key,q);
				break;
			} 
			else {
				/* three sub node */
				split(p,&key,&q);
				if ( p == *root) {
					/* split the root */
					newRoot(root,key,q);
					break;
				}
				else 
					/* remove a node from stack */
					p = del();
			}
		}
	}
}

void visit(Tree23 T)
{
	if (T->datar < INT_MAX) {
		cout<<"("<<T->datal<<","<<T->datar<<") ";
	} 
	else if (T->datal < INT_MAX) {
		cout<<"("<<T->datal<<",) "; 
	}
	else cout<<"(,) "; 
} 
void inOrder(Tree23 T)
{
	if(T)
	{ 
		visit(T);
		//cout<<endl;
		if (T->lchild == NULL)
			return;
		cout<<"(";
		inOrder(T->lchild);
		cout<<",";
		inOrder(T->mchild);
		cout<<",";
		inOrder(T->rchild); 
		cout<<")";
	} 

}

Tree23 search23(Tree23 root,int key)
{
	while (root) {
		s.push(root);
		switch (compare(key,root)) {
			case 1:	root = root->lchild;
					break;
			case 2: root = root->mchild;
					break;
			case 3: root = root->rchild;
					break;
			case 4: return root;
		}
	} 
	return NULL;
}
Tree23 min23(Tree23 root)
{
	while(root->lchild){
		s.push(root);
		root = root->lchild;
	}
	s.push(root);
	return root;
}

void deletex(Tree23 t,int key)
{
	/* delete key from node t */
	if(key == t->datal){
		/* delete first key */
		if(t->datar < INT_MAX){
			/* three sub node*/
			t->datal = t->datar;
			t->datar = INT_MAX;
		}
		else
			/* two sub node */
			t->datal = INT_MAX;
	}
	else
		/* delete second key */
		t->datar = INT_MAX;
}

void leftRotate(Tree23 &p,Tree23 &q,Tree23 &r)
{
	p->datal = r->datal;
	r->datal = q->datal;
	q->datal = q->datar;
	q->datar = INT_MAX;
	
	p->mchild = q->lchild;
	q->lchild = q->mchild;
	q->mchild = q->rchild;
	q->rchild = NULL;
}

void leftCombine(Tree23 &p,Tree23 &q,Tree23 &r) 
{
	p->datal = r->datal;
	p->datar = q->datal;
	p->mchild = q->lchild;
	p->rchild = q->mchild;
	delete q;
	if (r->datar == INT_MAX){
		/* r is two sub node*/
		r->datal = INT_MAX;
		r->mchild = NULL;
	}
	else{
		r->datal = r->datar;
		r->datar = INT_MAX;
		r->mchild = r->rchild;
		r->rchild = NULL; 
	}
} 


void middleRotate(Tree23 &p,Tree23 &q,Tree23 &r)
{
	p->datal = r->datal;
	r->datal = q->datar;
	q->datar = INT_MAX;
	p->mchild = q->rchild;
	q->rchild = NULL;
}

void middleCombine(Tree23 &p, Tree23 &q, Tree23 &r)
{
	q->datar = r->datal;
	q->rchild = p->lchild;
	delete p;
	if(r->datar < INT_MAX) {
		r->datal = r->datar;
		r->datar = INT_MAX;
		r->mchild = r->rchild;
		r->rchild = NULL;
	}
	else {
		r->datal = INT_MAX;
		r->mchild = NULL;
	}
	
}

void rightRotate(Tree23 &p,Tree23 &q,Tree23 &r)
{
	p->datal = r->datar;
	r->datar = q->datar;
	q->datar = INT_MAX;
	p->mchild = q->rchild;
	q->rchild = NULL;
}

void rightCombine(Tree23 &p,Tree23 &q,Tree23 &r)
{
	q->datar = r->datar;
	r->datar = INT_MAX;
	q->rchild = p->lchild;
	delete p;
	r->rchild = NULL;
}
bool delete23(Tree23 *root, int key)
{
	Tree23 t = search23(*root,key);
	Tree23 p;
	Tree23 r ;
	Tree23 q = NULL;
	if (t == NULL)
		return false;
	else{
		if (!isleaf(t)){
			if (t->datal == key){
				p = min23(t->mchild);
				t->datal = p->datal;
				key = p->datal;
			}
			else{
				p = min23(t->rchild);
				t->datar = p->datal;
				key = p->datal;
			}
			
		}
		else
			p = t;
		
		deletex(p,key);
		del();
		for(;;){
			if (p->datal == INT_MAX && p->datar == INT_MAX){
				r = del();
				if (r == NULL)
					break;
				if (r->lchild == p){
					/* */
					q = r->mchild;
					if (q->datar < INT_MAX){
						/* rotate when p is the left child of r */
						leftRotate(p,q,r);
					}
					else{
						/* combine when p is the left child of r*/
						leftCombine(p,q,r);
					}
				}
				else if (r->mchild == p) {
					q = r->lchild;
					if (q->datar < INT_MAX){
						middleRotate(p,q,r);
					}
					else{
						middleCombine(p,q,r);
					}
					
				}
				else {
					q = r->mchild;
					if (q->datar < INT_MAX){
						rightRotate(p,q,r);
					}
					else{
						rightCombine(p,q,r);
					}
				}
				p = r;
			}
			else 
				break;
			
		}
		if (p->datal == INT_MAX){
			*root = p->lchild;
			delete p;
		}	
		
	}
	
}
int main()
{
	Tree23 tree = NULL;
	for(int i = 0; i < 11; i++){
		insert23(&tree,i);
		inOrder(tree);
		cout<<endl;
		cout<<"-----------------------------------------"<<endl;
	}
	insert23(&tree,8);
	inOrder(tree);
	cout<<endl; 
	cout<<"--------------------------------------------"<<endl;
	
	while(!s.empty())
		s.pop();
	delete23(&tree,10);
	inOrder(tree);
	cout<<endl;
	
	cout<<"--------------------------------------------"<<endl;
	
	while(!s.empty())
		s.pop();
	delete23(&tree,9);
	inOrder(tree);
	cout<<endl;
	
	cout<<"--------------------------------------------"<<endl;
	
	while(!s.empty())
		s.pop();
	delete23(&tree,8);
	inOrder(tree);
	cout<<endl;
	
	cout<<"--------------------------------------------"<<endl;
	
	while(!s.empty())
		s.pop();
	delete23(&tree,7);
	inOrder(tree);
	cout<<endl;
	
	cout<<"--------------------------------------------"<<endl;
	
	while(!s.empty())
		s.pop();
	delete23(&tree,6);
	inOrder(tree);
	cout<<endl;
	
	cout<<"--------------------------------------------"<<endl;
	
	for(int i = 5;i >= 0; i--){
		while(!s.empty())
		s.pop();
		delete23(&tree,i);
		inOrder(tree);
		cout<<endl;
	
		cout<<"--------------------------------------------"<<endl;
		
	}
}

测试结果： 

Key  =   0  inserted:
(0,) 
---------------------------------------------------------------------
Key  =   1  inserted:
(0,1) 
---------------------------------------------------------------------
Key  =   2  inserted:
(1,) ((0,) ,(2,) ,)
---------------------------------------------------------------------
Key  =   3  inserted:
(1,) ((0,) ,(2,3) ,)
---------------------------------------------------------------------
Key  =   4  inserted:
(1,3) ((0,) ,(2,) ,(4,) )
---------------------------------------------------------------------
Key  =   5  inserted:
(1,3) ((0,) ,(2,) ,(4,5) )
---------------------------------------------------------------------
Key  =   6  inserted:
(3,) ((1,) ((0,) ,(2,) ,),(5,) ((4,) ,(6,) ,),)
---------------------------------------------------------------------
Key  =   7  inserted:
(3,) ((1,) ((0,) ,(2,) ,),(5,) ((4,) ,(6,7) ,),)
---------------------------------------------------------------------
Key  =   8  inserted:
(3,) ((1,) ((0,) ,(2,) ,),(5,7) ((4,) ,(6,) ,(8,) ),)
---------------------------------------------------------------------
Key  =   9  inserted:
(3,) ((1,) ((0,) ,(2,) ,),(5,7) ((4,) ,(6,) ,(8,9) ),)
---------------------------------------------------------------------
Key  =   10  inserted:
(3,7) ((1,) ((0,) ,(2,) ,),(5,) ((4,) ,(6,) ,),(9,) ((8,) ,(10,) ,))
---------------------------------------------------------------------
The key is currently in the tree.
Key  =   8  inserted:
(3,7) ((1,) ((0,) ,(2,) ,),(5,) ((4,) ,(6,) ,),(9,) ((8,) ,(10,) ,))
--------------------------------------------------------------------------
Key  =   10  deleted:
(3,) ((1,) ((0,) ,(2,) ,),(5,7) ((4,) ,(6,) ,(8,9) ),)
--------------------------------------------------------------------------
Key  =   9  deleted:
(3,) ((1,) ((0,) ,(2,) ,),(5,7) ((4,) ,(6,) ,(8,) ),)
--------------------------------------------------------------------------
Key  =   8  deleted:
(3,) ((1,) ((0,) ,(2,) ,),(5,) ((4,) ,(6,7) ,),)
--------------------------------------------------------------------------
Key  =   7  deleted:
(3,) ((1,) ((0,) ,(2,) ,),(5,) ((4,) ,(6,) ,),)
----------------------------------------------------------------------------
Key  =   6  deleted:
(1,3) ((0,) ,(2,) ,(4,5) )
---------------------------------------------------------------------------
Key  =   5  deleted:
(1,3) ((0,) ,(2,) ,(4,) )
---------------------------------------------------------------------------
Key  =   4  deleted:
(1,) ((0,) ,(2,3) ,)
---------------------------------------------------------------------------
Key  =   3  deleted:
(1,) ((0,) ,(2,) ,)
---------------------------------------------------------------------------
Key  =   2  deleted:
(0,1) 
---------------------------------------------------------------------------
Key  =   1  deleted:
(0,) 
---------------------------------------------------------------------------
Key  =   0  deleted:

---------------------------------------------------------------------------


REF：

1，数据结构(C语言版) Ellis Horowitz等

2，http://blog.youkuaiyun.com/sumoyu/article/category/1054287

3，http://www.bkjia.com/Pythonjc/815204.html

红黑树与2-3树：插入、删除操作的时间复杂度与实现机制比较
一键难忘的博客
11-03 3069
红黑树是一种平衡二叉查找树，其节点具有颜色属性（红色或黑色）。通过一系列规则来确保树的平衡性，红黑树的最大高度是 (2 \log(n)) 级别，从而保证了查找、插入和删除操作的时间复杂度为 (O(\log n))。节点是红色或黑色。根节点是黑色。所有叶节点（NIL）是黑色。红色节点的子节点必须是黑色（即不存在两个相连的红色节点）。从任一节点到其所有叶节点的每条路径都包含相同数量的黑色节点。2-3树是一种B树的特例，其中每个节点可以包含2个或3个子节点。
C语言 2-3树
fpk2014的博客
06-01 3024
2-3树简介 实现过程 代码实现 2-3树简介 2-3树是最简单的B-树（或-树）结构，其每个非叶节点都有两个或三个子女，而且所有叶都在统一层上。 2-3树的模拟过程可以看链接：InsertSortion 实现过程 在2-3树中，一个结点只有一个值的我们称为2-结点，有两个值的称为3-结点，在2-3树中，一个结点最多只有两个值，即3-结点。 ...
2-3树的实现
11-22
陈建二老师总结的2-3树讲课资料,主要适用于中南大学计算机系研究生的高级算法课程
数据结构——2-3树
weixin_38927257的博客
01-22 1545
文章目录1 前言2 2-3树定义2-3树的定义3 2-3树性质性质：4 2-3树查找5 2-3树插入5.1 插入5.2 向2-节点中插入新节点图解过程：5.3 向一棵只含3-节点的树中插入新节点图解过程：5.4 向一个父节点为2-节点的3-节点中插入新节点图解过程：5.5 向一个父节点为3-节点的3-节点中插入新节点图解过程：5.6 分裂根节点图解过程：6 2-3树删除6.1 删除非叶子节点图解过...
树的基本功能的实现
qq_50504109的博客
10-01 480
1、树的基本功能的实现（包括桉树状打印二叉树） 关于树的创建可以看看我的另外一篇，可别小看了树的创建，你要是真的把树的创建真真切切的弄懂啦， 那么树后面就好学了很多，否则，很痛苦的； 附链接：https://blog.youkuaiyun.com/qq_50504109/article/details/119721763 /** * 时隔一百年总算学到树啦 * 不容易 * * 测试用例：AB..CD... 或者 AB.DF..G..C.E.H.. */ #include<stdio.h> #i
2-3树的实现初探
wangxiaohigh
11-25 233
前篇文章（2-3树的实现分析）已经分析了2-3树的遍历（traverse），检索（retrieve），插入（insert）和删除（delete）的算法，经过三天的努力，我在分析的基础上采用回溯的方式实现了2-3树，由于还在初级阶段，肯定会出现不少的问题，请多赐教。但经过测试，运行还算正确。下面是代码实现： 2-3树的异常处理类 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~...
2-3 树的实现分析
11-21 550
在2-3树中，每个内部节点（非叶子节点）有两个或三个孩子，而且所有叶子都在同一级别上。例如，图1显示高度为3的2-3树。包含两个孩子的节点称为2-节点，二叉树中的节点都是2-节点；包含三个孩子的节点称为3-节点。 图1：高度为3的2-3树 2-3树不是二叉树，其节点可拥有3个孩子。不过，2-3树与满二叉树相似。若某棵2-3树不包含3-节点，则看上去像满二叉树，其所有内部节点都可有两个孩子，
2-3树（2-3 Tree）：原理、常见算法及其应用
最新发布
weixin_43841461的博客
09-30 2528
2-3树作为一种高效的数据结构，在计算机科学中有广泛的应用。通过允许节点拥有一个或两个键值来保持树的平衡，2-3树在最坏的情况下也能够保证操作的时间复杂度为O(logn)。掌握2-3树的概念和相关算法对于深入理解计算机科学的核心知识至关重要。
数据结构实验报告-查找-B-树基本操作的实现-实验内容与要求
03-17
### 数据结构实验报告：B-树的基本操作实现 #### 实验背景与目标 本实验旨在通过实践加深学生对B-树这一数据结构的理解，并掌握其关键操作如插入、删除、查找以及遍历的方法。B-树是一种自平衡的树数据结构，常...
2-3树的插于及删除操作源代码
03-28
文档"7-2-3树.doc"可能包含了2-3树的扩展，即7-2-3树，这是一种在每个节点最多有7个子节点的变体，其插入和删除操作的逻辑会更为复杂，但基本原理仍然相同。 总结来说，2-3树的插入和删除操作涉及到树的遍历、节点...
B-树 C++实现 基本功能
05-04
2. **插入操作**：在B-树中插入新元素时，我们需要找到正确的插入位置并保持树的平衡。如果插入导致某个节点超出其最大容量，那么节点需要分裂，将一部分键和子节点上移至父节点。这个过程可能需要递归进行，直到树...
数据结构-2-3树及实现树
一只Java开发
04-08 575
数据结构-2-3树及实现树 2-3查找树： 为了保证查找树的平衡性，需要树有一些灵活性，因此在这里允许树中的一个结点保存多个键，确切地说，我们将一颗标准的二叉查找树中的结点称为2-结点（含有一个键和两条链），而现在我们引入3-结点，它含有两个键和三条链。2-结点和3-结点中的每条链都对应着其中保存的键所分割产生的一个区间。 2-3查找树的定义 一颗2-3查找树要么为空要么满足下面两个要求： 1. 2-结点： 含有一个键及其对应的值和两条链，左链接指向2-3树中的键都小于该结点，右链接指向的2-3中的键大于该
树的基本操作函数实现
king9666的博客
02-19 370
树的基本操作及算法 左子右兄表示法 左子右兄表示法
2-3树
qq_36523667的博客
02-13 774
转载自：http://blog.youkuaiyun.com/chen_zhang_yu/article/details/52415077这哥们讲的太好了2-3树是二叉查找树的变种，树中的2和3代表两种节点，以下表示为2-节点和3-节点。    2-节点即普通节点：包含一个元素，两条子链接。    3-节点则是扩充版，包含2个元素和三条链接：两个元素A、B，左边的链接指向小于A的节点，中间的链接指向介于A、B...
2-3树的java实现
上帝已逝，自求多福
04-19 2214
点的定义 空点的定义 package TwoThreeTree; /** * A hole node does not have any values, and have only one child. */ final class HoleNode extends Node { private Node child; HoleNode()
2-3查找树的实现(c++)
m0_60508734的博客
08-10 200
【代码】2-3查找树的实现(c++)
C++ 2-3树实现（红黑树）学习笔记
qq_36203083的博客
04-06 1346
C++ 2-3树实现（红黑树）学习笔记 在使用二叉查找树时，二叉查找树的运行时间取决于树的形状，树的形状取决于插入数据的顺序，最好的情况是叶子节点到根节点到距离为LogN。 2-3树可以允许“每个节点保存2个数据”的情况发生，从而提高了二叉查找树的灵活性，最终实现了无论以什么顺序插入，都可以保持树的平衡性和有序性。 一. 2-3树的节点类型 本次通过红黑树实现2-3树，在树进行操作的过程中，2-...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值