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

#define t 3

typedef struct BNodeType
{
	int n;
	char key[2*t];
	bool leaf;
	BNodeType *c[2*t+1];
	int height;
}BNode,*pBNode;

typedef struct
{
	pBNode root;
}bTree,*pBTree;

typedef struct 
{
	pBNode x;
	int i;
}sType,*pStype;

pBNode allocateNode()
{
	pBNode node=(pBNode)malloc(sizeof(BNode));
	node->n=0;
	node->height=0;
	return node;
}

void b_tree_create(pBTree T)
{
	pBNode x=allocateNode();
	x->leaf=true;
	x->n=0;
	x->height=0;
	T->root=x;
}



void b_tree_split_child(pBNode x,int i)
{
	pBNode z=allocateNode();
	pBNode y=x->c[i];
	z->leaf=y->leaf;
	z->height=y->height;
	z->n=t-1;
	for(int j=1;j<=t-1;j++)
	{
		z->key[j]=y->key[j+t];
	}
	if(!y->leaf)
	{
		for(int j=1;j<=t;j++)
		{
			z->c[j]=y->c[j+t];
		}
	}
	y->n=t-1;
	for(int j=x->n+1;j>=i+1;j--)
	{
		x->c[j+1]=x->c[j];
	}
	x->c[i+1]=z;
	for(int j=x->n;j>=i;j--)
	{
		x->key[j+1]=x->key[j];
	}
	x->key[i]=y->key[t];
	x->n++;
}

void b_tree_insert_nonfull(pBNode x, char k)
{
	int i=x->n;
	if(x->leaf)
	{
		while(i>=1 && k<x->key[i])
		{
			x->key[i+1]=x->key[i];
			i--;
		}
		x->key[i+1]=k;
		x->n++;
	}
	else
	{
		while(i>=1 && k<x->key[i])
		{
			i--;
		}
		i++;
		if(x->c[i]->n==2*t-1)
		{
			b_tree_split_child(x,i);
			if(k>x->key[i])
				i++;
		}
		b_tree_insert_nonfull(x->c[i],k);
	}
}

void b_tree_insert(pBTree T,char k)
{
	pBNode r=T->root;
	if(r->n==2*t-1)
	{
		pBNode s=allocateNode();
		T->root=s;
		s->leaf=false;
		s->n=0;
		s->height=r->height+1;
		s->c[1]=r;
		b_tree_split_child(s,1);
		b_tree_insert_nonfull(s,k);
	}
	else
		b_tree_insert_nonfull(r,k);
}

pStype b_tree_search(pBNode x,char k)
{
	int i=1;
	while(i<=x->n && k>x->key[i])
		i++;
	if(k==x->key[i])
	{
		pStype s=(pStype)malloc(sizeof(sType));
		s->x=x;
		s->i=i;
		return s;
	}
	else if(x->leaf)
		return NULL;
	else
		return b_tree_search(x->c[i],k);
}

//这个前驱函数假设x为非叶节点，包含叶节点的前驱函数需要用到父节点，这里用不到所以没写
char preDecessor(pBNode x,int i)
{
	pBNode y=x->c[i];
	while(y && !y->leaf)
		y=y->c[y->n+1];
	return y->key[y->n];
}

//这个后继函数假设x为非叶节点，包含叶节点的后继函数需要用到父节点，这里用不到所以没写
char successor(pBNode x,int i)
{
	pBNode y=x->c[i+1];
	while(y && !y->leaf)
		y=y->c[1];
	return y->key[1];
}

