二叉排序树（草稿）

代码存在bug 运行不起来  

三个版本

1

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

typedef struct//关键字结构体 
{
	int key;//关键字项 
	int otherinfo;//其他数据域 
}ElemType;//每个节点的数据域的类型 
typedef struct BSTNode//二叉树结构体 
{
	ElemType data;//每个节点的数据域包括关键字项和其他数据项 
	struct BSTNode *lchild,*rchild;//左右孩子指针 
}BSTNode,*BSTree;

void InitTree(BSTree &T)//初始化二叉排序树 
{
	T = (BSTNode*)malloc(sizeof(BSTNode));//创建一个头结点 
	T->data.key = NULL;
	T->lchild = T->rchild = NULL;//头结点指针域和数据域都NULL 
}

void InsertTree(BSTree &T,int e)//二叉排序树的插入 
{
	if(!T)//找到插入位置，递归结束 
	{
		BSTree S;
		S = (BSTNode *)malloc(sizeof(BSTNode));//创建一个结点
		S->data.key = e;//新结点的数据置为e 
		S->lchild = S->rchild = NULL;//新结点设置为叶子结点 
		T = S;//把新结点S接到已找到的插入位置 
	}
	else if(e<T->data.key)
		InsertTree(T->lchild,e);//将S插入左子树 
	else
		InsertTree(T->rchild,e);//将S插入右子树 
} 

void CreateTree(BSTree &T)//创建二叉排序树 
{
	int a;
	printf("请输入：");
	scanf("%d",&a);
	T->data.key = a;//将数据填入二叉排序树的根结点 
	while(1)//利用循环进行插入操作 
	{
		scanf("%d",&a);
		InsertTree(T,a);//将数据导入到二叉排序树T中 
		if(getchar()=='\n')//死循环结束条件 
			break;
	}
}

void InOrderTraverse(BSTree T)//遍历二叉树，中序遍历 
{
	if(T)//递归终止条件是T为NULL  
	{
		InOrderTraverse(T->lchild);//中序遍历左子树 
		printf("%d ",T->data);//输出打印根结点 
		InOrderTraverse(T->rchild);//中序遍历右子树 
	}
}

int SearchTree(BSTree T,int key)//二叉排序树的查找，这里的查找只能知道二叉树中有没有和key相等的值 
{
	if(T == NULL)//查找结束，且没有和key相等的值 
		return 0;
	else if(T->data.key==key)//查找结束，二叉树中有和key相等的值 
		return T->data.key;	
	else if(key<T->data.key)
		return SearchTree(T->lchild,key);//递归左子树 
	else
		return SearchTree(T->rchild,key);//递归右子树 
}

void DeleteTree(BSTree &T,int key)//从二叉排序树T中删除关键字等于key的结点  ,这里分三种情况进行讨论 
{
	BSTree f,p;
	p = T;
	f = NULL;//初始化 
	while(p)//利用循环找到关键字等于key的结点
	{
		if(p->data.key == key)//找到关键字等于key的结点，并跳出循环 
			break;
		f = p;//结点f一直为结点p的双亲结点 
		if(p->data.key>key)
			p = p->lchild;//在p的左子树中继续查找 
		else
			p = p->rchild;//在p的右子树中继续查找 
	}
	if(p == NULL)//找不到被删除的结点则返回 
	{
		printf("没有找到要删除的值！\n");
		return ; 
	}
	/*第一种情况：被删除的结点（包含被删除的结点是根结点）的左右子树都存在，在其左子树上找中序最后一个结点填补*/ 
	BSTree q,s;
	if((p->lchild)&&(p->rchild))//被删结点p左右子树均不空 
	{
		q = p;
		s = p->rchild;
		while(s->rchild)//在结点p的左子树中继续查找其前驱结点,即最右下结点 
		{
			q = s;
			s = s->rchild;//向右到尽头 
		}
		p->data = s->data;//结点s中的数据顶替被删结点p中的 
		if(q != p)//重新连接结点q的右子树 
			q->rchild = s->lchild;
		else//重新连接结点q的左子树 
			q->lchild = s->lchild;
		free(s);//释放s 
		return ;//结束该函数 
	}
	/*第二种情况：被删结点(包含根结点)缺右子树，且包含左右子树都缺（即叶子结点）；缺右子树用左孩子填补*/
	else if(p->rchild == NULL)//被删结点缺右子树 
	{
		if(f)//判断被删结点是否为根结点，若是则f==NULL 
		{
			if(f->lchild == p)//判断被删结点的双亲结点的左孩子是否为p 
			{
				f->lchild = p->lchild;
				p->lchild = NULL;
			}
			else//被删结点的双亲结点的右孩子为p 
			{
				f->rchild = p->lchild;
				p->lchild = NULL;
			}
			free(p);//释放结点p 
			return ;//结束该函数 
		}
		else//被删结点为根结点 
		{
			f = p;
			p = p->lchild;
			f->lchild = NULL;
			free(f);//释放根结点 
			T = p;//根结点移位 
			return ;
		}
	}
	/*第三种情况：被删结点(包含根结点)缺左子树，且包含左右子树都缺（即叶子结点）；缺左子树用右孩子填补*/
	else	//	else if(p->lchild == NULL)//被删结点缺左子树 
	{
		if(f)//判断被删结点是否为根结点，若是则f==NULL 
		{
			if(f->lchild == p)//判断被删结点的双亲结点的左孩子是否为p 
			{
				f->lchild = p->rchild;
				p->rchild = NULL;
			}
			else//被删结点的双亲结点的右孩子为p 
			{
				f->rchild = p->rchild;
				p->rchild = NULL;
			}
			free(p);//释放结点p
			return ;//结束该函数 
		}
		else//被删结点为根结点 
		{
			f = p;
			p = p->rchild;
			f->lchild = NULL;
			free(f);//释放根结点 
			T = p;//根结点移位 
			return ;//结束该函数 
		}
	}
}

