数据结构：二叉排序树

原创

顾道长生 2022-07-13 09:56:28 博主文章分类：数据结构 ©著作权

文章标签 数据结构结点 #include i++ 文章分类 数据结构与算法人工智能

©著作权归作者所有：来自51CTO博客作者顾道长生的原创作品，请联系作者获取转载授权，否则将追究法律责任

听了国嵌唐老师的课，用C语言实现：

数据结构：二叉排序树_数据结构

BSTree.c

#include <stdio.h>
#include <malloc.h>
#include "BSTree.h"

typedef struct _tag_BSTree TBSTree;
struct _tag_BSTree
{
    int count;
    BSTreeNode* root;
};

static void recursive_display(BSTreeNode* node, BSTree_Printf* pFunc, int format, int gap, char div) 
{
    int i = 0;
    
    if( (node != NULL) && (pFunc != NULL) )
    {
        for(i=0; i<format; i++)
        {
            printf("%c", div);
        }
        
        pFunc(node);
        
        printf("\n");
        
        if( (node->left != NULL) || (node->right != NULL) )
        {
            recursive_display(node->left, pFunc, format + gap, gap, div);
            recursive_display(node->right, pFunc, format + gap, gap, div);
        }
    }
    else
    {
        for(i=0; i<format; i++)
        {
            printf("%c", div);
        }
        printf("\n");
    }
}

static int recursive_count(BSTreeNode* root)
{
    int ret = 0;
    
    if(root!=NULL)
    {
        ret = recursive_count(root->left)+1+recursive_count(root->right);
    }
    
    return ret;
}

static int recursive_height(BSTreeNode* root)
{
    int ret = 0;
    
    if(root!=NULL)
    {
        int lh = recursive_height(root->left);
        int rh = recursive_height(root->right);
        
        ret = ((lh>rh)?lh:rh)+1;
    }
    
    return ret;
}

static int recursive_degree(BSTreeNode* root)
{
    int ret = 0;
    
    if( root != NULL )
    {
        if( root->left != NULL )
        {
            ret++;
        }
        
        if( root->right != NULL )
        {
            ret++;
        }
        
        if( ret == 1 )
        {
            int ld = recursive_degree(root->left);
            int rd = recursive_degree(root->right);
            
            if( ret < ld )
            {
                ret = ld;
            }
            
            if( ret < rd )
            {
                ret = rd;
            }
        }
    }
    
    return ret;
}

static int recursive_insert(BSTreeNode* root,BSTreeNode* node,BSTree_Compare* compare)
{
    int ret = 0;
    int r = compare(node->key,root->key);
    
    if(r==0)
    {
        ret = 0;
    }
    else if(r<0)
    {
        if(root->left!=NULL)
        {
            ret = recursive_insert(root->left,node,compare);
        }
        else
        {
            root->left = node;
        }
    }
    else if(r>0)
    {
        if(root->right!=NULL)
        {
            ret =  recursive_insert(root->right,node,compare);
        }
        else
        {
            root->right = node;
        }
    }
}

static BSTreeNode* recursive_get(BSTreeNode* root,BSKey* key,BSTree_Compare* compare)
{
    BSTreeNode* ret = NULL;
    
    if(root!=NULL)
    {
        int r = compare(key,root->key);
        
        if(r==0)
        {
            ret = root;
        }
        else if(r<0)
        {
            ret = recursive_get(root->left,key,compare);
        }
        else if(r>0)
        {
            ret = recursive_get(root->right,key,compare);
        }
    }
    
    return  ret;
}

static BSTreeNode* delete_node(BSTreeNode** pRoot)
{
    BSTreeNode* ret = *pRoot;
    
    if((*pRoot)->right==NULL)
    {
        *pRoot = (*pRoot)->left;
    }
    else if((*pRoot)->left==NULL)
    {
        *pRoot = (*pRoot)->right;
    }
    else
    {
        BSTreeNode* g = *pRoot;
        BSTreeNode* c = (*pRoot)->left;
        
        while(c->right!=NULL)
        {
            g = c;
            c = c->right;
        }
        
        if(g!=*pRoot)
        {
            g->right = c->left;
        }
        else
        {
            g->left = c->left;
        }
        
        c->left = (*pRoot)->left;
        c->right = (*pRoot)->right;
        
        *pRoot = c;
    }
    
    return ret;
}

