数据结构源码笔记（C语言）：二叉排序树的基本操作算法_#include <stdio.h> #include <malloc.h> #define max-CSDN博客

本文链接：https://blog.csdn.net/cauchy7203/article/details/107828219

//二叉排序树的基本运算算法

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


#define MaxSize 100

typedef int KeyType;//关键码类型
typedef char InfoType;

typedef struct node//记录类型
{
	KeyType key;//关键字项
	InfoType  data;//其他数据域
	struct node *lchild,*rchild;//左右孩子指针
}BSTNode;

int path[MaxSize];//全局变量用于存储路径


void DispBST(BSTNode *b);

int InsertBST(BSTNode * &p,KeyType k)
{//在以*p为根结点的BST中插入一个关键字为k的结点
	if(p==NULL)
	{
		p=(BSTNode *)malloc(sizeof(BSTNode));
		p->key=k;p->lchild=p->rchild=NULL;
		return 1;
	}
	else if(k==p->key)
		return 0;
	else if(k<p->key)
		return InsertBST(p->lchild,k);//插入到*p的左子树中
	else 
		return InsertBST(p->rchild,k);//插入到*p的右子树中
}


BSTNode *CreateBST(KeyType A[],int n)
{
	BSTNode *bt=NULL;//初始时 BT为空树
	int i=0;
	while(i<n)
		if(InsertBST(bt,A[i])==1)//将A[i]插入到二叉树T中
		{
			printf("     第%d步，插入%d:",i+1,A[i]);
			DispBST(bt);printf("\n");
			i++;
		}
		return bt;//返回建立的二叉排序树的根指针
}


void Delete1(BSTNode *p,BSTNode * &r)
{
	BSTNode *q;
	if(r->rchild!=NULL)
		Delete1(p,r->rchild);//递归找最右下结点
	else//找到了最右下结点 *r
	{
		p->key=r->key;
		q=r;
		r=r->lchild;//将*r的双亲的右孩子结点改为*r的左孩子结点
		free(q);//释放原*r 的空间
	}
}


void Delete(BSTNode * &p)
{
	BSTNode *q;
	if(p->rchild==NULL)//*p结点没有右子树的情况
	{
		q=p;
		p=p->lchild;
		free(q);
	}
	else if(p->lchild==NULL)//*p结点没有左子树的情况
	{
		q=p;
		p=p->rchild;
		free(q);
	}
	else Delete1(p,p->lchild);//*p结点既有左子树又有右子树的情况
}

int DeleteBST(BSTNode * &bt,KeyType k)
{//在bt中删除关键字为k的结点
	if(bt==NULL)
		return 0;//空树，删除失败
	else
	{
		if(k<bt->key)
			return DeleteBST(bt->lchild,k);//在左子树中删除关键字为k的结点
		else if(k>bt->key)
			return DeleteBST(bt->rchild,k);//在右子树中删除关键字为k 的结点
		else //k=bt->key的情况
		{
			Delete(bt);//调用Delete(bt)删除*bt结点
			return 1;
		}
	}
}

void SearchBST1(BSTNode *bt,KeyType k,KeyType path[],int i)
{//以非递归方式输出从根结点到查找到的结点的路径
	int j;
	if(bt==NULL)
		return;
	else if(k==bt->key)//找到了结点
	{
		path[i+1]=bt->key;//输出其路径
		for(j=0;j<=i+1;j++)
			printf("%3d",path[j]);
		printf("\n");
	}
	else
	{
		path[i+1]=bt->key;
		if(k<bt->key)
			SearchBST1(bt->lchild,k,path,i+1);//在左子树中递归查找
		else
			SearchBST1(bt->rchild,k,path,i+1);//在右子树中递归查找
	}
}



int SearchBST2(BSTNode *bt,KeyType k)
{//以递归方式输出从根结点到查找到的结点路径
	if(bt==NULL)
		return 0;
	else if(k==bt->key)
	{
		printf("%3d",bt->key);
		return 1;
	}
	else if(k<bt->key)
		SearchBST2(bt->lchild,k);//在左子树中递归查找
	else
		SearchBST2(bt->rchild,k);//在右子树中递归查找
	printf("%3d",bt->key);	
}

void DispBST(BSTNode *bt)
{//以括号表示法输出二叉排序树
	if(bt!=NULL)
	{
		printf("%d",bt->key);
		if(bt->lchild!=NULL||bt->rchild!=NULL)
		{
			printf("(");
			DispBST(bt->lchild);
			if(bt->rchild!=NULL)
				printf(",");
			DispBST(bt->rchild);
			printf(")");
		}
	}
}


KeyType predt=-32767;//predt为全局变量，保存当前结点中序前趋的值，初值为负无穷

int JudgeBST(BSTNode *bt)
{
	int b1,b2;
	if(bt==NULL)
		return 1;
	else
	{
		b1=JudgeBST(bt->lchild);
		if(b1==0||predt>=bt->key)
		0;
		predt=bt->key;
		b2=JudgeBST(bt->rchild);
		return b2;
	}
}


int  main()
{
	BSTNode *bt;
	KeyType k=7;
	int a[]={4,9,0,1,8,6,3,5,2,7},n=10;
	printf("创建一棵BST树:");
	printf("\n");
	bt=CreateBST(a,n);
	printf("\nBST:");DispBST(bt);printf("\n");
	printf("bt %s\n",(JudgeBST(bt)?"是一棵BST":"不是一棵BST"));
	printf("\n");
	printf("查找%d关键字（递归）:",k); SearchBST1(bt,k,path,-1);
	printf("查找%d关键字（非递归）:",k); SearchBST2(bt,k);
	printf("\n\n删除操作:\n"); 

	printf("   原BST:"); DispBST(bt);	printf("\n");
	
	printf("   删除结点4:"); 
	DeleteBST(bt,4);
	DispBST(bt);
	printf("\n"); 
    printf("   删除结点5:"); 
	DeleteBST(bt,5);
	DispBST(bt);
	printf("\n\n"); 
	return 0;
}