数据结构——2-3树

最新推荐文章于 2024-01-08 15:27:11 发布
原创 最新推荐文章于 2024-01-08 15:27:11 发布 · 362 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构与算法

本文详细介绍了2-3树的基本概念、性质、查找、插入和删除操作的实现过程。通过实例展示了如何在C++中实现2-3树，并提供了完整的代码示例，包括插入、搜索、删除等核心功能。

年前实现了一个2-3树，后来就玩儿去了，再后来看书去了，所以就耽搁了。基本上网上找不到什么2-3树的实现，大概是因为这东西基本真正被用过吧。基于它的思想而发明的B树，B+树才是真正的大头，不过2-3树的模型比较简单，对我们理解B树和B+树的实现有很大的帮助，所以最终我还是通过自己的努力，实现了一个2-3树。

下面是2-3树的基本介绍：

2-3树不是一种二叉树，但他的形状满足以下性质：
（1）一个节点包含一个或两个键值
（2）每个内部节点有两个子节点（如果它有一个键值）或三个子节点（如果它有两个键值）
（3）所有叶节点都在树结构的同一层，因此树的高度总是平衡的。

对于每个结点, 左子树中所有后继结点的值都小于第一个键的值, 而其中间子树中所有结点的值都大于或等于第一个键的值。如果结点有右子树的话( 相应地, 结点存储两个键值) , 那么其中间子树中所有后继结点的值都小于第二个键的值, 而其右子树中所有后继结点的值都大于或等于第二个键的值。同时，同一层的键值从左到右增大。

2-3树的查找方法与二分查找树相似，从根节点出发，如果在根节点找到查找值则查找成功返回，否则根据节点键的规则递归地查找下去，直到找到或返回失败。

在2-3树中插入新值时并不为其开辟一个新的叶子节点来存储，也就是说，2-3树不是向下生长的。插入算法首先找到一个合适的叶子节点来存放该值，使树的性质不被破坏。如果该叶子节点只包含一个值（每个节点都最多有两个值），则简单将该值放入叶子节点即可。如果叶子结点本身已经包含两个值了，则需要为前加入的叶子开辟新的空间。设节点L为插入节点，但是已经满了，也就是，这个节点因为包含了三个值，所以必须进行分裂，设新分裂出来的节点为L’，则L将存储这三个值中最小的那个值，而L’则存储这三个值中最大的那个。处于中间的值将得到提升，作为插入值晋升到父节点去。如果父节点只包含一个键值，该值直接放入节点即可，否则，同样的“分裂-晋升”过程将在该父节点进行，一直递归到根节点为止。2-3的插入实现中利用了一个函数splitNode，它接收被插入节点的指针和插入的数据，并将指向L'指针和被往上传的值通过引用传回来。当插入结点已满时便启用这个函数。

从2-3树删除一个节点，有三种可能情况需要考虑：最简单的情况是，如果删除的值存储在有两个键值的节点上，直接删除该值并不影响树的性质与结构。如果被删除的值所在的节点只有它一个键值，被删除后该节点将为空，因此通过向兄弟节点借一个记录，并修改父节点来解决。如果兄弟节点不够借，则需要合并相邻节点，并影响双亲，可能导致树的高度下降。如果被删除的值是树的内部节点，则将被删除记录用右边子树中的最小键值代替，然后再根据第一、二种情况将该值删除。第一种情况的实现相当简单，只需要考虑如果删除的是左键值，那么要把右键值移过来而已。被借的情况由borrowLeft和borrowRight来实现，合并的情况由mergeLeft和mergeRight来实现。具体代码如下：

//TTTree.h
#ifndef TTTREE_H
#define TTTREE_H

#include<iostream>
#include<queue>
using namespace std;