static BSTreeNode* recursive_delete(BSTreeNode** pRoot,BSKey* key,BSTree_Compare* compare)
{
    BSTreeNode* ret = NULL;
    
    if((pRoot!=NULL)&&(*pRoot!=NULL))
    {
        int r = compare(key,(*pRoot)->key);
        
        if(r==0)
        {
            ret = delete_node(pRoot);
        }
        else if(r<0)
        {
            ret = recursive_delete((&(*pRoot)->left),key,compare);
        }
        else if(r>0)
        {
            ret = recursive_delete((&(*pRoot)->right),key,compare);
        }
    }
    
    return ret;
}

/*创建一个树*/ 
BSTree* BSTree_Create()
{
    TBSTree* ret = (TBSTree*)malloc(sizeof(TBSTree));
    
    if(ret!=NULL)
    {
        ret->count = 0;
        ret->root = NULL;
    }
    
    return ret;
}

/*销毁一个树*/ 
void BSTree_Destroy(BSTree* tree)
{
    free(tree);
}

/*将已存在的树清空*/
void BSTree_Clear(BSTree* tree)
{
    TBSTree* btree = (TBSTree*)tree;
    
    if(btree!=NULL)
    {
        btree->count = 0;
        btree->root = NULL;
    }
}

/*将结点node插入到tree中的pos位置处*/
BSTree_Insert(BSTree* tree,BSTreeNode* node,BSTree_Compare* compare)
{
    TBSTree* btree = (TBSTree*)tree;
    int ret = (btree != NULL) && (node != NULL) && (compare!=NULL);
    int bit = 0;
    
    if( ret )
    {
        node->left = NULL;
        node->right = NULL;
        
        if(btree->root== NULL)
        {
            btree->root = node;
        }
        else
        {
            ret = recursive_insert(btree->root,node,compare);
        }
        
        if(ret)
        {
            btree->count++;
        }
    }
    
    return ret;
}

/*将tree中pos位置的结点删除并返回*/
BSTreeNode* BSTree_Delete(BSTree* tree,BSKey* key,BSTree_Compare* compare)
{
    TBSTree* btree = (TBSTree*)tree;
    BSTreeNode* ret = NULL;
    int bit = 0;
    
    if((btree!=NULL)&&(key!=NULL)&&(compare!=NULL))
    { 
        ret = recursive_delete(&btree->root,key,compare);
        
        if(ret!=NULL)
        {
            btree->count--;
        }
        
    }
    
    return ret;
}

/*得到pos位置的结点并返回*/
BSTreeNode* BSTree_Get(BSTree* tree,BSKey* key,BSTree_Compare* compare)
{
    TBSTree* btree = (TBSTree*)tree;
    BSTreeNode* ret = NULL;
    
    if((btree!=NULL)&&(key!=NULL)&&(compare!=NULL))
    { 
        ret = recursive_get(btree->root,key,compare);
    }
    
    return ret;
}

/*返回tree的根结点*/
BSTreeNode* BSTree_Root(BSTree* tree)
{
    TBSTree* btree = (TBSTree*)tree;
    BSTreeNode* ret = NULL;
    
    if( btree != NULL )
    {
        ret = btree->root;
    }
    
    return ret;
}

/*返回tree的高度*/
int BSTree_Height(BSTree* tree)
{
    TBSTree* btree = (TBSTree*)tree;
    int ret = 0;
    
    if( btree != NULL )
    {
        ret = recursive_height(btree->root);
    }
    
    return ret;    
}

/*返回tree的结点数*/
int BSTree_Count(BSTree* tree)
{
    TBSTree* btree = (TBSTree*)tree;
    int ret = 0;
    
    if( btree != NULL )
    {
        ret = btree->count;
    }
    
    return ret;
}

/*返回tree的度数*/
int BSTree_Degree(BSTree* tree)
{
    TBSTree* btree = (TBSTree*)tree;
    int ret = 0;
    
    if( btree != NULL )
    {
        ret = recursive_degree(btree->root);
    }
    
    return ret;    
}

void BSTree_Display(BSTree* tree, BSTree_Printf* pFunc, int gap, char div) 
{
    TBSTree* btree = (TBSTree*)tree;
    
    if( btree != NULL )
    {
        recursive_display(btree->root, pFunc, 0, gap, div);
    }
}

BSTree.h

