#include <stdio.h>
　　 #include <stdlib.h>
　　 #define STACK_MAX_SIZE 30
　　 #define QUEUE_MAX_SIZE 30
　　 #ifndef elemType
　　 typedef char elemType;
　　 #endif
　　 /************************************************************************/
　　 /*　　　　　　　　　　　以下是关于二叉树操作的11个简单算法　　　　　　　 */
　　 /************************************************************************/
　　 struct BTreeNode{
　　 elemType data;
　　 struct BTreeNode *left;
　　 struct BTreeNode *right;
　　 };
　　 /* 1.初始化二叉树 */
　　 void initBTree(struct BTreeNode* *bt)
　　 {
　　 *bt = NULL;
　　 return;
　　 }
　　 /* 2.建立二叉树(根据a所指向的二叉树广义表字符串建立) */
　　 void createBTree(struct BTreeNode* *bt, char *a)
　　 {
　　 struct BTreeNode *p;
　　 struct BTreeNode *s[STACK_MAX_SIZE];/* 定义s数组为存储根结点指针的栈使用 */
　　 int top = -1;/* 定义top作为s栈的栈顶指针，初值为-1,表示空栈 */
　　 int k;/* 用k作为处理结点的左子树和右子树，k = 1处理左子树，k = 2处理右子树 */
　　 int i = 0;/* 用i扫描数组a中存储的二叉树广义表字符串，初值为0 */
　　 *bt = NULL;/* 把树根指针置为空，即从空树开始建立二叉树 */
　　 /* 每循环一次处理一个字符，直到扫描到字符串结束符为止 */
　　 while(a[i] != ''){
　　 switch(a[i]){
　　 case ' ':
　　 break;　/* 对空格不作任何处理 */
　　 case '(':
　　 if(top == STACK_MAX_SIZE - 1){
　　 printf("栈空间太小！ ");
　　 exit(1);
　　 }
　　 top++;
　　 s[top] = p;
　　 k = 1;
　　 break;
　　 case ')':
　　 if(top == -1){
　　 printf("二叉树广义表字符串错误! ");
　　 exit(1);
　　 }
　　 top--;
　　 break;
　　 case ',':
　　 k = 2;
　　 break;
　　 default:
　　 p = malloc(sizeof(struct BTreeNode));
　　 p->data = a[i];
　　 p->left = p->right = NULL;
　　 if(*bt == NULL){
　　 *bt = p;
　　 }else{
　　 if( k == 1){
　　 s[top]->left = p;
　　 }else{
　　 s[top]->right = p;
　　 }
　　 }
　　 }
　　 i++;　/* 为扫描下一个字符修改i值 */
　　 }
　　 return;
　　 }
　　 /* 3.检查二叉树是否为空，为空则返回1,否则返回0 */
　　 int emptyBTree(struct BTreeNode *bt)
　　 {
　　 if(bt == NULL){
　　 return 1;
　　 }else{
　　 return 0;
　　 }
　　 }
　　 /* 4.求二叉树深度 */
　　 int BTreeDepth(struct BTreeNode *bt)
　　 {
　　 if(bt == NULL){
　　 return 0;　/* 对于空树，返回0结束递归 */
　　 }else{
　　 int dep1 = BTreeDepth(bt->left);　/* 计算左子树的深度 */
　　 int dep2 = BTreeDepth(bt->right);　/* 计算右子树的深度 */
　　 if(dep1 > dep2){
　　 return dep1 + 1;
　　 }else{
　　 return dep2 + 1;
　　 }
　　 }
　　 }
　　 /* 5.从二叉树中查找值为x的结点，若存在则返回元素存储位置，否则返回空值 */
　　 elemType *findBTree(struct BTreeNode *bt, elemType x)
　　 {
　　 if(bt == NULL){
　　 return NULL;
　　 }else{
　　 if(bt->data == x){
　　 return &(bt->data);
　　 }else{/* 分别向左右子树递归查找 */
　　 elemType *p;
　　 if(p = findBTree(bt->left, x)){
　　 return p;
　　 }
　　 if(p = findBTree(bt->right, x)){
　　 return p;
　　 }
　　 return NULL;
　　 }
　　 }
　　 }
　　 /* 6.输出二叉树(前序遍历) */
　　 void printBTree(struct BTreeNode *bt)
　　 {
　　 /* 树为空时结束递归，否则执行如下操作 */
　　 if(bt != NULL){
　　 printf("%c", bt->data);　/* 输出根结点的值 */
　　 if(bt->left != NULL || bt->right != NULL){
　　 printf("(");
　　 printBTree(bt->left);
　　 if(bt->right != NULL){
　　 printf(",");
　　 }
　　 printBTree(bt->right);
　　 printf(")");
　　 }　
　　 }
　　 return;
　　 }
　　 /* 7.清除二叉树，使之变为一棵空树 */
　　 void clearBTree(struct BTreeNode* *bt)
　　 {
　　 if(*bt != NULL){
　　 clearBTree(&((*bt)->left));
　　 clearBTree(&((*bt)->right));
　　 free(*bt);
　　 *bt = NULL;
　　 }
　　 return;
　　 }
　　 /* 8.前序遍历 */
　　 void preOrder(struct BTreeNode *bt)
　　 {
　　 if(bt != NULL){
　　 printf("%c ", bt->data);　/* 访问根结点 */
　　 preOrder(bt->left);　　/* 前序遍历左子树 */
　　 preOrder(bt->right);　/* 前序遍历右子树 */
　　 }
　　 return;
　　 }
　　 /* 9.前序遍历 */
　　 void inOrder(struct BTreeNode *bt)
　　 {
　　 if(bt != NULL){
　　 inOrder(bt->left);　　/* 中序遍历左子树 */
　　 printf("%c ", bt->data);　/* 访问根结点 */
　　 inOrder(bt->right);　　/* 中序遍历右子树 */
　　 }
　　 return;
　　 }
　　 /* 10.后序遍历 */
　　 void postOrder(struct BTreeNode *bt)
　　 {
　　 if(bt != NULL){
　　 postOrder(bt->left);　/* 后序遍历左子树 */
　　 postOrder(bt->right);　/* 后序遍历右子树 */
　　 printf("%c ", bt->data);　/* 访问根结点 */
　　 }
　　 return;
　　 }
　　 /* 11.按层遍历 */
　　 void levelOrder(struct BTreeNode *bt)
　　 {
　　 struct BTreeNode *p;
　　 struct BTreeNode *q[QUEUE_MAX_SIZE];
　　 int front = 0, rear = 0;
　　 /* 将树根指针进队 */
　　 if(bt != NULL){
　　 rear = (rear + 1) % QUEUE_MAX_SIZE;
　　 q[rear] = bt;
　　 }
　　 while(front != rear){　/* 队列非空 */
　　 front = (front + 1) % QUEUE_MAX_SIZE; /* 使队首指针指向队首元素 */
　　 p = q[front];
　　 printf("%c ", p->data);
　　 /* 若结点存在左孩子，则左孩子结点指针进队 */
　　 if(p->left != NULL){
　　 rear = (rear + 1) % QUEUE_MAX_SIZE;
　　 q[rear] = p->left;
　　 }
　　 /* 若结点存在右孩子，则右孩子结点指针进队 */
　　 if(p->right != NULL){
　　 rear = (rear + 1) % QUEUE_MAX_SIZE;
　　 q[rear] = p->right;
　　 }
　　 }
　　 return;
　　 }
　　 /************************************************************************/
　　 /*
　　 int main(int argc, char *argv[])
　　 {
　　 struct BTreeNode *bt;/* 指向二叉树根结点的指针 */
　　 char *b;　　/* 用于存入二叉树广义表的字符串 */
　　 elemType x, *px;
　　 initBTree(&bt);
　　 printf("输入二叉树广义表的字符串： ");
　　 /* scanf("%s", b); */
　　 b = "a(b(c), d(e(f, g), h(, i)))";
　　 createBTree(&bt, b);
　　 if(bt != NULL)
　　 printf(" %c ", bt->data);
　　 printf("以广义表的形式输出： ");
　　 printBTree(bt);　/* 以广义表的形式输出二叉树 */
　　 printf(" ");
　　 printf("前序：");　/* 前序遍历 */
　　 preOrder(bt);
　　 printf(" ");
　　 printf("中序：");　/* 中序遍历 */
　　 inOrder(bt);
　　 printf(" ");
　　 printf("后序：");　/* 后序遍历 */
　　 postOrder(bt);
　　 printf(" ");
　　 printf("按层：");　/* 按层遍历 */
　　 levelOrder(bt);
　　 printf(" ");
　　 /* 从二叉树中查找一个元素结点 */
　　 printf("输入一个待查找的字符： ");
　　 scanf(" %c", &x);　/* 格式串中的空格跳过空白字符 */
　　 px = findBTree(bt, x);
　　 if(px){
　　 printf("查找成功：%c ", *px);
　　 }else{
　　 printf("查找失败！ ");
　　 }
　　 printf("二叉树的深度为：");
　　 printf("%d ", BTreeDepth(bt));
　　 clearBTree(&bt);
　　 return 0;
　　 }
　　 */
#include<stdio.h>
　　 #defineQUEUE_MAX_SIZE20
　　 #defineSTACK_MAX_SIZE10
　　 typedefintelemType;
　　 #include"BT.c"
　　 /************************************************************************/
　　 /*　　　　　　　　　　以下是关于二叉搜索树操作的4个简单算法　　　　　　　*/
　　 /************************************************************************/
　　 /*1.查找*/
　　 /*递归算法*/
　　 elemType*findBSTree1(structBTreeNode*bst,elemTypex)
　　 {
　　 /*树为空则返回NULL*/
　　 if(bst==NULL){
　　 returnNULL;
　　 }else{
　　 if(x==bst->data){
　　 return&(bst->data);
　　 }else{
　　 if(x<bst->data){　　/*向左子树查找并直接返回*/
　　 returnfindBSTree1(bst->left,x);
　　 }else{　　　　/*向右子树查找并直接返回*/
　　 returnfindBSTree1(bst->right,x);
　　 }
　　 }
　　 }
　　 }
　　 /*非递归算法*/
　　 elemType*findBSTree2(structBTreeNode*bst,elemTypex)
　　 {
　　 while(bst!=NULL){
　　 if(x==bst->data){
　　 return&(bst->data);
　　 }elseif(x<bst->data){
　　 bst=bst->left;
　　 }else{
　　 bst=bst->right;
　　 }
　　 }
　　 returnNULL;
　　 }
　　 /*2.插入*/
　　 /*递归算法*/
　　 voidinsertBSTree1(structBTreeNode**bst,elemTypex)
　　 {
　　 /*新建一个根结点*/
　　 if(*bst==NULL){
　　 structBTreeNode*p=(structBTreeNode*)malloc(sizeof(structBTreeNode));
　　 p->data=x;
　　 p->left=p->right=NULL;
　　 *bst=p;
　　 return;
　　 }elseif(x<(*bst)->data){　　　　/*向左子树完成插入运算*/
　　 insertBSTree1(&((*bst)->left),x);
　　 }else{　　　　/*向右子树完成插入运算*/
　　 insertBSTree1(&((*bst)->right),x);
　　 }
　　 }
　　 /*非递归算法*/
　　 voidinsertBSTree2(structBTreeNode**bst,elemTypex)
　　 {
　　 structBTreeNode*p;
　　 structBTreeNode*t=*bst,*parent=NULL;
　　 /*为待插入的元素查找插入位置*/
　　 while(t!=NULL){
　　 parent=t;
　　 if(x<t->data){
　　 t=t->left;
　　 }else{
　　 t=t->right;
　　 }
　　 }
　　 /*建立值为x，左右指针域为空的新结点*/
　　 p=(structBTreeNode*)malloc(sizeof(structBTreeNode));
　　 p->data=x;
　　 p->left=p->right=NULL;
　　 /*将新结点链接到指针为空的位置*/
　　 if(parent==NULL){
　　 *bst=p;　　　　/*作为根结点插入*/
　　 }elseif(x<parent->data){　　　　/*链接到左指针域*/
　　 parent->left=p;
　　 }else{
　　 parent->right=p;
　　 }
　　 return;
　　 }
　　 /*3.建立*/
　　 voidcreateBSTree(structBTreeNode**bst,elemTypea[],intn)
　　 {
　　 inti;
　　 *bst=NULL;
　　 for(i=0;i<n;i++){
　　 insertBSTree1(bst,a[i]);
　　 }
　　 return;
　　 }
　　 /*4.删除值为x的结点，成功返回1,失败返回0*/
　　 intdeleteBSTree(structBTreeNode**bst,elemTypex)
　　 {
　　 structBTreeNode*temp=*bst;
　　 if(*bst==NULL){
　　 return0;
　　 }
　　 if(x<(*bst)->data){
　　 returndeleteBSTree(&((*bst)->left),x);　　　　/*向左子树递归*/
　　 }
　　 if(x>(*bst)->data){
　　 returndeleteBSTree(&((*bst)->right),x);　　/*向右子树递归*/
　　 }
　　 /*待删除的元素等于树根结点值且左子树为空，将右子树作为整个树并返回1*/
　　 if((*bst)->left==NULL){
　　 *bst=(*bst)->right;
　　 free(temp);
　　 return1;
　　 }
　　 /*待删除的元素等于树根结点值且右子树为空，将左子树作为整个树并返回1*/
　　 if((*bst)->right==NULL){
　　 *bst=(*bst)->left;
　　 free(temp);
　　 return1;
　　 }else{
　　 /*中序前驱结点为空时，把左孩子结点值赋给树根结点，然后从左子树中删除根结点*/
　　 if((*bst)->left->right==NULL){
　　 (*bst)->data=(*bst)->left->data;
　　 returndeleteBSTree(&((*bst)->left),(*bst)->data);
　　 }else{　　/*定位到中序前驱结点，把该结点值赋给树根结点，然后从以中序前驱结点为根的
　　 树上删除根结点*/
　　 structBTreeNode*p1=*bst,*p2=p1->left;
　　 while(p2->right!=NULL){
　　 p1=p2;
　　 p2=p2->right;
　　 }
　　 (*bst)->data=p2->data;
　　 returndeleteBSTree(&(p1->right),p2->data);
　　 }
　　 }
　　 }
　　 /************************************************************************/
　　 intmain(intargc,char*argv[])
　　 {
　　 intx,*px;
　　 elemTypea[10]={30,50,20,40,25,70,54,23,80,92};
　　 structBTreeNode*bst=NULL;
　　 createBSTree(&bst,a,10);
　　 printf("建立的二叉搜索树的广义表形式为： ");
　　 printBTree(bst);
　　 printf(" ");
　　 printf("中序遍历： ");
　　 inOrder(bst);
　　 printf(" ");
　　 printf("输入待查找元素的值：");
　　 scanf("%d",&x);
　　 if(px=findBSTree1(bst,x)){
　　 printf("查找成功！得到的x为：%d ",*px);
　　 }else{
　　 printf("查找失败！ ");
　　 }
　　 printf("输入待插入的元素值：");
　　 scanf("%d",&x);
　　 insertBSTree1(&bst,x);
　　 printf("输入待删除元素值：");
　　 scanf("%d",&x);
　　 if(deleteBSTree(&bst,x)){
　　 printf("1 ");
　　 }else{
　　 printf("0 ");
　　 }
　　 printf("进行相应操作后的中序遍历为： ");
　　 inOrder(bst);
　　 printf(" ");
　　 printf("操作后的二叉搜索树的广义表的形式为： ");
　　 printBTree(bst);
　　 printf(" ");
　　 clearBTree(&bst);
　　 return0;
　　 }