template<class Elem, class Key, class KEComp, class EEComp>
class TTTree : public Tree<Elem, Key, KEComp, EEComp>{
	protected:
		using Tree<Elem, Key, KEComp, EEComp>::count;
		struct TTNode{
			Elem elems[2];
			TTNode* ptrs[3];
			TTNode(){
				ptrs[0] = ptrs[1] = ptrs[2] = 0;
			}
			TTNode( Elem empty ){
				ptrs[0] = ptrs[1] = ptrs[2] = 0;
				elems[0] = elems[1] = empty;
			} 
		};
		TTNode* root;
		Elem EMPTY;
		int height;
		void splitNode( TTNode* subroot, TTNode* inPtr, Elem inVal, TTNode*& retPtr, Elem& retVal );
		bool insertHelp( TTNode* subroot, const Elem& e, TTNode*& retPtr, Elem& retVal );
		void clear( TTNode* subroot );
		void borrowLeft( TTNode* subroot, int ptrIndex );
		void borrowRight( TTNode* subroot, int ptrIndex );
		void mergeLeft( TTNode* subroot, int ptrIndex );
		void mergeRight( TTNode* subroot, int ptrIndex );
		void removeHelp( TTNode* subroot, const Key& k, Elem& e );
	public:
		TTTree( const Elem& em ){
			root = 0;
			height = 0;
			EMPTY = em;
		}
		~TTTree(){
			clear( root );
		}
		bool insert( const Elem& e);
		bool remove( const Key& k ,Elem& e );
		bool search( const Key& k, Elem& e );
		void print() const;
	};
	
#include "TTTree.cpp"
#endif

 

//TTTree.cpp


template<class Elem, class Key, class KEComp, class EEComp>
bool TTTree<Elem, Key, KEComp, EEComp>::
	search( const Key& k, Elem& e ){
		TTNode* current=root;
		while( current != 0 ){
			if( KEComp::eq( k, current->elems[0] ) ){
				e = current->elems[0];
				return true;
			}
			if( !EEComp::eq( EMPTY, current->elems[1] ) && 
				KEComp::eq( k, current->elems[1] ) ){
					e = current->elems[1];
					return true;
				}			
			if( KEComp::lt( k, current->elems[0] ) )
				current = current->ptrs[0];
			else if( EEComp::eq( EMPTY, current->elems[1] ) || 
				KEComp::lt( k, current->elems[1] ) )
						current = current->ptrs[1];
					else
						current = current->ptrs[2];
					}
		return false;
}

template<class Elem, class Key, class KEComp, class EEComp>
void TTTree<Elem, Key, KEComp, EEComp>::
	clear( TTNode* subroot ){
		if( subroot == 0 )
			return;
		for( int i=0; i<3; i++ )
			clear( subroot->ptrs[i] );
		delete subroot;
	}
		
template<class Elem, class Key, class KEComp, class EEComp>
void TTTree<Elem, Key, KEComp, EEComp>::
	print() const{
		if( root == 0 ){
			cout<<"empty tree"<<endl;
			return;
		}
		queue<TTNode*> nodeQueue;
		nodeQueue.push(root);
		TTNode* current;
		int h = height;
		int intent=1;
		string BLANK="       ";
		for( int i=1; i<height; i++ )
			intent *= 3;
		int num = 1;
		while( h>0 && !nodeQueue.empty() ){
			for( int i=0; i<num; i++ ){
				current = nodeQueue.front();
				nodeQueue.pop();
				if( current != 0 ){
					for( int j=0; j<3; j++ )
						nodeQueue.push( current->ptrs[j] );
					for( int j=0; j<intent/2; j++ )
						cout<<BLANK;
					cout<<"|"<<current->elems[0]<<"|";
					if( EEComp::eq( EMPTY, current->elems[1] ) )
						cout<<"__|";
					else
						cout<<current->elems[1]<<"|";
					for( int j=0; j<intent/2; j++ )
						cout<<BLANK;
				}else{
					for( int j=0; j<3; j++ )
						nodeQueue.push( 0 );
					for( int j=0; j<intent; j++ )
						cout<<BLANK;
					}
			}
			cout<<endl;
			intent /= 3;
			num *= 3;
			h--;
		}
	}

