数据结构:二叉排序树
作者:互联网
听了国嵌唐老师的课,用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;
}
运行效果:
标签:排序,NULL,int,BSTreeNode,tree,ret,二叉,BSTree,数据结构 来源: https://blog.csdn.net/wl1780852311/article/details/101373031