#ifndef _BSTREE_H_
#define _BSTREE_H_

typedef void BSTree;
typedef void BSKey;

typedef struct _tag_BSTreeNode BSTreeNode;
struct _tag_BSTreeNode
{
  BSKey* key;
  BSTreeNode* left;
  BSTreeNode* right;
};
typedef void (BSTree_Printf)(BSTreeNode*);
typedef int (BSTree_Compare)(BSKey*,BSKey*);

/*创建一个树*/ 
BSTree* BSTree_Create();

/*销毁一个树*/ 
void BSTree_Destroy(BSTree* tree);

/*将已存在的树清空*/
void BSTree_Clear(BSTree* tree);

/*将结点node插入到tree中的pos位置处*/
int BSTree_Insert(BSTree* tree,BSTreeNode* node,BSTree_Compare* compare);

/*将tree中pos位置的结点删除并返回*/
BSTreeNode* BSTree_Delete(BSTree* tree,BSKey* key,BSTree_Compare* compare);

/*得到pos位置的结点并返回*/
BSTreeNode* BSTree_Get(BSTree* tree,BSKey* key,BSTree_Compare* compare);

/*返回tree的根结点*/
BSTreeNode* BSTree_Root(BSTree* tree);

/*返回tree的高度*/
int BSTree_Height(BSTree* tree);

/*返回tree的结点数*/
int BSTree_Count(BSTree* tree);

/*返回tree的度数*/
int BSTree_Degree(BSTree* tree);

void BSTree_Display(BSTree* tree,BSTree_Printf* pFunc,int gap,char div);

#endif

main.c

#include <stdio.h>
#include <stdlib.h>
#include "BSTree.h"
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

struct Node
{
    BSTreeNode header;
    char v;
};

void print_data(BSTreeNode* node)
{
    if(node!=NULL)
    {
        printf("%c",((struct Node*)node)->v);
    }
}

int compare_key(BSKey* k1,BSKey* k2)
{
    return (int)k1-(int)k2;
}

int main(int argc, char *argv[])
{
    BSTree* tree = BSTree_Create();
    
    struct Node n1 = {{(BSKey*)1,NULL, NULL}, 'A'};
    struct Node n2 = {{(BSKey*)2,NULL, NULL}, 'B'};
    struct Node n3 = {{(BSKey*)3,NULL, NULL}, 'C'};
    struct Node n4 = {{(BSKey*)4,NULL, NULL}, 'D'};
    struct Node n5 = {{(BSKey*)5,NULL, NULL}, 'E'};
    struct Node n6 = {{(BSKey*)6,NULL, NULL}, 'F'};
    
    BSTree_Insert(tree, (BSTreeNode*)&n4, compare_key);
    BSTree_Insert(tree, (BSTreeNode*)&n1, compare_key);
    BSTree_Insert(tree, (BSTreeNode*)&n3, compare_key);
    BSTree_Insert(tree, (BSTreeNode*)&n6, compare_key);
    BSTree_Insert(tree, (BSTreeNode*)&n2, compare_key);
    BSTree_Insert(tree, (BSTreeNode*)&n5, compare_key);
    
    printf("Height:%d\n",BSTree_Height(tree));
    printf("Degree:%d\n",BSTree_Degree(tree));
    printf("Count:%d\n",BSTree_Count(tree));
    printf("Search Key 5:%c\n",((struct Node*)BSTree_Get(tree,(BSKey*)5,compare_key))->v);
    
    printf("Full Tree\n");
    
    BSTree_Display(tree,print_data,4,'-');
    
    BSTree_Delete(tree,(BSKey*)1,compare_key);
    printf("After Delete Key 1:\n");
    printf("Height:%d\n",BSTree_Height(tree));
    printf("Degree:%d\n",BSTree_Degree(tree));
    printf("Count:%d\n",BSTree_Count(tree));
    printf("Full Tree\n");
    
    BSTree_Display(tree,print_data,4,'-');
    
    BSTree_Clear(tree);
    printf("After Clear:\n");
    printf("Height:%d\n",BSTree_Height(tree));
    printf("Degree:%d\n",BSTree_Degree(tree));
    printf("Count:%d\n",BSTree_Count(tree));
    
    BSTree_Display(tree,print_data,4,'-');
    
    BSTree_Destroy(tree);
    
    return 0;
}