C++ 23树

23树这篇文章写得有点问题，择日修改

更新： 参考后面写的B树 实现 http://blog.csdn.net/nightwizard2030/article/details/77451712

#include<iostream>  
#include<ctime>  
#include<stack>  
#include<ctime>
#include<cstdlib>
using namespace std;  
 
int new_counter=0;
int del_counter=0; 

struct Node{  
    int _data[3];//one more data for spilt
	int _count;// 1  or  2
    Node* _array[4];//one more point for spilt
};

void insert(Node* node,Node* parent,int data){
	
	//叶节点删除后所留下的空节点
	if(node->_count==0){
		node->_data[0]=data;
		node->_count++;
		return;
	}
	
	
	if(node->_count==1){//如果当前节点为2节点，则可直接在当前节点上添加
		
		if(data<node->_data[0]){//小于2节点 中的数据，在左边添加，使其成为3节点
			
			if(node->_array[0]!=0){//如果有子节点，则向下走
				insert(node->_array[0],node,data);
			}
			else{//如果没有子节点，则在当前节点上操作
				int temp=node->_data[0];
				node->_data[0]=data;
				node->_data[1]=temp;
				node->_count++;
			}
		}else{//大于等于 2节点中的数据，在右边添加，使其成为3节点
			
			if(node->_array[1]!=0){//如果有子节点，则向下走
				insert(node->_array[1],node,data);
			}
			else{
				node->_data[1]=data;
				node->_count++;
			}
			
		}
		
	}
	else{//如果当前为3节点
		
		if(data<node->_data[0]){	
			if(node->_array[0]!=0){
				insert(node->_array[0],node,data);
			}else{
				//有序插入
				int temp1=node->_data[0];
				int temp2=node->_data[1];
				node->_data[0]=data;
				node->_data[1]=temp1;
				node->_data[2]=temp2;
				node->_count++;
			}
		}
		else if(data<node->_data[1]){
			if(node->_array[1]!=0){
				insert(node->_array[1],node,data);
			}else{
				//有序插入
				int temp1=node->_data[1];
				node->_data[1]=data;
				node->_data[2]=temp1;
				node->_count++;
			}
		}
		else{
			if(node->_array[2]!=0){
				insert(node->_array[2],node,data);
			}else{
				//有序插入
				node->_data[2]=data;
				node->_count++;
			}
		}
		
	}
	//分裂检测
	if(node->_count==3){
		
		//构造2个新节点
		Node* node1=new Node;
		node1->_data[0]=node->_data[0];
		node1->_count=1;
		node1->_array[0]=node->_array[0];
		node1->_array[1]=node->_array[1];
		node1->_array[2]=0;
		node1->_array[3]=0;
			
		Node* node2=new Node;
		node2->_data[0]=node->_data[2];
		node2->_count=1;
		node2->_array[0]=node->_array[2];
		node2->_array[1]=node->_array[3];
		node2->_array[2]=0;
		node2->_array[3]=0;
		
		new_counter+=2;
		
		for(int i=1;i<3;i++){
			node1->_data[i]=-1;
			node2->_data[i]=-1;
		}
		
		
		if(parent==0){//如果当前节点没有父节点，则增加一层
			
			//降为2节点
			node->_data[0]=node->_data[1];
			for(int i=1;i<3;i++){
				node->_data[i]=-1;
			}
			node->_count=1;
			node->_array[0]=node1;
			node->_array[1]=node2;
			node->_array[2]=0;
			node->_array[3]=0;
			
			
		}
		else{//如果有父节点，则将分裂出的根插入父节点
			
			//判断位置
			if(node->_data[1]<parent->_data[0]){
				//1 左边
				if(parent->_array[2]!=0){
					parent->_data[2]=parent->_data[1];
					parent->_data[1]=parent->_data[0];
					parent->_data[0]=node->_data[1];
					parent->_array[3]=parent->_array[2];
					parent->_array[2]=parent->_array[1];
					parent->_array[1]=node2;
					parent->_array[0]=node1;
				}
				else if(parent->_array[1]!=0){
					parent->_data[1]=parent->_data[0];
					parent->_data[0]=node->_data[1];
					parent->_array[2]=parent->_array[1];
					parent->_array[1]=node2;
					parent->_array[0]=node1;
				}
				
			}
			else if((parent->_count>1&&node->_data[1]<parent->_data[1])
				||parent->_count==1){
				//1 右边 2左边
				if(parent->_array[2]!=0){
					parent->_data[2]=parent->_data[1];
					parent->_data[1]=node->_data[1];

					parent->_array[3]=parent->_array[2];
					parent->_array[2]=node2;
					parent->_array[1]=node1;

				}
				else if(parent->_array[1]!=0){
					parent->_data[1]=node->_data[1];
					
					parent->_array[2]=node2;
					parent->_array[1]=node1;
				}
			}
			else if((parent->_count>2&&node->_data[1]<parent->_data[2])
				||parent->_count==2){
				//2右边 3左边	
				if(parent->_array[2]!=0){
					parent->_data[2]=node->_data[1];

					parent->_array[3]=node2;
					parent->_array[2]=node1;

				}	
			}

			parent->_count++;
			delete node;
			del_counter++;
		}
	}
}