template<class Elem, class Key, class KEComp, class EEComp>
void TTTree<Elem, Key, KEComp, EEComp>::
	splitNode( TTNode* subroot, TTNode* inPtr, Elem inVal, TTNode*& retPtr, Elem& retVal ){
		retPtr = new TTNode( EMPTY );
		if( EEComp::lt( inVal, subroot->elems[0] ) ){
			retVal = subroot->elems[0];
			subroot->elems[0] = inVal;
			retPtr->elems[0] = subroot->elems[1];
			retPtr->ptrs[0] = subroot->ptrs[1];
			retPtr->ptrs[1] = subroot->ptrs[2];
			subroot->ptrs[1] = inPtr;
		}else{
			if( EEComp::lt( inVal, subroot->elems[1] ) ){
				retVal = inVal;
				retPtr->elems[0] = subroot->elems[1];
				retPtr->ptrs[0] = inPtr;
				retPtr->ptrs[1] = subroot->ptrs[2];
			}else{
				retVal = subroot->elems[1];
				retPtr->elems[0]=inVal;
				retPtr->ptrs[0] = subroot->ptrs[2];
				retPtr->ptrs[1] = inPtr;
			}
		}
		subroot->ptrs[2] = 0;
		subroot->elems[1] = EMPTY;
	}
	
template<class Elem, class Key, class KEComp, class EEComp>
bool TTTree<Elem, Key, KEComp, EEComp>::
	insertHelp( TTNode* subroot, const Elem& e, TTNode*& retPtr, Elem& retVal ){
		Elem tempRetVal; TTNode* tempRetPtr=0;
		if( subroot->ptrs[0] == 0 ){	//leaf
			if( EEComp::eq( EMPTY, subroot->elems[1] ) ){
				if( EEComp::lt( e, subroot->elems[0] ) ){
					subroot->elems[1] = subroot->elems[0];
					subroot->elems[0] = e;
				}else
					subroot->elems[1] = e;
			}else
				splitNode( subroot, 0, e, retPtr, retVal );
		}else if( EEComp::lt( e, subroot->elems[0] ) )
			insertHelp( subroot->ptrs[0], e, tempRetPtr, tempRetVal );
			else if( EEComp::eq( EMPTY, subroot->elems[1] ) || EEComp::lt( e, subroot->elems[1] ) )
				insertHelp( subroot->ptrs[1], e, tempRetPtr, tempRetVal );
			else
				insertHelp( subroot->ptrs[2], e, tempRetPtr, tempRetVal );
		
		if( tempRetPtr != 0 ){
			if( EEComp::eq( EMPTY, subroot->elems[1] ) ){
				if( EEComp::lt( tempRetVal, subroot->elems[0] ) ){
					subroot->elems[1] = subroot->elems[0];
					subroot->elems[0] = tempRetVal;
					subroot->ptrs[2] = subroot->ptrs[1];
					subroot->ptrs[1] = tempRetPtr;
				}else{
					subroot->elems[1] = tempRetVal;
					subroot->ptrs[2] = tempRetPtr;
				}
			}else
				splitNode( subroot, tempRetPtr, tempRetVal, retPtr, retVal );
			}
		return true;
		}
		
template<class Elem, class Key, class KEComp, class EEComp>
bool TTTree<Elem, Key, KEComp, EEComp>::
	insert( const Elem& e ){
		if( root == 0 ){
			root = new TTNode( EMPTY );
			root->elems[0] = e;
			height++;
			count++;
			return true;
		}
		Elem myRetVal;
		TTNode* myRetPtr = 0;
		if( insertHelp( root, e, myRetPtr, myRetVal ) ){
			count++;
			if( myRetPtr != 0 ){
				TTNode* temp = new TTNode(EMPTY);
				temp->elems[0] = myRetVal;
				temp->ptrs[0] = root;
				temp->ptrs[1] = myRetPtr;
				root = temp;
				height ++;
			}
			return true;
		}
		return false;
	}

