二叉搜索树操作集，C语言实现，数据结构

二叉搜索树操作集，C语言实现，数据结构
代码AC

创建建二叉搜索树

//创建建二叉搜索树
BinTree CreateBST(BinTree BST){
	ElementType X;
    printf("\n请输入二叉树结点(用空格隔开各结点，以-999结束输入)(不必按顺序，将会自动依据结点数据的大小建立二叉搜索树):\n");
    while (1){
    	scanf("%d",&X);
    	if (X == -999) break;
    	BST = Insert(BST, X);
	}
	return BST;
}

遍历二叉搜索树

//中序遍历
void InorderTraversal( BinTree BST ) {
	if( BST ) {
		InorderTraversal( BST->Left );
		/* 此处假设对BST结点的访问就是打印数据 */
		printf("%d ", BST->Data); /* 假设数据为整型 */
		InorderTraversal( BST->Right );
	}
}

//先序遍历
void PreorderTraversal( BinTree BST ) {
	if( BST ) {
		printf("%d ", BST->Data );
		PreorderTraversal( BST->Left );
		PreorderTraversal( BST->Right );
	}
}

//后序遍历
void PostorderTraversal( BinTree BST ) {
	if( BST ) {
		PostorderTraversal( BST->Left );
		PostorderTraversal( BST->Right );
		printf("%d ", BST->Data);
	}
}

//层序遍历
void LevelorderTraversal ( BinTree *BST ) {
	int front,rear;
	TNode *que[MaxSize];  //定义一个循环队列，用来记录将要访问的层次上的结点
	front = rear = 0;
	TNode *q;
	if (BST != NULL) {
		rear = (rear + 1)%MaxSize;
		que[rear] = BST;     //根节点入队
		while (front != rear) {
			front = (front + 1)%MaxSize;
			q = que[front];  //队头结点出队
			printf("%d ",q->Data);   //访问队头结点
			if (q->Left != NULL) {		//如果左子树不空，则左子树的根节点入队
				rear = (rear + 1)%MaxSize;
				que[rear] = q->Left;
			}
			if (q->Right != NULL) {		//如果右子树不空，则右子树的根节点入队
				rear = (rear + 1)%MaxSize;
				que[rear] = q->Right;
			}
		}
	}
}

插入元素

//插入元素
BinTree Insert( BinTree BST, ElementType X ) {
	if( !BST ) { /* 若原树为空，生成并返回一个结点的二叉搜索树 */
		BST = (BinTree)malloc(sizeof(struct TNode));
		BST->Data = X;
		BST->Left = BST->Right = NULL;
	} else { /* 开始找要插入元素的位置 */
		if( X < BST->Data )
			BST->Left = Insert( BST->Left, X );   /*递归插入左子树*/
		else  if( X > BST->Data )
			BST->Right = Insert( BST->Right, X ); /*递归插入右子树*/
		/* else X已经存在，什么都不做 */
	}
	return BST;
}

删除元素

//删除元素
BinTree Delete( BinTree BST, ElementType X ) {
	BinTree Tmp;
	if( !BST )
		printf("要删除的元素未找到");
	else {
		if( X < BST->Data )
			BST->Left = Delete( BST->Left, X );   /* 从左子树递归删除 */
		else if( X > BST->Data )
			BST->Right = Delete( BST->Right, X ); /* 从右子树递归删除 */
		else { /* BST就是要删除的结点 */
			/* 如果被删除结点有左右两个子结点 */
			if( BST->Left && BST->Right ) {
				/* 从右子树中找最小的元素填充删除结点 */
				Tmp = FindMin( BST->Right );
				BST->Data = Tmp->Data;
				/* 从右子树中删除最小元素 */
				BST->Right = Delete( BST->Right, BST->Data );
			} else { /* 被删除结点有一个或无子结点 */
				Tmp = BST;
				if( !BST->Left )       /* 只有右孩子或无子结点 */
					BST = BST->Right;
				else                   /* 只有左孩子 */
					BST = BST->Left;
				free( Tmp );
			}
		}
	}
	return BST;
}

查找元素

//查找元素
BinTree Find( BinTree BST, ElementType X ) {
	if( !BST )	return NULL;
	else if( X == BST->Data ) return BST;
	else if( X > BST->Data ) return Find( BST->Right, X );
	else if( X < BST->Data ) return Find( BST->Left, X );
	return NULL;
}

递归查找最小元素

//递归查找最小元素
BinTree FindMin( BinTree BST ) {
	if( !BST ) return NULL;
	else if( !BST->Left ) return BST;
	else if( BST->Left ) FindMin( BST->Left );
}

非递归查找最大元素

//非递归查找最大元素
BinTree FindMax( BinTree BST ) {
	if( BST )
		while( BST->Right ) BST = BST->Right;
	return BST;
}

求结点个数和叶子结点个数

//求结点个数
int Node_num(BinTree BST) {
	int left,right,n;
	if(!BST) {
		n = 0;
		return n;
	} else if(!BST->Left && !BST->Right) {
		n = 1;
		return n;
	} else {
		left = Node_num(BST->Left);
		right = Node_num(BST->Right);
		n = left + right + 1;
		return n;
	}
}

//求叶子结点个数
int Leaf_num(BinTree BST) {
	int l,r;
	if (!BST) return 0;
	if (!BST->Left && !BST->Right) return 1;
	else {
		l = Leaf_num(BST->Left);
		r = Leaf_num(BST->Right);
		return l + r;
	}
}

判断是否为满二叉树

bool IsFull_Bitree(BinTree BST) {
	if (!BST) return false;
	if ( Node_num(BST) == pow(2,GetHeight(BST)) - 1) return true;
	else return false;
}

测试运行结果