Node* init(int data){
	
	Node* root=new Node;
	new_counter++;
	for(int i=0;i<3;i++){
		root->_data[i]=-1;
	}
	for(int i=0;i<4;i++){
		root->_array[i]=0;
	}
	
	root->_count=1;
	
	root->_data[0]=data;
	
}

void PreOrderTranversal(Node* root){  
      
    if(root==0){  
        return;  
    }  
    
	for(int i=0;i<2;i++){
		if(root->_data[i]==-1){
			break;
			
		}
		cout<<root->_data[i]<<' ';  
	}
	cout<<root->_count<<endl;


	for(int i=0;i<3;i++){
		 if(root->_array[i]!=0){
			PreOrderTranversal(root->_array[i]); 
		 }
	}

}


void InOrderTranversal(Node* root){
	
	if(root==0){
		return;
	}
	
	for(int i=0;i<3;i++){
		 if(root->_array[i]!=0){
			InOrderTranversal(root->_array[i]);
			if(i<2&&root->_data[i]!=-1){
				cout<<root->_data[i]<<endl;
			}
		 }
	}
	
	if(root->_array[0]==0){
		for(int i=0;i<2;i++){
			if(root->_data[i]!=-1){
				cout<<root->_data[i]<<endl;
			}
		}
	}
}


void PostOrderTranversal(Node* root){
	for(int i=0;i<3;i++){
		 if(root->_array[i]!=0){
			PostOrderTranversal(root->_array[i]); 
			delete root->_array[i];
			del_counter++;
		 }
	}
}

int find_counter=0;
void find(Node* root,int data){
	find_counter++;
	if(root==0){
		cout<<"i can't find it!"<<endl;
		return;
	}
	
	int pos=0;
	for(int i=0;i<2;i++){
		
		if(root->_data[i]==-1){
			break;
		}
		if(root->_data[i]==data){
			cout<<"i find data:"<<data<<" at "<<find_counter<<" times!"<<endl;
			return;
		}
		if(root->_data[i]<data){
			pos=i+1;
		}
	}
	
	find(root->_array[pos],data);
	
}


//give up
/*
void del_proc(Node* root,Node* parent,int pos,int data){
	if(root->_array[0]==0){//要删除的节点为叶节点
		if(root->_count==2){//有两个元素，可直接删除1个
			if(pos==0){
				root->_data[pos]=root->_data[pos+1];
				root->_data[pos+1]=-1;
			}
			else{
				root->_data[pos]=-1;
			}
			root->_count=1;
		}
		else{//只有一个元素
			if(parent->_count==1){//父节点也只有1个元素
				if(parent->_array[0]==root){
					if(parent->_array[1]->_count==1){//只能依赖结构调整了
						parent->_array[1]->_data[1]=parent->_array[1]->_data[0];
						parent->_array[1]->_data[0]=parent->_data[0];
						parent->_array[0]=parent->_array[1];
						parent->_array[1]=0;
						parent->_count=0;
						delete root;
					}
					else{
						
					}
				}
				else{
					
				}
			}
		}
	}
	
}

void del(Node* root,Node* parent,int data){
	if(root==0){
		cout<<"not exist!"<<endl;
		return;
	}
	
	int pos=0;
	for(int i=0;i<2;i++){
		
		if(root->_data[i]==-1){
			break;
		}
		if(root->_data[i]==data){
			del_proc(root,parent,i,data);
			return;
		}
		if(root->_data[i]<data){
			pos=i+1;
		}
	}
	del(root->_array[pos],root,data);
	//结构调整
	
}
*/

void del_proc(Node* ori,Node* root,int pos,int counter){
	
	counter++;
	if(root->_array[0]==0){//要删除的节点为叶节点
		ori->_data[pos]=root->_data[0];
		root->_data[0]=-1;
		if(root->_count==2){
			root->_data[0]=root->_data[1];
			root->_data[1]=-1;
		}
		root->_count--;
		cout<<"del ok!"<<endl;
		return;
	}
	else{//若不是叶节点，就递归找到后继
		if(counter==0){
			del_proc(ori,root->_array[pos+1],pos,counter);
		}
		else{
			del_proc(ori,root->_array[0],pos,counter);
		}
	}
	
}

void del(Node* root,int data){
	if(root==0){
		cout<<"not exist!"<<endl;
		return;
	}
	
	int pos=0;
	for(int i=0;i<2;i++){
		
		if(root->_data[i]==-1){
			break;
		}
		if(root->_data[i]==data){
			cout<<"i:"<<i<<endl;
			del_proc(root,root,i,0);
			return;
		}
		if(root->_data[i]<data){
			pos=i+1;
		}
	}
	del(root->_array[pos],data);
	
}



int main(int argc,char* argv[]){
	srand(time(NULL));
	
	int times=100;
	int find_num=101;
	if(argc>1){
		times=atoi(argv[1]);
	}
	if(argc>2){
		find_num=atoi(argv[2]);
	}
	
	
	Node* root=init(101);

	for(int i=0;i<times;i++){
		insert(root,0,rand()%1000);
	}
	
	PreOrderTranversal(root);
	
	del(root,101);
	
	find(root,find_num);
	
	
	//delete
	PostOrderTranversal(root);
	delete root;
	del_counter++;
	cout<<new_counter<<':'<<del_counter<<endl;
	cout<<"finish!!"<<endl;
}