数据结构——2-3树

最新推荐文章于 2023-04-24 11:36:42 发布
最新推荐文章于 2023-04-24 11:36:42 发布
阅读量307 收藏
点赞数
分类专栏： 编程 文章标签： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_16109/article/details/82276270
版权

年前实现了一个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;
	}

 

iteye_16109
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
看图轻松理解数据结构与算法系列(2-3树)
seaboat——a free boat on the sea.（公众号：远洋号）
08-23 1050
前言 推出一个新系列，《看图轻松理解数据结构和算法》，主要使用图片来描述常见的数据结构和算法，轻松阅读并理解掌握。本系列包括各种堆、各种队列、各种列表、各种树、各种图、各种排序等等几十篇的样子。 2-3树 2-3树，是最简单的B-树，其中2、3主要体现在每个非叶子节点都有2个或3个子节点，B-树即是平衡树，平衡树是为了解决不平衡树查询效率问题，常见的二叉平衡书有AVL树，它虽然提高了查询...
2-3树的建树（即插入）过程
CHMMLS的专栏
12-29 4908
题目：2-3树的建树（即插入）过程问题描述： 实现2—3树的插入过程。 2—树是这样一种树：  A．每个非叶子结点都有2个或3个儿子；  B．每条众树根到树叶的路径长度相等；  C．只有一个根结点的树也是2—3树。算法设计思想：（冒泡法等方法） 构建这样的结点：p指向父结点；lb指向左子树最大结点；mb指向第二个子树最大结点；ls指向最左孩子结点；ms指向中间孩子结点；rs指向最右孩子结点；ap附
数据结构：2-3树
小键233
03-08 917
声明：本文为学习 数据结构与算法分析(第三版) Clifford A.Shaffer 著 的学习笔记，代码有参考该书的示例代码。2-3树2-3 树的形状定义如下： 一个结点包含一个或两个关键码。 每个内部结点有两个子结点（如果它包含一个关键码）或者三个子结点（如果它包含两个关键码），它因此得名 2-3 树。 所有叶结点都在树结构的同一层，因此树的高度总是平衡的。 2-3 树保持了类似于BST 的检索
经典数据结构之2-3树
互联网架构师笔记
04-24 1746
2-3树，是最简单的B-树，其中2、3主要体现在每个非叶子节点都有2个或3个子节点
2-3树
chenxiaokang的博客
07-16 414
2-3树为了保证查找树的平衡性，我们需要一些灵活性，因此在这里我们允许树的一个结点保存多个键。我们将一颗二叉查找树的结点称为2-结点（包含一个键和两条链接），现在我们引入3-结点（包含两个键和三条链接）。一颗2-3查找树或为一颗空树，或由以下结点组成：2-结点，含有一个键和两条链接，左链接指向的2-3树中的键都小于该结点，有链接都大于。3-结点，含有两个键和三条链接，中链接指向的2-3树中的键都位...
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：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
数据结构第五章-树与二叉树 二叉树的C语言实现代码
最新发布
05-22
该资源中为【数据结构】专栏——C语言实现二叉树篇章中涉及到的代码 代码中包含以下内容： 1. 二叉树相关头文件： - 二叉链表的数据类型声明 - 链队列结点类型声明 - 链队列类型声明 - 二叉树基本功能（二叉树的...
【RISC-V学习】《手把手教你设计CPU——RISC-V处理器》笔记（二）2021.11.11
qq_41876038的博客
11-11 2523
本文只针对RISC-V的相关内容大纲进行整理，对于蜂鸟E200处理器的内容基本上简要略过。且内容只是大纲部分，便于对本文有全局的理解，以及便于今后的翻阅查找。 第二部分 手把手教你使用Verilog 设计CPU 第五章 蜂鸟E200设计总览和顶层介绍 第五章主要以蜂鸟E200为具体实例介绍如何设计一款RISC-V CPU，从宏观入手，介绍若干处理器设计的总览要诀。 本章可以让我们清楚设计RISC-V CPU要从哪几个方面进行考虑，不需要清楚具体的实现细节。 5.1 处理器硬件设计概述 1.架构和
数据结构与算法——深入理解红-黑树！
ChenTianyu的博客
05-20 2455
文章目录数据结构与算法——红-黑树1 为什么需要红-黑树？2 红-黑规则3 为什么默认插入红色节点？4 如何修正违规？(1) [三节点]颜色变换(2) 单节点颜色改变(3) 旋转5 插入一个新节点(1) 向下路途中的颜色变换(3) 插入新节点(4) 插入节点之后的旋转(2) 向下路途中的旋转6 删除7 效率参考 数据结构与算法——红-黑树 1 为什么需要红-黑树？ 普通二叉搜索树，插入新节点后可能导致树的不平衡。 而平衡的二叉树，才能使搜索效率最高。 红-黑树在插入和删除的时候进行了一些特殊的处理，能使二叉
python数据结构学习笔记-2016-12-25-01-2-3 树
mengzm的博客
12-31 778
14.4 2-3 树        2-3 树是一种平衡树，其形状定义如下： 每一个结点可储存1个或2个关键码，分别以k1和k2表示；每一个结点有2~3个子结点，分别为左子结点、中子结点和右子结点；所有的叶结点都在同一层；每一个内结点如果只有一个关键码，则其只有两个子结点，如果有两个关键码，则其有三个子结点。        对于每一个内结点来说，有： 所有小于该
B,B+,B*,2-3树的介绍与图的创建
算法萌新一枚
04-10 734
主要阐述多叉树和图为什么出现,有什么用,特征是什么,以及图的创建等
2-3 tree
内牛满面
10-09 253
[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 940
[TOC] 在之前的二分搜索和二叉查找树中已经能够很好地解决查找的问题了，但是它们在最坏情况下的性能还是很糟糕 理想情况下我们希望能够保持二分查找树的平衡性。在一棵含有N个结点的树中，我们希望树高为 ~lgN，这样我们就能保证所有查找都能在 ~lgN 次比较内结束 一、定义 为了保证查找树的平衡性，我们需要一些灵活性，因此我们允许树中的一个结点保存多个键。 将一棵标准的二叉查找树中的结点...
详解多路查找树（2-3树、2-3-4树、B树、B+树）以及python实现相关操作
weixin_45666566的博客
08-31 1174
多路查找树引言1、概述2、2-3树2.1 定义2.2 插入操作三级目录 引言 二叉树的局限性： \quad \quad二叉树需要加载到内存的，如果二叉树的节点少，没有什么问题，但是如果二叉树的节点很多，就存在一下问题： 在构建二叉树时，需要多次进行i/o(存取）操作（海量数据存在数据库或文件中），节点数量，构建二叉树时，速度有影响。 节点数量，也会造成二叉树的高度很大，会降低操作速度 \quad \quad我们之前谈的树，都是一个节点可以有多个孩子，但是它自身只存储一个元素。二叉树限制更多，节点最多只
【待续】C数据结构2.3-顺序表之插入算法
ai516001066的博客
01-15 231
网易云 转载于:https://www.cnblogs.com/Catherinezhilin/p/10274865.html
队列的顺序存储
08-07 145
typedefintPosition; structQNode{ ElementType*Data;/*存储元素的数组*/ PositionFront,Rear;/*队列的头、尾指针*/ intMaxSize;/*队列最大容量*/ }; typedefstructQNode*Qu...
详解二三树
if_i_were_a的博客
04-18 3675
2-3树: 说明:本博客的图片均来自慕课网 满足二分搜索树的基本性质 节点可以存放一个元素或者两个元素 2-3是一棵绝对平衡的树，从根节点到任意一个叶子节点锁经过的节点数量一定是相等的 2-3树如何维持绝对的平衡？[2-3树添加节点绝对不会添加到空节点中，节点的融合，子树的分裂] 如果插入的是2节点:节点的融合 如果插入的节点是3-节点，父亲节点为2-节点 ...
清华大学版数据结构——深入解析树与二叉树
"数据结构（清华大学版）——树和二叉树" 在计算机科学中，树是一种非线性数据结构，广泛应用于各种算法和数据存储。清华大学版的数据结构教材详细阐述了树和二叉树的相关概念，这对于理解和掌握数据结构至关重要。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值