二叉排序树(B-Tree)-c实现

这个二叉排序树写完了，虽然还有些bug，但还是很高兴的。

主要实现二叉排序树的构建。(*表示稍微重要点)

二叉排序树的打印。

二叉排序树的删除。

代码里的三种情况都测了

顺便附送一个简单的中序遍历，递归。

代码现在还有很多内存泄漏，不想改了，明天或者下周改。

主要遇到的小问题：1.排序树的打印，本想链式结构打印出来，但是控制不好，就换了一种简单的方法。

                          2.内存malloc和free还有很大问题。tips：为什么一般malloc之后，内存释放后NULL指针，现在有点明白，free 那块malloc的内存，不然会形成很多内存碎片，而此时的指针还是指向原先的那块内存地址，只不过数据被free掉了，，p= NULL，这样把指针内容清掉。

                          3.最不该的错误是2个，一个笔误把=写成了==，找了半个小时的bug，另一个是类型转换，漏掉一个&， PrintBTree((BTREE*) &delNode);//here I forget the sybol &

#include <stdio.h>
#define  ISLCHILD 1
#define  ISRCHILD 2

typedef int  DATATYPE;
typedef struct treenode
{
    DATATYPE data;
    struct treenode *parent;
    struct treenode *lchild;
    struct treenode *rchild;
}TreeNode;

typedef TreeNode* BTREE;
TreeNode* InitBTree(DATATYPE oriData[], int size);
//TreeNode * GetRootNode(DATATYPE data);
TreeNode * GetRootNode(DATATYPE data, TreeNode* newTreeNode);
TreeNode *InsertNode(TreeNode* parNode, DATATYPE data);
TreeNode *GetFixNode(BTREE *btree, DATATYPE data);
void PrintBTree(BTREE* btree);
void PrintTreeNode(TreeNode* );
void PrintViewTreeNode(TreeNode* treeNode, int num);
void PrintNTab(int i);
void DeleteNode(BTREE* btree, DATATYPE delData);
int IsLeafNode(TreeNode* Node);
TreeNode* GetNodePos(BTREE* btree, DATATYPE Data);
int IsLchild(TreeNode* pareNode,  DATATYPE sonNode);
int IsHasOneChlid(TreeNode *Node);
int IsHasTwoChlid(TreeNode *Node);

TreeNode* GetMaxNodePos(BTREE* btree);
void PreTravel(BTREE *btree);
//中序遍历
void PreTravel(BTREE *btree)
{
    TreeNode* curTreeNode = *btree;
    if(IsLeafNode(curTreeNode))
    {
        printf("%d ", curTreeNode->data);
    }
    else
    {
        if((*btree)->lchild!=NULL)
        {
            PreTravel((BTREE*)&((*btree)->lchild));
        }
        printf("%d ", curTreeNode->data);
        if((*btree)->rchild!=NULL)
        {
            PreTravel((BTREE*)&((*btree)->rchild));
        }

    }
    return ;
}