template<class Elem, class Key, class KEComp, class EEComp>
void TTTree<Elem, Key, KEComp, EEComp>::
	removeHelp( TTNode* subroot, const Key& k, Elem& e ){
		if( subroot == 0 ){
			e = EMPTY;
			return ;
		}
		e = EMPTY;
		Elem tempElem = EMPTY;
		int ptrIndex = -1;
		if( KEComp::eq( k, subroot->elems[0] ) ){
			e = subroot->elems[0];
			if( subroot->ptrs[0] == 0 ){	//leaf node
				if( !EEComp::eq( EMPTY, subroot->elems[1] ) ){
					 subroot->elems[0]=subroot->elems[1];
					 subroot->elems[1]= EMPTY;
					}else
						subroot->elems[0] = EMPTY;
					return ;
			}else{		//if not leaf node, find a leaf node to take place of it
				TTNode* replace=subroot->ptrs[1];
				while( replace->ptrs[0] != 0 )
					replace = replace->ptrs[0];
				subroot->elems[0]=replace->elems[0];
				ptrIndex = 1;
				removeHelp( subroot->ptrs[1], getKey(replace->elems[0]), tempElem );
				tempElem = e;
			}
		}else if( !EEComp::eq( EMPTY, subroot->elems[1] ) && KEComp::eq( k, subroot->elems[1] ) ){
			e = subroot->elems[1];
			if( subroot->ptrs[0] == 0 ){				
				subroot->elems[1] = EMPTY;
				return;
			}else{
				TTNode* replace=subroot->ptrs[2];
				while( replace->ptrs[0] != 0 )
					replace = replace->ptrs[0];
				subroot->elems[1] = replace->elems[0];
				ptrIndex = 2;
				removeHelp( subroot->ptrs[2], getKey( replace->elems[0] ), tempElem );
				tempElem = e;
			}
		}else if( KEComp::lt( k, subroot->elems[0] ) ){
			ptrIndex = 0;
			removeHelp( subroot->ptrs[0], k, tempElem );
		}else if( EEComp::eq( EMPTY, subroot->elems[1] ) || KEComp::lt( k, subroot->elems[1] ) ){
			ptrIndex = 1;
			removeHelp( subroot->ptrs[1], k, tempElem );
		}else{
			ptrIndex = 2;
			removeHelp( subroot->ptrs[2], k, tempElem );
		}
		if( ptrIndex>=0 && !EEComp::eq( EMPTY, tempElem ) ){
			e = tempElem;
			if( EEComp::eq( EMPTY, subroot->ptrs[ptrIndex]->elems[0]) ){
				if( ptrIndex == 0 ){
					if( !EEComp::eq( EMPTY, subroot->ptrs[1]->elems[1] ) ){
						borrowRight( subroot, 0 );
					}else if( EEComp::eq( EMPTY, subroot->elems[1] ) ){
						mergeRight( subroot, 0 );
					}else if( !EEComp::eq( EMPTY, subroot->ptrs[2]->elems[1] ) ){
						borrowRight( subroot, 0 );
						borrowRight( subroot, 1 );
					}else{
						borrowRight( subroot, 0 );
						mergeRight( subroot, 1 );
					}
				}else if( ptrIndex == 1 ){
					if( !EEComp::eq( EMPTY, subroot->ptrs[0]->elems[1] ) ){
						borrowLeft( subroot, 1 );
					}else if( EEComp::eq( EMPTY, subroot->elems[1] ) ){
						mergeLeft( subroot, 1 );
					}else if( !EEComp::eq( EMPTY, subroot->ptrs[2]->elems[1] ) ){
						borrowRight( subroot, 1 );
					}else{
						mergeRight( subroot, 1 );
					}
				}else if( ptrIndex == 2 ){
					if( !EEComp::eq( EMPTY, subroot->ptrs[1]->elems[1] ) ){
						borrowLeft( subroot, 2 );
					}else if( !EEComp::eq( EMPTY, subroot->ptrs[0]->elems[1] ) ){
						borrowLeft( subroot, 1 );
						borrowLeft( subroot, 2 );
					}else{
						mergeLeft( subroot, 2 );
					}
				}
			}
		}
	}
					