int main()
{
	BSTree T;
	InitTree(T);//初始化二叉排序树 
	CreateTree(T);//创建二叉排序树 
	InOrderTraverse(T);//打印 
	printf("\n");
	if(SearchTree(T,16))//判断二叉排序树中是否存在关键字与key相等的结点 ，其中的16是测试值，可换变量 
		printf("存在：%d\n",SearchTree(T,16));
	else
		printf("不存在！\n"); 
	DeleteTree(T,16);//二叉排序树的删除，删除与key相等的结点，其中的数值为测试值 
	printf("删除之后："); 
	InOrderTraverse(T);//再次打印结果，验证删除是否成功 
	free(T);
	return 0;
}

2

#include "stdio.h"
#include "stdlib.h"
#include "string.h"



typedef struct node
{
	int data;
	struct node *lchild,*rchild;
}node,*Node;

int searchBST(Node T,int data,Node f,Node *p);
int insertBST(Node *T,int data);
int deleteBST(Node *T,int data);
int deleteNode(Node *p);
int printfBST(Node T);

int searchBST(Node T,int data,Node f,Node *p)
{
	if(!T)
	{	
		*p=f;
		return 0;
	}
	else if(data==T->data)
	{
		*p=T;
		return 1;
	}
	else if(T->data<data)
	{
		return searchBST(T->rchild,data,T,p);	
	}
	else if(T->data>data)
	{
		return searchBST(T->lchild,data,T,p);	
	}
}

int insertBST(Node *T,int data)
{
	Node p,s;
	
	if(!searchBST(*T,data,NULL,&p))
	{
			
		s=(Node)malloc(sizeof(node));
		s->data=data;
		s->rchild=s->lchild=NULL;
		
		if(!p)
		{
			*T=s;	
		}
		else if(p->data>data)
		{
			p->lchild=s;
		}
		else
		{
			p->rchild=s;
		}
		return 1;
	}
	else
	{
		return 0;
	}
}

int deleteBST(Node *T,int data)
{
	if(!*T)
	{
		return 0;
	}
	else{
		if(data == (*T)->data)
		{
			return deleteNode(T);
		}
		else if(data<(*T)->data)
		{
			return deleteBST(&(*T)->lchild,data);
		} 
		else
		{
			return deleteBST(&(*T)->rchild,data);
		}
	}
}

int deleteNode(Node *p)
{
	Node q,s;
	
	if( (*p)->rchild==NULL )
	{
		q=*p;
		*p=(*p)->lchild;
		free(q);
	}
	else if( (*p)->lchild==NULL)
	{
		q=*p;
		*p=(*p)->rchild;
		free(q);
	}
	else
	{
		q=*p;
		s=(*p)->lchild;
		
		while(s->rchild)
		{
			q=s;
			s=s->rchild;
		}
		
		(*p)->data=s->data;
		
		if(q!=*p)
		{
			q->rchild=s->lchild;
		} 
		else{
			q->lchild=s->lchild;
		}
		free(s);
	}
	return 1;
}

int printfBST(Node T)
{
	if(T)
	{
	return printfBST(T->lchild);
	printf("%d ",T->data);
	return printfBST(T->rchild);
	}
	
}

int main()
{
	Node T;

	insertBST(&T,5);
	insertBST(&T,1);
	insertBST(&T,6);
	insertBST(&T,8);
	
	printfBST(T);
}

3