TreeNode* GetMaxNodePos(BTREE* btree)
{
    TreeNode* maxTreeNode = *btree;
    while(maxTreeNode)
    {
        printf("NodeValue[%d]
", maxTreeNode->data);
        printf("NodeValue[%d]
", maxTreeNode->data);
        printf("NodeValue[%d]
", maxTreeNode->data);

        if(maxTreeNode->rchild == NULL)
        {
            break;
            //return maxTreeNode;
        }else{
            maxTreeNode = maxTreeNode->rchild;
        }
    }
    return maxTreeNode;
}


/*1=> has 2 childrean*/
int IsHasTwoChlid(TreeNode *Node)
{
    return ((Node->lchild!=NULL)&&(Node->rchild!=NULL));
}

int IsHasOneChlid(TreeNode *Node)
{
    if((Node->lchild !=NULL)&&(Node->rchild == NULL))
        return ISLCHILD;
    if((Node->lchild ==NULL)&&(Node->rchild != NULL))
        return ISRCHILD;
    return 0;
}

/* 1——> isLchild */
int IsLchild(TreeNode* pareNode, DATATYPE sonNode)
{
    return (pareNode->lchild->data == sonNode);
}
TreeNode* GetNodePos(BTREE* btree, DATATYPE data)
{
    //TreeNode* curTreeNode = (TreeNode*)malloc(sizeof(TreeNode));
    TreeNode* curTreeNode = *btree;
    while(//(curTreeNode->data!= data )
          1&&(curTreeNode != NULL))
    {
        if(data == curTreeNode->data)
        {
            break;
        }
        else  if(data> curTreeNode->data)
        {
            curTreeNode = curTreeNode->rchild;
        }
        else  if(data < curTreeNode->data)
        {
            curTreeNode = curTreeNode->lchild;
        }

    }
    return curTreeNode;
}


/*1 -> isleaf*/
int IsLeafNode(TreeNode* Node)
{
    return ((Node->lchild == NULL)&&(Node->rchild == NULL));
}

/*
RULE:其删除一个节点需要考虑对应节点的状态，具体的说就是，是否存在左右节点，等等。需要按照以下情况讨论。

1.查找待删除节点，在查找的同时需要记录一下待删除节点的父亲。

2.如果待删除节点的左右节点都不存在，那么直接删除（叶子节点）。

3.如果待删除节点左子树存在右子树不存在，或者左子树不存在右子树存在。直接将其子树中存在的一边候补上来即可。

4.如果待删除节点左右子树都在，这个情况是最复杂的。需要按照二叉排序树的性质从其左子树或者有子树中选择节点补到待删除节点的位置。

    如果从左子树中选，就应该选择左子树中最右边的那个叶子节点（这里肯定是叶子，如果不是叶子，那么就不是最右边的节点）

    如果从右子树中选，就应该选择有子树中最左边的那个叶子节点。
*/
void DeleteNode(BTREE* btree, DATATYPE delData)
{
    TreeNode *delNode  = GetNodePos(btree, delData);

    if(delNode == NULL)
    {
        printf("delNode not exist.
");
        return ;
    }
    /*叶子节点*/
    if(IsLeafNode(delNode))
    {
        printf("delNode is leaf node,del directly.
");
        if(IsLchild(delNode->parent, delData))
        {
            /*in left tree*/
            delNode->parent->lchild = NULL;
            delNode = NULL;
        }
        else
        {
            delNode->parent->rchild = NULL;
            delNode = NULL;
        }
        return ;

    }

    /*只有一个孩子节点，直接删除*/
    if(IsHasOneChlid(delNode) == ISLCHILD)
    {
        delNode->lchild->parent = delNode->parent;
        /*judge the del is the left or right*/
        if(IsLchild(delNode->parent, delNode->data))
        {
            delNode->parent->lchild = delNode->lchild;

        }
        else
        {
            delNode->parent->rchild = delNode->lchild;
        }
        delNode = NULL;
        return ;
    }
    else if(IsHasOneChlid(delNode) == ISRCHILD)
    {
        delNode->rchild->parent = delNode->parent;
        /*judge the del is the left or right*/
        if(IsLchild(delNode->parent, delNode->data))
        {
            delNode->parent->lchild = delNode->rchild;

        }
        else
        {
            delNode->parent->rchild = delNode->rchild;
        }

        delNode = NULL;
        return ;
    }
    //有左右孩子节点，找出左/右中的最大/小的，替换删除的节点
    /*I chose the left max to replace the delnode*/
    if(IsHasTwoChlid(delNode))
    {
#if 0
        printf("TTTTTTTTTTTTTTTTTTTTTTTB
");
        PrintBTree((BTREE*) &delNode);//here I forget the sybol &
        printf("TTTTTTTTTTTTTTTTTTTTTTTE
");
#else
        TreeNode* maxTreeNode = GetMaxNodePos((BTREE*)&delNode);
        printf("MaxTreeNode[%d]
", maxTreeNode->data);
        maxTreeNode->parent->rchild = NULL;//here =  writes to ==  then ^ ^
        maxTreeNode->parent = NULL;
        delNode->data = maxTreeNode->data;
        maxTreeNode = NULL;
#endif
        return ;
    }
}

void PrintNTab(int num)
{
    int i = 0;

    while(i<num)
    {
       printf("    ");
       i++;
    }
}

void PrintViewTreeNode(TreeNode* treeNode, int num)
{
    num++;
    printf("%d", treeNode->data);
    if(treeNode->lchild == NULL)
    {
        printf("
");
        PrintNTab(num);
        printf("*");
    }
    else
    {    printf("
");
         PrintNTab(num);
         PrintViewTreeNode(treeNode->lchild, num);
    }
    if(treeNode->rchild == NULL)
    {
        printf("
");
        PrintNTab(num);
        printf("&");

    }
    else
    {
        printf("
");
        PrintNTab(num);
        PrintViewTreeNode(treeNode->rchild, num);

    }


}

/*这个看不出来树的结构了，需要重新写打印方法。*/
void PrintTreeNode(TreeNode* treeNode)
{
    if((treeNode->lchild == NULL)
            &&(treeNode->rchild == NULL))
    {
       printf("%d
", treeNode->data);
    }
    else
    {
        if((treeNode->lchild != NULL)
                || (treeNode->rchild != NULL))
        {
            printf("%d ", treeNode->data);
            if(treeNode->lchild != NULL)
            {
                printf("--->");
                PrintTreeNode(treeNode->lchild);
            }
            printf("%d ", treeNode->data);
            if(treeNode->rchild != NULL)
            {
                printf("===>");
                PrintTreeNode(treeNode->rchild);
            }
        }
    }
    return ;
}

void PrintBTree(BTREE* btree)
{
    int num = 0;
    if(btree==NULL)
    {
        printf("empty tree.
");
    }
    printf("TreeView Rule---若一个节点有左右孩子节点,则父节点一行一列，左右孩子不同行同一列，若无做孩子，则打印的数据用*代替，如果无有孩子则打印的数据用&代替"
           "另外树的层次用4个空格来体现，比如第1列代表第一层，第5列代表第二层。
"
           );
    printf("***********TREE View BEGIN***********
");
    //PrintTreeNode((*btree));
    PrintViewTreeNode(*btree, num);
    printf("
");
    printf("***********TREE View END ***********
");
    printf("
");

    printf("***********TREE View BEGIN***********
");
    printf("rules:
	---> lchild.
	 ===> rchild
");
    PrintTreeNode(*btree);
    printf("
");
    printf("***********TREE View END ***********
");

}


TreeNode* InitBTree(DATATYPE oriData[],  int size)
{
    BTREE* btree = NULL;
    btree = (BTREE*)malloc(sizeof(BTREE));
    *btree = (TreeNode*)malloc(sizeof(TreeNode));
    int pos = size;
    GetRootNode(oriData[0], *btree);
    TreeNode *posNode = (TreeNode*)malloc(sizeof(TreeNode));
    while(pos>1)
    {
        printf("********begin one*************
");
        printf("pos = [%d] index =[%d] data[%d]
", pos, size-pos+1, oriData[size-pos+1]);
        posNode = GetFixNode(btree, oriData[size-pos+1]);
        printf("Parent = [%d] Insert data=[%d]  
", posNode->data, oriData[size-pos+1] );
        InsertNode(posNode, oriData[size-pos+1]);
        pos--;
        printf("********end one*************

");

    }

    printf("********btree data %d*************

", (*btree)->data);

    return *btree;

}

TreeNode * GetRootNode(DATATYPE data, TreeNode* newTreeNode)
{
    //newTreeNode = (TreeNode*)malloc(sizeof(TreeNode));
    newTreeNode->data = data;
    newTreeNode->parent = NULL;
    newTreeNode->lchild = NULL;
    newTreeNode->rchild = NULL;
    return newTreeNode;
}
//将一个值插入节点的L/R子树上
TreeNode *InsertNode(TreeNode* parNode, DATATYPE data)
{
    if(data == parNode->data)
    {
        printf("invaild data %d
", data);
        printf("invaild para here at line %d.
", __LINE__);
        return NULL;
    }
    TreeNode* sonTreeNode = (TreeNode*)malloc(sizeof(TreeNode));
    sonTreeNode->data = data;
    sonTreeNode->lchild = NULL;
    sonTreeNode->rchild = NULL;
    sonTreeNode->parent = parNode;//这里要不要考虑这个链接？？？
    if(data < parNode->data)
    {
         parNode->lchild = sonTreeNode;
    }
    else{
        parNode->rchild = sonTreeNode;
    }
    return sonTreeNode;
}
//查找合适的位置来插入新元素(find parent)
TreeNode *GetFixNode(BTREE *btree, DATATYPE data)
{
     if((btree == NULL ))
     {
         return NULL;
     }

     if(((*btree)->lchild == NULL)
             &&((*btree)->rchild == NULL))
     {
         //InsertNode(*btree ,data);
         printf("insert under root 
");
         return *btree;
     }
     TreeNode* curTreeNode = (TreeNode*)malloc(sizeof(TreeNode));
     curTreeNode = *btree;
     while( (curTreeNode->lchild != NULL)
           ||(curTreeNode->rchild !=NULL) )
     {
         if(data > curTreeNode->data)
         {
             //printf("insert R 
");
             printf(" data=[%d] curData=[%d] insert R 
", data, curTreeNode->data);
             if(curTreeNode->rchild != NULL)
             {
                 printf("curTreeNode->rchild != NULL rchild[%d]
", curTreeNode->rchild->data);
                 curTreeNode = curTreeNode->rchild;

             }else{

                 break;
             }
         }
         else if(data < curTreeNode->data)
         {
             printf(" data=[%d] curData=[%d] insert L 
", data, curTreeNode->data);
             if(curTreeNode->lchild != NULL)
             {
                 curTreeNode = curTreeNode->lchild;

             }else{

                 break;
             }
         }
         else
         {
             printf("invaild elem here at line %d.
", __LINE__);
             return NULL;
         }

     }
     return curTreeNode;

}

int main(void)
{
    printf("	Hello World!
");
    int arr[12]={4, 5, 2, 1,3, 6, 8, 9, 7, 22, 11, 33};

    //int arr[5]={22, 11, 33, 15, 9};
    BTREE *btree = NULL;
    btree = (BTREE*)malloc(sizeof(BTREE));
    *btree = (TreeNode*)malloc(sizeof(TreeNode));
    *btree = InitBTree(arr, 12);
    //*btree = InitBTree(arr, 5);
    PrintBTree(btree);
    TreeNode* curTreeNode = (TreeNode*)malloc(sizeof(TreeNode));

    DeleteNode(btree, 11);
    PrintBTree(btree);
    printf("中序遍历:
");
    PreTravel(btree);


    return 0;
}

运行结构也贴上来：

        Hello World!
********begin one*************
pos = [12] index =[1] data[5]
insert under root
Parent = [4] Insert data=[5]
********end one*************

********begin one*************
pos = [11] index =[2] data[2]
 data=[2] curData=[4] insert L
Parent = [4] Insert data=[2]
********end one*************

********begin one*************
pos = [10] index =[3] data[1]
 data=[1] curData=[4] insert L
Parent = [2] Insert data=[1]
********end one*************

********begin one*************
pos = [9] index =[4] data[3]
 data=[3] curData=[4] insert L
 data=[3] curData=[2] insert R
Parent = [2] Insert data=[3]
********end one*************

********begin one*************
pos = [8] index =[5] data[6]
 data=[6] curData=[4] insert R
curTreeNode->rchild != NULL rchild[5]
Parent = [5] Insert data=[6]
********end one*************

********begin one*************
pos = [7] index =[6] data[8]
 data=[8] curData=[4] insert R
curTreeNode->rchild != NULL rchild[5]
 data=[8] curData=[5] insert R
curTreeNode->rchild != NULL rchild[6]
Parent = [6] Insert data=[8]
********end one*************

********begin one*************
pos = [6] index =[7] data[9]
 data=[9] curData=[4] insert R
curTreeNode->rchild != NULL rchild[5]
 data=[9] curData=[5] insert R
curTreeNode->rchild != NULL rchild[6]
 data=[9] curData=[6] insert R
curTreeNode->rchild != NULL rchild[8]
Parent = [8] Insert data=[9]
********end one*************

********begin one*************
pos = [5] index =[8] data[7]
 data=[7] curData=[4] insert R
curTreeNode->rchild != NULL rchild[5]
 data=[7] curData=[5] insert R
curTreeNode->rchild != NULL rchild[6]
 data=[7] curData=[6] insert R
curTreeNode->rchild != NULL rchild[8]
 data=[7] curData=[8] insert L
Parent = [8] Insert data=[7]
********end one*************

********begin one*************
pos = [4] index =[9] data[22]
 data=[22] curData=[4] insert R
curTreeNode->rchild != NULL rchild[5]
 data=[22] curData=[5] insert R
curTreeNode->rchild != NULL rchild[6]
 data=[22] curData=[6] insert R
curTreeNode->rchild != NULL rchild[8]
 data=[22] curData=[8] insert R
curTreeNode->rchild != NULL rchild[9]
Parent = [9] Insert data=[22]
********end one*************

********begin one*************
pos = [3] index =[10] data[11]
 data=[11] curData=[4] insert R
curTreeNode->rchild != NULL rchild[5]
 data=[11] curData=[5] insert R
curTreeNode->rchild != NULL rchild[6]
 data=[11] curData=[6] insert R
curTreeNode->rchild != NULL rchild[8]
 data=[11] curData=[8] insert R
curTreeNode->rchild != NULL rchild[9]
 data=[11] curData=[9] insert R
curTreeNode->rchild != NULL rchild[22]
Parent = [22] Insert data=[11]
********end one*************

********begin one*************
pos = [2] index =[11] data[33]
 data=[33] curData=[4] insert R
curTreeNode->rchild != NULL rchild[5]
 data=[33] curData=[5] insert R
curTreeNode->rchild != NULL rchild[6]
 data=[33] curData=[6] insert R
curTreeNode->rchild != NULL rchild[8]
 data=[33] curData=[8] insert R
curTreeNode->rchild != NULL rchild[9]
 data=[33] curData=[9] insert R
curTreeNode->rchild != NULL rchild[22]
 data=[33] curData=[22] insert R
Parent = [22] Insert data=[33]
********end one*************

********btree data 4*************

TreeView Rule---若一个节点有左右孩子节点,则父节点一行一列，左右孩子不同行同一列，若无做孩子，则打印的数据用*代替，如果无有孩子则打印的数据用&代替另外树的层次用4个空格来体现，比如第1列代表第一层，第5列代表第二层。
***********TREE View BEGIN***********
4
    2
        1
            *
            &
        3
            *
            &
    5
        *
        6
            *
            8
                7
                    *
                    &
                9
                    *
                    22
                        11
                            *
                            &
                        33
                            *
                            &
***********TREE View END ***********

***********TREE View BEGIN***********
rules:
        ---> lchild.
         ===> rchild
4 --->2 --->1
2 ===>3
4 ===>5 5 ===>6 6 ===>8 --->7
8 ===>9 9 ===>22 --->11
22 ===>33

***********TREE View END ***********
delNode is leaf node,del directly.
TreeView Rule---若一个节点有左右孩子节点,则父节点一行一列，左右孩子不同行同一列，若无做孩子，则打印的数据用*代替，如果无有孩子则打印的数据用&代替另外树的层次用4个空格来体现，比如第1列代表第一层，第5列代表第二层。
***********TREE View BEGIN***********
4
    2
        1
            *
            &
        3
            *
            &
    5
        *
        6
            *
            8
                7
                    *
                    &
                9
                    *
                    22
                        *
                        33
                            *
                            &
***********TREE View END ***********

***********TREE View BEGIN***********
rules:
        ---> lchild.
         ===> rchild
4 --->2 --->1
2 ===>3
4 ===>5 5 ===>6 6 ===>8 --->7
8 ===>9 9 ===>22 22 ===>33

***********TREE View END ***********
中序遍历:
1 2 3 4 5 6 7 8 9 22 33