template<class Elem, class Key, class KEComp, class EEComp>
void TTTree<Elem, Key, KEComp, EEComp>::					
	borrowRight( TTNode* subroot, int ptrIndex ){
	if( ptrIndex<0 || ptrIndex>1 )
		return;
	subroot->ptrs[ptrIndex]->elems[0] = subroot->elems[ptrIndex];
	subroot->elems[ptrIndex] = subroot->ptrs[ptrIndex+1]->elems[0];
	subroot->ptrs[ptrIndex+1]->elems[0] = subroot->ptrs[ptrIndex+1]->elems[1];
	subroot->ptrs[ptrIndex+1]->elems[1] = EMPTY;
	subroot->ptrs[ptrIndex]->ptrs[1] = subroot->ptrs[ptrIndex+1]->ptrs[0];	
	subroot->ptrs[ptrIndex+1]->ptrs[0] = subroot->ptrs[ptrIndex+1]->ptrs[1];
	subroot->ptrs[ptrIndex+1]->ptrs[1]	= subroot->ptrs[ptrIndex+1]->ptrs[2];
	subroot->ptrs[ptrIndex+1]->ptrs[2] = 0;
	}

template<class Elem, class Key, class KEComp, class EEComp>
void TTTree<Elem, Key, KEComp, EEComp>::
	borrowLeft( TTNode* subroot, int ptrIndex ){
		if( ptrIndex>2 || ptrIndex<1 )
			return;
		subroot->ptrs[ptrIndex]->elems[1] = subroot->ptrs[ptrIndex]->elems[0];
		subroot->ptrs[ptrIndex]->elems[0] = subroot->elems[ptrIndex-1];
		subroot->elems[ptrIndex-1] = subroot->ptrs[ptrIndex-1]->elems[1];
		subroot->ptrs[ptrIndex-1]->elems[1] = EMPTY;
		subroot->ptrs[ptrIndex]->ptrs[1] = subroot->ptrs[ptrIndex]->ptrs[0];
		subroot->ptrs[ptrIndex]->ptrs[0] = subroot->ptrs[ptrIndex-1]->ptrs[2];
		subroot->ptrs[ptrIndex-1]->ptrs[2] = 0;	
	}		
	
template<class Elem, class Key, class KEComp, class EEComp>
void TTTree<Elem, Key, KEComp, EEComp>::
	mergeRight( TTNode* subroot, int ptrIndex ){
		if( ptrIndex<0 || ptrIndex>1 )
			return;
		subroot->ptrs[ptrIndex]->elems[0] = subroot->elems[ptrIndex];
		subroot->elems[ptrIndex] = EMPTY;
		subroot->ptrs[ptrIndex]->elems[1] = subroot->ptrs[ptrIndex+1]->elems[0];
		subroot->ptrs[ptrIndex]->ptrs[1] = subroot->ptrs[ptrIndex+1]->ptrs[0];
		subroot->ptrs[ptrIndex]->ptrs[2] = subroot->ptrs[ptrIndex+1]->ptrs[1];
		delete subroot->ptrs[ptrIndex+1];
		subroot->ptrs[ptrIndex+1] = 0;
	}