#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define ElemType int
#define  KeyType int
/* 二叉排序树的节点结构定义 */
typedef struct BiTNode
{
    int data;
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;
//二叉排序树查找算法
int SearchBST(BiTree T,KeyType key,BiTree f,BiTree *p){		// T根节点   key查找的值   f父节点  *p指向当前找到的地方节点
    //如果 T 指针为空，说明查找失败，令 p 指针指向查找过程中最后一个叶子结点，并返回查找失败的信息
    if (!T){		
        *p=f;
        return FALSE;
    }
    //如果相等，令 p 指针指向该关键字，并返回查找成功信息
    else if(key==T->data){
        *p=T;
        return TRUE;
    }
    //如果 key 值比 T 根结点的值小，则查找其左子树；反之，查找其右子树
    else if(key<T->data){
        return SearchBST(T->lchild,key,T,p);		//如果查找的值比当前节点小则递归找左孩子
    }else{
        return SearchBST(T->rchild,key,T,p);		//如果查找的值比当前节点大则递归找右孩子
    }
}

int InsertBST(BiTree *T,ElemType e){			//插入节点  *T根节点  e插入的值
    BiTree p=NULL;								//创建结构体指针用来定位查找到最后的地方，方便插入
    //如果查找不成功，需做插入操作
    if (!SearchBST((*T), e,NULL,&p)) {			//如果找不到则可以插入
        //初始化插入结点
        BiTree s=(BiTree)malloc(sizeof(BiTree));		//创建结构体指针并分配内存
        s->data=e;										//数据等于e
        s->lchild=s->rchild=NULL;						//左右孩子初始化为NULL
        //如果 p 为NULL，说明该二叉排序树为空树，此时插入的结点为整棵树的根结点
        if (!p) {
            *T=s;
        }
        //如果 p 不为 NULL，则 p 指向的为查找失败的最后一个叶子结点，只需要通过比较 p 和 e 的值确定 s 到底是 p 的左孩子还是右孩子
        else if(e < p->data){			
        }else{
            p->rchild=s;
        }
        return TRUE;
    }
    //如果查找成功，不需要做插入操作，插入失败
    return FALSE;
}
//删除函数
int Delete(BiTree *p)
{
    BiTree q, s;
    //情况 1，结点 p 本身为叶子结点，直接删除即可
    if(!(*p)->lchild && !(*p)->rchild){				//if节点p的左孩子和右孩子为空
        *p = NULL;
    }
    else if(!(*p)->lchild){ //左子树为空，只需用结点 p 的右子树根结点代替结点 p 即可；
        q = *p;
        *p = (*p)->rchild;
        free(q);
    }
    else if(!(*p)->rchild){//右子树为空，只需用结点 p 的左子树根结点代替结点 p 即可；
        q = *p;
        *p = (*p)->lchild;//这里不是指针 *p 指向左子树，而是将左子树存储的结点的地址赋值给指针变量 p
        free(q);
    }
    else{//左右子树均不为空，采用第 2 种方式
        q = *p;
        s = (*p)->lchild;
        //遍历，找到结点 p 的直接前驱
        while(s->rchild)
        {
            q = s;
            s = s->rchild;
        }
        //直接改变结点 p 的值
        (*p)->data = s->data;
        //判断结点 p 的左子树 s 是否有右子树，分为两种情况讨论
        if( q != *p ){
            q->rchild = s->lchild;//若有，则在删除直接前驱结点的同时，令前驱的左孩子结点改为 q 指向结点的孩子结点
        }else{
            q->lchild = s->lchild;//否则，直接将左子树上移即可
        }
        free(s);
    }
    return TRUE;
}
int DeleteBST(BiTree *T, int key)
{
    if( !(*T)){//不存在关键字等于key的数据元素
        return FALSE;
    }
    else
    {
        if( key == (*T)->data ){
            Delete(T);
            return TRUE;
        }
        else if( key < (*T)->data){
            //使用递归的方式
            return DeleteBST(&(*T)->lchild, key);
        }
        else{
            return DeleteBST(&(*T)->rchild, key);
        }
    }
}
void order(BiTree t)//中序输出
{
    if(t == NULL){
        return ;
    }
    order(t->lchild);
    printf("%d ", t->data);
    order(t->rchild);
}
int main()
{
    int i;
    int a[5] = {3,4,2,5,9};
    BiTree T = NULL;
    for( i = 0; i < 5; i++ ){
        InsertBST(&T, a[i]);
    }
    printf("中序遍历二叉排序树：\n");
    order(T);
    printf("\n");
    printf("删除3后，中序遍历二叉排序树：\n");
    DeleteBST(&T,3);
    order(T);
}