B+树C语言实现

B+树C语言版本，编译通过，测试正确

插入部分实现，其中删除和插入类似

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

#define M 2 //The minimum degree of this B+ tree
#define KeyNumMax 2*M-1//Maximum Key Number
#define KeyNumMin M-1//Minimum Key Number


//
typedef int KeyType;
typedef struct Node* Position;
typedef struct rNode* Search_Insert_Position_Result;
typedef struct List_Node* Path_List;
//data struct
typedef struct Node{
	bool IsLeaf;
	int KeyNum;
	KeyType Key[KeyNumMax];
	Position PtrChild[KeyNumMax];
	Position Next_Leaf_Node;
}Node;
typedef struct rNode{
	Position Insert_Position;
	int Key_Position;
}rNode;
typedef struct List_Node{
	Path_List Pre_List_Node;
	Path_List Next_List_Node;
	Position Path_List_Tree_Node;
	int The_Ith_Child_of_Parent;
}List_Node;

//global variable
Position ROOT;
Path_List Path_List_Header;
Path_List Path_List_Tail;
//Make Node
Position Make_New_Node()
{
	Position New_Node=(Position)malloc(sizeof(Node));
	New_Node->IsLeaf=false;
	New_Node->KeyNum=0;
	New_Node->Next_Leaf_Node=NULL;
	return New_Node;
}

//Search the Leaf Node to Insert
Search_Insert_Position_Result BPT_Search(Position Current_Node,KeyType Key,int Index)
{
	int i=0;
	Path_List Path_List_Node=(Path_List)malloc(sizeof(List_Node));
	
	Path_List_Node->Path_List_Tree_Node=Current_Node;
	
	Path_List_Tail->Pre_List_Node->Next_List_Node=Path_List_Node;
	Path_List_Node->Pre_List_Node=Path_List_Tail->Pre_List_Node;
	Path_List_Node->Next_List_Node=Path_List_Tail;
	Path_List_Tail->Pre_List_Node=Path_List_Node;
	Path_List_Node->The_Ith_Child_of_Parent=Index;
	//printf("%d\n",Path_List_Tail->Pre_List_Node->Path_List_Tree_Node->KeyNum);
	//if(Path_List_Tail->Pre_List_Node->Pre_List_Node==Path_List_Header)
	//	puts("here");
	
	Search_Insert_Position_Result Insert_Node_Position=(Search_Insert_Position_Result)malloc(sizeof(rNode));
	if(Current_Node->IsLeaf==true)
	{
		while(Key>Current_Node->Key[i]&&i<Current_Node->KeyNum)
			i++;
		Insert_Node_Position->Insert_Position=Current_Node;
		Insert_Node_Position->Key_Position=i;
		return Insert_Node_Position;	
	}
	else
	{
		while(i<Current_Node->KeyNum&&Key>Current_Node->Key[i])
		{
			i++;
		}
		if(i==Current_Node->KeyNum)
			i--;
		Search_Insert_Position_Result Insert_Position_1=BPT_Search(Current_Node->PtrChild[i],Key,i);
		return Insert_Position_1;
	}
}

//function of Node Splict,case 1:leaf node;   case 2:internal node;
Position BplusTree_Node_Split(Position Current_Node)
{
	int i=0;
	Position New_Node=Make_New_Node();
	New_Node->IsLeaf=Current_Node->IsLeaf;
	if(Current_Node->IsLeaf==true){
		New_Node->Next_Leaf_Node=Current_Node->Next_Leaf_Node;
		Current_Node->Next_Leaf_Node=New_Node;
		for(i=0;i<M-1;i++)
			New_Node->Key[i]=Current_Node->Key[i+M];
		Current_Nod