template<class Elem, class Key, class KEComp, class EEComp>
void TTTree<Elem, Key, KEComp, EEComp>::
	mergeLeft( TTNode* subroot, int ptrIndex ){
		if( ptrIndex<1 || ptrIndex>2 )
			return;
		subroot->ptrs[ptrIndex-1]->elems[1] = subroot->elems[ptrIndex-1];
		subroot->elems[ptrIndex-1] = EMPTY;
		subroot->ptrs[ptrIndex-1]->ptrs[2] = subroot->ptrs[ptrIndex]->ptrs[0];
		delete subroot->ptrs[ptrIndex];
		subroot->ptrs[ptrIndex] = 0;
	}
					
template<class Elem, class Key, class KEComp, class EEComp>
bool TTTree<Elem, Key, KEComp, EEComp>::
	remove( const Key& k, Elem& e ){
		 e = EMPTY;
		 removeHelp( root, k, e );
		 if( e == EMPTY )
		 	return false;
		 if( EEComp::eq( EMPTY, root->elems[0] ) ){
		 	TTNode* temp = root;
		 	root = root->ptrs[0];
		 	height --;
		}
		return true;
	}

 

看图轻松理解数据结构与算法系列(2-3树)
seaboat——a free boat on the sea.（公众号：远洋号）
08-23 1226
前言 推出一个新系列，《看图轻松理解数据结构和算法》，主要使用图片来描述常见的数据结构和算法，轻松阅读并理解掌握。本系列包括各种堆、各种队列、各种列表、各种树、各种图、各种排序等等几十篇的样子。 2-3树 2-3树，是最简单的B-树，其中2、3主要体现在每个非叶子节点都有2个或3个子节点，B-树即是平衡树，平衡树是为了解决不平衡树查询效率问题，常见的二叉平衡书有AVL树，它虽然提高了查询...
数据结构：2-3树
小键233
03-08 990
声明：本文为学习 数据结构与算法分析(第三版) Clifford A.Shaffer 著 的学习笔记，代码有参考该书的示例代码。2-3树2-3 树的形状定义如下： 一个结点包含一个或两个关键码。 每个内部结点有两个子结点（如果它包含一个关键码）或者三个子结点（如果它包含两个关键码），它因此得名 2-3 树。 所有叶结点都在树结构的同一层，因此树的高度总是平衡的。 2-3 树保持了类似于BST 的检索
经典数据结构之2-3树
互联网架构师笔记
04-24 2520
2-3树，是最简单的B-树，其中2、3主要体现在每个非叶子节点都有2个或3个子节点
2-3树
chenxiaokang的博客
07-16 473
2-3树为了保证查找树的平衡性，我们需要一些灵活性，因此在这里我们允许树的一个结点保存多个键。我们将一颗二叉查找树的结点称为2-结点（包含一个键和两条链接），现在我们引入3-结点（包含两个键和三条链接）。一颗2-3查找树或为一颗空树，或由以下结点组成：2-结点，含有一个键和两条链接，左链接指向的2-3树中的键都小于该结点，有链接都大于。3-结点，含有两个键和三条链接，中链接指向的2-3树中的键都位...
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
S-function入门及案例详解（1）——S-function基础介绍及基本案例
Wendy的博客
06-24 7万+
本专题将用三篇文章对S-function进行介绍及其案例详解。欢迎关注~ 目录一、S-Function简介二、详解sfuntmpl函数2.1 sfuntmpl函数介绍2.2 mdlInitializeSizes函数2.3 mdlDerivatives函数2.4 mdlUpdate函数2.5 mdlOutputs函数2.6 mdlGetTimeOfNextVarHit函数2.7 mdlTerminate函数三、案例1——对波形的幅值进行放大3.1 案例分析3.2 案例详解3.3 输出波形四、案例2——对波形的
数据结构第五章-树与二叉树二叉树的C语言实现代码
最新发布
05-22
该资源中为【数据结构】专栏——C语言实现二叉树篇章中涉及到的代码 代码中包含以下内容： 1. 二叉树相关头文件： - 二叉链表的数据类型声明 - 链队列结点类型声明 - 链队列类型声明 - 二叉树基本功能（二叉树的...
postgreSQL源码分析——索引的建立与使用——B-Tree索引（1）
m0_53446118的博客
10-24 5850
目录nbtree算法介绍二级目录三级目录 nbtree算法介绍 // nbtree.c var foo = 'bar'; 二级目录 三级目录
ARM架构—— Cortex-M3与Cortex-M4特点概述
m0_61973119的博客
01-08 4601
哈佛结构是一种将程序指令存储和数据存储分开的存储器结构。哈佛结构是一种并行体系结构，它的主要特点是将程序和数据存储在不同的存储空间中，即程序存储器和数据存储器是两个独立的存储器，每个存储器独立编址、独立访问。两个存储器相对应的是系统的4条总线，即程序的数据总线与地址总线数据的数据总线与地址总线。这种分离的程序总线和数据总线可允许在一个机器周期内同时获得指令字（来自程序存储器）和操作数（来自数据存储器），从而提高了执行速度，进而提高了数据的吞吐率。
2-3树的建树（即插入）过程
CHMMLS的专栏
12-29 5109
题目：2-3树的建树（即插入）过程问题描述： 实现2—3树的插入过程。 2—树是这样一种树：  A．每个非叶子结点都有2个或3个儿子；  B．每条众树根到树叶的路径长度相等；  C．只有一个根结点的树也是2—3树。算法设计思想：（冒泡法等方法） 构建这样的结点：p指向父结点；lb指向左子树最大结点；mb指向第二个子树最大结点；ls指向最左孩子结点；ms指向中间孩子结点；rs指向最右孩子结点；ap附
树结构——2-3树图解
gjbss的博客
08-04 959
2-3树图解以及设计原理
python数据结构学习笔记-2016-12-25-01-2-3 树
mengzm的博客
12-31 841
14.4 2-3 树        2-3 树是一种平衡树，其形状定义如下： 每一个结点可储存1个或2个关键码，分别以k1和k2表示；每一个结点有2~3个子结点，分别为左子结点、中子结点和右子结点；所有的叶结点都在同一层；每一个内结点如果只有一个关键码，则其只有两个子结点，如果有两个关键码，则其有三个子结点。        对于每一个内结点来说，有： 所有小于该
B,B+,B*,2-3树的介绍与图的创建
算法萌新一枚
04-10 848
主要阐述多叉树和图为什么出现,有什么用,特征是什么,以及图的创建等
2-3树的原理图解
乌鸦喜欢写字台
10-29 1362
1、树的基本介绍 2-3树是最简单的B-数结构，具有如下特点： 1） 2-3树的所有叶子节点都在同一层（只要是B树都满足这个条件）； 2）有两个子节点的节点叫二节点，二节点要么没有子节点，要么有两个节点； 3）有三个子节点的节点叫三节点，三节点要么没有子节点，要么有三个节点； 4）2-3树是由二节点和三节点构成的树 2、2-3树图解 实例：将数列[16,24,12,32,14,26,34,10,8,28,38,20]构建成2-3树，并保证数据插入的...
2-3 tree
内牛满面
10-09 300
[code="java"] package com.leon.cc; import com.leon.util.Stack; /** * @author : Leon * @since : 2013-10-9 * @see : */ public class Tree { Node root = new Node(); ...
2-3 查找树
能能
09-17 1037
[TOC] 在之前的二分搜索和二叉查找树中已经能够很好地解决查找的问题了，但是它们在最坏情况下的性能还是很糟糕 理想情况下我们希望能够保持二分查找树的平衡性。在一棵含有N个结点的树中，我们希望树高为 ~lgN，这样我们就能保证所有查找都能在 ~lgN 次比较内结束 一、定义 为了保证查找树的平衡性，我们需要一些灵活性，因此我们允许树中的一个结点保存多个键。 将一棵标准的二叉查找树中的结点...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值