void b_tree_delete(pBNode x,char k,pBTree T)
{
	int i=1;
	while(i<=x->n && k>x->key[i])
		i++;
	if(k==x->key[i])
	{
		//case 1
		if(x->leaf)
		{
			for(int j=i;j<x->n;j++)
			{
				x->key[j]=x->key[j+1];
			}
			x->n--;
		}
		//case 2
		else
		{
			//case 2.a
			pBNode y=x->c[i],z=x->c[i+1];
			if(y->n>=t)
			{
				char pre=preDecessor(x,i);
				x->key[i]=pre;
				b_tree_delete(x->c[i],pre,T);
			}
			//case 2.b
			else if(z->n>=t)
			{
				char suc=successor(x,i);
				x->key[i]=suc;
				b_tree_delete(x->c[i+1],suc,T);
			}
			//case 2.c
			else
			{			
				//处理y中key数组
				int j=y->n+1;
				y->key[j]=x->key[i];
				for(int m=1;m<=z->n;m++)
				{
					y->key[j+m]=z->key[m];
				}
				//处理y子节点
				j=y->n+1;
				for(int m=1;m<=z->n+1;m++)
				{
					y->c[j+m]=z->c[m];
				}
				//处理y中key的个数
				y->n+=z->n+1;
				
				//处理x中key数组
				for(int m=i;m<x->n;m++)
					x->key[m]=x->key[m+1];
				//处理x子节点
				for(int m=i+1;m<x->n+1;m++)
					x->c[m]=x->c[m+1];
				//处理x中key的个数
				x->n--;

				if(x->n==0)
				{
					free(x);
					T->root=y;
				}
				free(z);
				b_tree_delete(y,k,T);
			}
		}
	}
	//case 3
	else
	{		
		pBNode y=x->c[i];
		if(y->n<t)
		{
			//case 3.a
			if(i>1 && x->c[i-1] && x->c[i-1]->n>=t)
			{
				//z是y的左兄弟
				pBNode z=x->c[i-1];
				char lc=z->key[z->n];
				char xc=x->key[i-1];
				//处理x
				x->key[i-1]=lc;				
				//处理y
				for(int m=y->n;m>=1;m--)
				{
					y->key[m+1]=y->key[m];
				}
				y->key[1]=xc;
				for(int m=y->n+1;m>=1;m--)
				{
					y->c[m+1]=y->c[m];
				}
				y->c[1]=z->c[z->n+1];
				y->n++;
				//处理z
				z->n--;
				
			}
			else if(i<x->n+1 && x->c[i+1] && x->c[i+1]->n>=t)
			{
				//z是y的右兄弟
				pBNode z=x->c[i+1],y=x->c[i];
				char rc=z->key[1];
				char xc=x->key[i];
				//处理x
				x->key[i]=rc;				
				//处理y
				y->key[y->n+1]=xc;
				y->c[y->n+2]=z->c[1];
				y->n++;
				//处理z
				for(int m=1;m<z->n;m++)
				{
					z->key[m]=z->key[m+1];
				}
				for(int m=1;m<z->n+1;m++)
				{
					y->c[m]=y->c[m+1];
				}				
				z->n--;
			}
			//case 3.b
			else
			{
				if(i>1 && x->c[i-1] && x->c[i-1]->n<t)
				{
					//z是y的左兄弟
					pBNode z=x->c[i-1];
					//处理y中key数组
					for(int m=y->n;m>=1;m--)
						y->key[m+t]=y->key[m];					
					for(int m=1;m<=z->n;m++)
					{
						y->key[m]=z->key[m];
					}
					y->key[t]=x->key[i-1];
					//处理y子节点
					for(int m=y->n+1;m>=1;m--)
						y->c[m+t]=y->c[m];	
					for(int m=1;m<=z->n+1;m++)
					{
						y->c[m]=z->c[m];
					}
					//处理y中key的个数
					y->n+=z->n+1;
				
					//处理x中key数组
					for(int m=i-1;m<x->n;m++)
						x->key[m]=x->key[m+1];
					//处理x子节点
					for(int m=i-1;m<x->n+1;m++)
						x->c[m]=x->c[m+1];
					//处理x中key的个数
					x->n--;

					if(x->n==0)
					{
						free(x);
						T->root=y;
					}
					free(z);
				}
				else if(i<x->n+1 && x->c[i+1] && x->c[i+1]->n<t)
				{
					//z是y的右兄弟
					pBNode z=x->c[i+1];
					//处理y中key数组	
					y->key[t]=x->key[i];
					for(int m=1;m<=z->n;m++)
					{
						y->key[m+t]=z->key[m];
					}				
					//处理y子节点
					for(int m=1;m<=z->n+1;m++)
					{
						y->c[m+t]=z->c[m];
					}
					//处理y中key的个数
					y->n+=z->n+1;
				
					//处理x中key数组
					for(int m=i;m<x->n;m++)
						x->key[m]=x->key[m+1];
					//处理x子节点
					for(int m=i+1;m<x->n+1;m++)
						x->c[m]=x->c[m+1];
					//处理x中key的个数
					x->n--;

					if(x->n==0)
					{
						free(x);
						T->root=y;
					}
					free(z);
				}
			}
		}	
		b_tree_delete(y,k,T);
	}
	
}

void printNode(pBNode x)
{
	for(int i=1;i<=x->n;i++)
	{
		printf("%c,%d ",x->key[i],x->height);
	}
	printf("\n");
}

pBTree initTree()
{
	pBTree T=(pBTree)malloc(sizeof(bTree));	
	T->root=allocateNode();
	pBNode x=T->root;
	x->n=4;
	x->height=1;
	x->leaf=false;
	x->key[1]='G';
	x->key[2]='M';
	x->key[3]='P';
	x->key[4]='X';
	pBNode c1=allocateNode();
	c1->n=4;
	c1->height=0;
	c1->leaf=true;
	c1->key[1]='A';
	c1->key[2]='C';
	c1->key[3]='D';
	c1->key[4]='E';
	pBNode c2=allocateNode();
	c2->n=2;
	c2->height=0;
	c2->leaf=true;
	c2->key[1]='J';
	c2->key[2]='K';
	pBNode c3=allocateNode();
	c3->n=2;
	c3->height=0;
	c3->key[1]='N';
	c3->key[2]='O';
	pBNode c4=allocateNode();
	c4->n=5;
	c4->height=0;
	c4->key[1]='R';
	c4->key[2]='S';
	c4->key[3]='T';
	c4->key[4]='U';
	c4->key[5]='V';
	pBNode c5=allocateNode();
	c5->n=2;
	c5->height=0;
	c5->key[1]='Y';
	c5->key[2]='Z';
	x->c[1]=c1;
	x->c[2]=c2;
	x->c[3]=c3;
	x->c[4]=c4;
	x->c[5]=c5;
	return T;
}

void main()
{
	pBTree T=initTree();
	b_tree_insert(T,'B');
	b_tree_insert(T,'Q');
	b_tree_insert(T,'L');
	b_tree_insert(T,'F');
	b_tree_delete(T->root,'F',T);
	b_tree_delete(T->root,'M',T);
	b_tree_delete(T->root,'G',T);
	//b_tree_delete(T->root,'D',T);
	//b_tree_delete(T->root,'B',T);
	pStype s;
	s=b_tree_search(T->root,'P');
	printNode(s->x);
	s=b_tree_search(T->root,'C');
	printNode(s->x);
	s=b_tree_search(T->root,'E');
	printNode(s->x);
	getchar();
}