二叉搜索树的算法

//内含二叉搜索树的插入，递归插入，删除，删除最大结点，迭代搜索，递归搜素以及判断一颗树是否是二叉搜索树的算法
#include<stdio.h>
#include<stdlib.h>
typedef struct btnode {
	int key;
	char ccc;
	struct btnode* Lchild, * Rchild;
}BTNode;
typedef struct btree {
	struct btnode* Root;
}BTree;

BTNode* NewNode() {
	BTNode* p = (BTNode*)malloc(sizeof(BTNode));
	return p;
}
BTNode* NewNode2(int x,char ch) {
	BTNode* p = (BTNode*)malloc(sizeof(BTNode));
	p->key = x;
	p->ccc = ch;
	p->Lchild = NULL;
	p->Rchild = NULL;
	return p;
}
void CreateBT(BTree* bt) {
	bt->Root = NULL;
}
void MakeBT(BTree* bt, int x, char ch, BTree* lt, BTree* rt) {
	BTNode* p = NewNode();
	p->key = x;
	p->ccc = ch;
	p->Rchild = rt->Root;
	p->Lchild = lt->Root;
	lt->Root = rt->Root = NULL;
	bt->Root = p;
}
void BreakBT(BTree* bt, BTree* lt, BTree* rt) {
	BTNode* p = bt->Root;
	if (p) {
		lt->Root = p->Lchild;
		rt->Root = p->Rchild;
		bt->Root = NULL;
		free(p);
	}
}
int Size(BTNode* p) {
	int s, s1, s2;
	if (!p) {
		return 0;
	}
	else {
		s1 = Size(p->Lchild);
		s2 = Size(p->Rchild);
		s = s1 + s2 + 1;
		return s;
	}
}
int SizeofBT(BTree bt) {
	return Size(bt.Root);
}
int Depth(BTNode* p) {
	if (!p) {
		return 0;
	}
	else {
		return 1 + max(Depth(p->Lchild), Depth(p->Rchild));
	}
}
int DepthofBT(BTree bt) {
	return Depth(bt.Root);
}
int CountLeaf(BTNode* p, int count)
{
	if (p != NULL)
	{
		if (p->Lchild == NULL && p->Rchild == NULL) {
			count++;
		}
		count = CountLeaf(p->Lchild, count);
		count = CountLeaf(p->Rchild, count);
	}
	return count;
}
int NumberofLeaf(BTree bt, int count) {
	return CountLeaf(bt.Root, count);
}
void LevelOrd(BTree bt) {
	BTNode* p;
	BTNode* queue[256];
	int front = -1, rear = -1;
	p = bt.Root;
	rear++;
	queue[rear] = p;
	while (front != rear) {
		front++;
		p = queue[front];
		printf("%d_%c ", p->key,p->ccc);
		if (p->Lchild != NULL) {
			rear++;
			queue[rear] = p->Lchild;
		}
		if (p->Rchild != NULL) {
			rear++;
			queue[rear] = p->Rchild;
		}
	}
	printf("\n");
}
void Visit(BTNode* p) {
	printf("%d_%c ", p->key,p->ccc);
}
void PreOrd(void (*Visit)(BTNode* u), BTNode* t) {
	if (t) {
		(*Visit)(t);
		PreOrd(Visit, t->Lchild);
		PreOrd(Visit, t->Rchild);
	}
}
void InOrd(void (*Visit)(BTNode* u), BTNode* t) {
	if (t) {
		InOrd(Visit, t->Lchild);
		(*Visit)(t);
		InOrd(Visit, t->Rchild);
	}
}
void PostOrd(void (*Visit)(BTNode* u), BTNode* t) {
	if (t) {
		PostOrd(Visit, t->Lchild);
		PostOrd(Visit, t->Rchild);
		(*Visit)(t);
	}
}
void PreOrder(BTree* bt, void  (*Visit)(BTNode* u)) {
	PreOrd(Visit, bt->Root);
}
void InOrder(BTree* bt, void  (*Visit)(BTNode* u)) {
	InOrd(Visit, bt->Root);
}
void PostOrder(BTree* bt, void  (*Visit)(BTNode* u)) {
	PostOrd(Visit, bt->Root);
}
//二叉搜索树的递归算法
BTNode* Find(BTNode* p , int k) {
	if (!p) {
		return NULL;
	}
	if (k==p->key) {
		return p;
	}
	else if (k<p->key) {
		return Find(p->Lchild,k);
	}
	else {
		return Find(p->Rchild,k);
	}
}
//调用二叉搜索树的递归算法
void BtSearchDigui(BTree *bt, int k) {
	BTNode* p = Find(bt->Root, k);
	if (p) {
		printf("Find it!   %d_%c\n",p->key,p->ccc);
	}
	else {
		printf("no element!\n");
	}
}
//二叉搜索树的迭代算法
void BtSearchDiedai(BTree * bt, int k) {
	BTNode* p = bt->Root;
	while (p) {
		if (k<p->key) {
			p = p->Lchild;
		}
		else if (k>p->key) {
			p = p->Rchild;
		}
		else {
			printf("Find it! :   %d_%c\n",p->key,p->ccc);
			break;
		}
	}
	if (!p) {
		printf("no element!\n");
	}
}
//二叉搜索树的插入算法
void Insert(BTree * bt, int k,char ch) {
	BTNode* r, * p , * q;
	q = (BTNode*)malloc(sizeof(BTNode));
	p = bt->Root;
	while (p){
		q = p;
		if (k<p->key) {
			p = p->Lchild;
		}
		else if (k>p->key) {
			p = p->Rchild;
		}
		else {
			printf("Duplication! \n");
			return;
		}
	}
	r = NewNode2(k, ch);
	if (bt->Root) {
		if (k<q->key) {
			q->Lchild = r;
		}
		if(k>q->key){
			q->Rchild = r;
		}
	}
	else {
		bt->Root = r;
	}
}
//二叉搜索树的删除某一结点算法
void Remove(BTree* bt, int k) {
	BTNode* c, * r, * s, * p, * q;
	q = (BTNode*)malloc(sizeof(BTNode));
	p = bt->Root;
	while (p && p->key!=k) {
		q = p;
		if (k<p->key) {
			p = p->Lchild;
		}
		else {
			p = p->Rchild;
		}
	}
	if (!p) {
		printf("No Element with Key k!\n");
		return;
	}
	printf("find the elememt which you want to delete: %d_%c\n",p->key,p->ccc);
	if (p->Lchild&&p->Rchild) {
		s = p->Rchild;
		r = p;
		while (s->Lchild) {
			r = s;
			s = s->Lchild;
		}
		p->key = s->key;
		p->ccc = s->ccc;
		p = s;
		q = r;
	}
	if (p->Lchild) {
		c = p->Lchild;
	}
	else {
		c = p->Rchild;
	}
	if (p==bt->Root) {
		bt->Root = c;
	}
	else if (p==q->Lchild) {
		q->Lchild = c;
	}
	else {
		q->Rchild = c;
	}
	free(p);
	printf("Remove Succeeded!\n");
}
//判断一颗二叉树是否是二叉搜索树,  是从按层次遍历二叉树变种而来。按层次每到一个新节点，都要判断该结点的的左孩子是否比该结点值小，右孩子是否比该节点大。如果有一个为false，那么就判断不是二叉搜索树
int BinaryTreeJudge(BTree* bt) {
	BTNode* p;
	BTNode* queue[256];
	int front = -1, rear = -1;
	p = bt->Root;
	rear++;
	queue[rear] = p;
	while (front != rear) {
		front++;
		p = queue[front];
		printf("%d ", p->key);
		if (p->Lchild != NULL) {
			rear++;
			if (p->Lchild->key >= p->key) {
				printf("此树不是二叉搜索树！\n");
				return 0;
			}
			queue[rear] = p->Lchild;
		}
		if (p->Rchild != NULL) {
			rear++;
			if (p->Rchild->key <= p->key) {
				printf("此树不是二叉搜索树！\n");
				return 0;
			}
			queue[rear] = p->Rchild;
		}
	}
	if (front == rear) {
		printf("此树是二叉搜索树！\n");
	}
	return 1;
}
//删除一颗二叉搜索树的最大元素
void RemoveTheMax(BTree* bt) {
	BTNode * p, * q;
	q = (BTNode*)malloc(sizeof(BTNode));
	p = bt->Root;
	if (p==NULL) {
		printf("树为空，无法删除最大元素\n");
	}
	else {
		if (p->Rchild==NULL){
			if (p->Lchild == NULL) {
				printf("该树只含有一个元素，已删除，树已为空！\n");
				bt->Root = NULL;
				free(p);
				return;
			}
			else {
				bt->Root = p->Lchild;
				free(p);
				return;
			}
		}
		while (p->Rchild != NULL) {
			q = p;
			p = p->Rchild;
		}
		q->Rchild = p->Lchild;
		free(p);
	}
}
//递归算法在一棵二叉搜索树上插入一个元素
BTNode* RecursionInsert(BTNode* p, BTNode* q, int k) {
	if (!p) {
		return q;
	}
	q = p;
	if (k == p->key) {
		return NULL;
	}
	else if (k < p->key) {
		return RecursionInsert(p->Lchild, q, k);
	}
	else {
		return RecursionInsert(p->Rchild, q, k);
	}
}
//调用递归算法在一棵二叉搜索树上插入一个元素
void BtRecursionInsert(BTree* bt, int k, char ch) {
	BTNode* p, * q;
	q = (BTNode*)malloc(sizeof(BTNode));
	p = NewNode2(k, ch);
	if (bt->Root == NULL) {
		bt->Root = p;
	}
	else {
		q = RecursionInsert(bt->Root, q, k);
		if (q) {
			if (k < q->key) {
				q->Lchild = p;
			}
			if (k > q->key) {
				q->Rchild = p;
			}
		}
		else {
			printf("元素重复，无法插入！\n");
		}
	}
}
void main() {
	BTree* z;
	z = (BTree*)malloc(sizeof(BTree));
	CreateBT(z);
	Insert(z, 28, 'A');
	Insert(z, 21, 'B');
	Insert(z, 25, 'D');
	Insert(z, 23, 'G');
	Insert(z, 36, 'C');
	Insert(z, 33, 'E');
	Insert(z, 35, 'H');
	Insert(z, 34, 'I');
	Insert(z, 43, 'F');
	printf("%d\n",DepthofBT(*z));
	Remove(z, 23);
	LevelOrd(*z);
	InOrder(z, Visit);
	BinaryTreeJudge(z);
	//Insert(z, 56, 'D');   //从无到有构造二叉搜索树时，根节点一定要最先创建！
	//Insert(z, 44, 'A');   //如果要创建特定的二叉搜索树，各个节点的插入顺序是必不可少的！
	//Insert(z, 24, 'C');
	//Insert(z, 50, 'B');
	//Insert(z, 49, 'H');
	//Insert(z, 52, 'E');
	//Insert(z, 55, 'G');
	//Insert(z, 56, 'I');
	//LevelOrd(*z);
	//InOrder(z, Visit);
	//printf("\n");
	//BtSearchDigui(z, 55);
	//BtSearchDiedai(z, 55);
	/*Remove(z, 76);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
	Remove(z, 25);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
	Remove(z, 45);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");*/
	RemoveTheMax(z);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
}