数据结构课程设计-二叉树操作系统

二叉树基本操作(头文件)：
//二叉树的创建
void CreateBiTree(BTNode **root)                ///二级指针作为函数参数
{                                                               ///void CreateBiTree(BiTree &root)       //引用类型的参数
    char ch;                                   ///要插入的数据
    scanf("\n%c", &ch);                    ///cin>>ch;
    if(ch=='#')                                                 ///BiTree *CreateBiTree()         //返回结点指针类型
        *root = NULL;
    else
    {
        *root = (BTNode *)malloc(sizeof(BTNode));
        (*root)->data = ch;
        CreateBiTree(&((*root)->lchild));
        CreateBiTree(&((*root)->rchild));
    }
}

void Pre_order_Creat_Btree(BTree *root)    //仿先序遍历创建二叉树
{
	DataType c;
	if((c=getchar())=='#')
		*root=NULL;
	else
	{
		*root=(BTNode *)malloc(sizeof(BTNode));
		(*root)->data=c;   //别以为把这行代码换下位置就成了中、后序遍历创建方式,肯定是错误的
		Pre_order_Creat_Btree(&((*root)->lchild));
		Pre_order_Creat_Btree(&((*root)->rchild));
	}
}   //我们首先创建的是根节点,先序首先操作的是根节点我们才能固定出一棵二叉树,中后序首先操作不是根节点,

//二叉树遍历递归算法
//-----------------------------先序遍历递归版---------------------------------
void Pre_order_Rec(BTree root)
{
	if(root)
	{
		printf("%c ",root->data);
		Pre_order_Rec(root->lchild);
		Pre_order_Rec(root->rchild);
	}
}
//-----------------------------中序遍历递归版----------------------------------
void In_order_Rec(BTree root)
{
	if(root)
	{
		In_order_Rec(root->lchild);
		printf("%c ",root->data);
		In_order_Rec(root->rchild);
	}
}
//------------------------------后序遍历递归版-----------------------------------
void Post_order_Rec(BTree root)
{
	if(root)
	{
		Post_order_Rec(root->lchild);
		Post_order_Rec(root->rchild);
		printf("%c ",root->data);
	}
}

//访问函数，可以定义声明作为函数指针使用
int visit(BTree Tree)
{
    if(Tree)
    {
        printf("%c ",Tree->data);       //访问节点函数
        return 1;
    }
    else
        return 0;
}

//层次遍历非递归算法
//------------------------------方法一C++STL实现---------------------------
void LevelOrder_First(BTree Tree)
{
    queue<BTree>Q;
    BTree p;
    p=Tree;
    if(visit(p)==1)    //只要当前的这棵树不为空，就访问该树根节点的信息并进行入队操作
        Q.push(p);
    while(!Q.empty())             //层次遍历利用了先进先出的性质，故想到了队列
    {
        p=Q.front();
        Q.pop();
        if(visit(p->lchild)==1)
            Q.push(p->lchild);
        if(visit(p->rchild)==1)
            Q.push(p->rchild);
    }
}
//-------------------------------方法二C语言实现--------------------------
void LevelOrder_Second(BTree Tree)
{
    BTNode *queue[1000];                //定义队列有十个空间  --- 这种方式可以说根本就没有用到队列，充其量只是思维上和队列一致
    if(Tree==NULL)        //空树则返回                      //很方便---我喜欢
        return;
    int front,rear;
    front=rear=0;
    queue[rear++]=Tree;
    while(front!=rear)                //如果队尾指针不等于对头指针时
    {
        cout<<queue[front]->data<<" ";  //输出遍历结果
        if(queue[front]->lchild!=NULL)  //将队首结点的左孩子指针入队列
        {
            queue[rear]=queue[front]->lchild;
            rear++;                                 //队尾指针后移一位
        }
        if(queue[front]->rchild!=NULL)
        {
            queue[rear]=queue[front]->rchild;    //将队首结点的右孩子指针入队列
            rear++;                         //队尾指针后移一位
        }
        front++;                       //对头指针后移一位
    }
}
//---------------------------------方法三-课本版-----------------------------------
void LevelOrder_Third(BTree root)
{
	Squeue queue;
	BTNode *p=NULL;
	if(NULL!=root)
	{
		p=root;
		Init_Squeue(queue);
		En_Squeue(queue,p);
		while(!Empty_Squeue(*queue))
		{
			De_Squeue(queue,&p);
			printf("%c ",p->data);
			if(p->lchild!=NULL)
				En_Squeue(queue,p->lchild);
			if(p->rchild!=NULL)
				En_Squeue(queue,p->rchild);
		}
	}
}
//计算二叉树的深度-递归版
//------------------------------------方法一--------------------------
int BTree_Depth_First(BTree root)
{
	if(root)
	{
		int h1=BTree_Depth_First(root->lchild);
		int h2=BTree_Depth_First(root->rchild);
		return (h1>h2?h1:h2)+1;
	}              //return (depth(T->lchild)>depth(T->rchild)?depth(T->lchild):depth(T->rchild))+1;
	return 0;
}
//-----------------------------------方法二----------------------------
void BTree_Depth_Second(BTree root,int Count,int &depth)
{
	if(root)
	{
		if(Count>depth)
			depth=Count;
		BTree_Depth_Second(root->lchild,Count+1,depth);
		BTree_Depth_Second(root->rchild,Count+1,depth);
	}
}

//计算二叉树的叶子节点数
void BTree_leave_num(BTree root,int &Count)
{
	if(root)             //这里你为什么要用引用。1、你没有返回值。2、实参到形参的传递只是赋值过程不改变原值 3、你也没用指针
	{
		if(!root->lchild&&!root->rchild)      //不改变二叉树的结构,我不应该用指针的
			Count++;
		BTree_leave_num(root->lchild,Count);
		BTree_leave_num(root->rchild,Count);
	}
}
//先中后二叉树遍历非递归版
//---------------------------先序遍历非递归算法----------------------
typedef BTree Elemtype;
void PreOrder_NonRec_First(BTree root)
{
	SqStack stack;
	StackInitiate(&stack);
	BTNode *p=NULL;
	if(root!=NULL)
	{
		stack.data[++stack.top]=root;
		while(stack.top>0)
		{
			p=stack.data[stack.top--];
			printf("%c ",p->data);
			if(NULL!=p->rchild)
				stack.data[++stack.top]=p->rchild;
			if(NULL!=p->lchild)
				stack.data[++stack.top]=p->lchild;
		}
	}
}
void PreOrder_NonRec_Second(BTree Tree)           //先序遍历的非递归
{
    if(!Tree)
        return ;
    stack<BTree>s;
    s.push(Tree);
    while(!s.empty())
    {
        BTree temp=s.top();                             //总结：关于先中后遍历的栈如何应用，你只需要根据先中后序访问顺序关系知道什么时候做出栈，什么时候做入栈
        cout<<temp->data<<" ";                         //然后判断出栈或者入栈的时候需不需要进行访问操作就明白了
        s.pop();
        if(temp->rchild)                   //这种和下面的两种有所不同，请读者自己体会
            s.push(temp->rchild);
        if(temp->lchild)
            s.push(temp->lchild);
    }
}
void PreOrder_NonRec_Third(BTree Tree)          //先序遍历的非递归---法一：只在入栈的时候做访问操作
{
    if(!Tree)
        return ;
    stack<BTree>s;
    BTree curr=Tree;
    while(curr!=NULL||!s.empty())
    {
        while(curr!=NULL)                         //根据先序的关系知先让最左边的孩子全部入栈（边入栈边访问），完后作出栈就好了再重复入栈就好了
        {
            cout<<curr->data<<" ";
            s.push(curr);
            curr=curr->lchild;
        }
        if(!s.empty())
        {
            curr=s.top();
            s.pop();
            curr=curr->rchild;
        }
    }
}
void PreOrder_NonRec_Fouth(BTree Tree)     //先序遍历的非递归
{
    if(!Tree)
        return ;
    stack<BTree> s;
    while(Tree)                                 //左子树上的节点全部压入到栈中
    {
        s.push(Tree);
        cout<<Tree->data<<" ";
        Tree=Tree->lchild;
    }
    while(!s.empty())
    {
        BTree temp=s.top()->rchild;            // 栈顶元素的右子树
        s.pop();                                    // 弹出栈顶元素
        while(temp)                           //栈顶元素存在右子树，则对右子树同样遍历到最下方
        {
            cout<<temp->data<<" ";
            s.push(temp);                 //这里也是在入栈的时候做访问操作（因为先序首先访问的就是每一棵树的根节点）
            temp=temp->lchild;
        }
    }
}
//-----------------------中序遍历非递归算法------------------------
void InOrder_NonRec_First(BTree root)
{
	SqStack stack;
	BTNode *p=NULL;
	StackInitiate(&stack);
	p=root;
	while(NULL!=p||stack.top>0)
	{
		while(NULL!=p)
		{
			stack.data[++stack.top]=p;
			p=p->lchild;
		}
		p=stack.data[stack.top--];
		printf("%c ",p->data);
		p=p->rchild;
	}
}
void InOrder_NonRec_Second(BTree T)           //中序遍历的非递归
{
    if(!T)
        return ;
    BTree curr=T;                   //指向当前要检查的节点
    stack<BTree>s;
    while(curr!=NULL||!s.empty())
    {
        while(curr!=NULL)
        {
            s.push(curr);
            curr=curr->lchild;
        }
        if(!s.empty())                          //中序遍历首先访问的是左节点再是根节点，所以是在出栈的时候做访问操作
        {												//同时入栈的左节点又充当根节点的作用
            curr=s.top();
            s.pop();
            cout<<curr->data<<" ";
            curr=curr->rchild;
        }
    }
}
void InOrder_NonRec_Third(BTree T)               //中序遍历的非递归
{
    if(!T)
        return ;
    stack<BTree>s;
    BTree curr=T->lchild;                      //指向当前要检查的节点
    s.push(T);
    while(curr!=NULL||!s.empty())
    {
        while(curr!=NULL)                     //一直向左走
        {
            s.push(curr);
            curr=curr->lchild;
        }
        curr=s.top();                                //还是入栈的时候不做访问操作，只在出栈的时候做访问操作
        s.pop();
        cout<<curr->data<<" ";
        curr = curr->rchild;
    }
}
void PostOrder_NonRec_Second(BTree T)         //后序遍历的非递归
{
    stack<BTree>S;
    BTree curr=T;                  //指向当前要检查的节点
    BTree previsited=NULL;                //指向前一个被访问的节点
    while(curr!=NULL||!S.empty())         //栈空时结束
    {
        while(curr!=NULL)               //一直向左走直到为空
        {
            S.push(curr);
            curr=curr->lchild;
        }
        curr=S.top();               // 当前节点的右孩子如果为空或者已经被访问，则访问当前节点
        if(curr->rchild==NULL||curr->rchild==previsited)
        {
            cout<<curr->data<<" ";                //这个思路很好，相比课本上的，显得精简活跃，当你无法具体理解代码时，你就画出一棵二叉树再对比代码的思路进行
            previsited=curr;                           //一步一步地跟踪
            S.pop();
            curr = NULL;
        }
        else
            curr=curr->rchild;      // 否则访问右孩子
    }
}
void PostOrder_NonRec_Third(BTree T)        //后序遍历的非递归     双栈法
{
    stack<BTree>s1,s2;
    BTree curr;                     //指向当前要检查的节点
    s1.push(T);
    while(!s1.empty())                //栈空时结束
    {
        curr=s1.top();
        s1.pop();
        s2.push(curr);
        if(curr->lchild)                       //这个方式就更加简单了，具有实际效率
            s1.push(curr->lchild);
        if(curr->rchild)
            s1.push(curr->rchild);
    }
    while(!s2.empty())
    {
        printf("%c ", s2.top()->data);
        s2.pop();
    }
}
//查找指定节点的孩子的算法
void Find_Child_Bnode(BTNode *p,BTNode **p_lchild,BTNode **p_rchild)
{
	if(p==NULL)
		return ;
	*p_lchild=p->lchild;
	*p_rchild=p->rchild;
	return ;
}
//查找指定节点的双亲的算法
typedef BTree Elemtype;

int Find_Parent_Bnode(BTree root,BTNode *p,BTNode **p_parent)
{
	SqStack stack;
	BTNode *q=NULL;
	*p_parent=NULL;
	if(p==root)
		return 0;
	stack.top=0;q=root;
	while(NULL!=q||stack.top>0)
	{
		while(NULL!=q)
		{
			stack.data[++stack.top]=q;
			q=q->lchild;
		}
		q=stack.data[stack.top--];
		if(p==q->lchild||p==q->rchild)
		{
			*p_parent=q;                //二叉树中一个节点最多只有一个父节点，别以为叫双亲你就以为是两个
			return 1;
		}
		q=q->rchild;
	}
	return 0;
}
//查找指点节点子孙节点的算法
typedef char DataType;
typedef BTree Elemtype;

void FindDescendants_Blist(BTNode *p)
{
	SqQueue queue;                    //队列的声明与定义
	BTNode *q=NULL;int count=0;
	if(p==NULL)
	{
		printf("当前输入的节点参数有错!!!\n");
		return ;
	}
	if(p->lchild==NULL&&p->rchild==NULL)
	{
		printf("当前输入的节点是叶子节点，无孩子节点!!!\n");
		return ;
	}
	queue.front=0;
	queue.rear=0;
	printf("%c节点的所有子孙节点如下所示：\n",p->data);
	queue.data[queue.rear]=p;
	queue.rear=(queue.rear+1)%MAX;
	while(queue.front!=queue.rear)
	{
		q=queue.data[queue.front];
		queue.front=(queue.front+1)%MAX;
		if(q!=p)
		{
			printf("%c ",q->data);
			count++;
			if(count==5)
				printf("\n");
		}
		if(NULL!=q->lchild)
		{
			queue.data[queue.rear]=q->lchild;
			queue.rear=(queue.rear+1)%MAX;
		}
		if(NULL!=q->rchild)
		{
			queue.data[queue.rear]=q->rchild;
			queue.rear=(queue.rear+1)%MAX;
		}
	}
	printf("\n");
	printf("节点%c共有%d个子孙节点.\n",p->data,count);
	return ;
}
//查找指定节点祖先的算法
void FindAncersors_Blist(BTree root,BTNode *p)       //这样子的所有祖先连起来就是折线(为什么这么说,想过吗)
{
	BTNode *p_parent=p;
	BTNode *q=NULL;
	if(p==root)
	{
		printf("输入的节点信息是根节点，无祖先可寻!!!\n");
		return ;
	}
	while(p_parent!=root)
	{
		q=p_parent;
		p_parent=NULL;
		Find_Parent_Bnode(root,q,&p_parent);
		printf("节点%c是节点%c的一个祖先节点.\n",p_parent->data,p->data);
	}
}
//基于后序遍历的二叉树各类结点统计递归算法
int count_leaf=0;
int count_onedegree=0;
int count_twodegree=0;

void NodeCount_Rec(BTree root)
{
	if(root!=NULL)
	{
		NodeCount_Rec(root->lchild);
		NodeCount_Rec(root->rchild);
		if(NULL==root->lchild&&NULL==root->rchild)
			count_leaf++;
		else if(NULL!=root->lchild&&NULL!=root->rchild)
			count_twodegree++;
		else
			count_onedegree++;
	}
}
//给某节点插入左节点
BTree Insert_LeftNode(BTree father,DataType x)
{
	BTree p=NULL,q=NULL;
	if(father==NULL)
		return NULL;            //注意在函数调用时NULL和0的区别（返回值的类型）
	q=father->lchild;
	p=(BTNode *)malloc(sizeof(BTNode));
	p->data=x;
	p->lchild=q;
	p->rchild=NULL;
	father->lchild=p;
	return father->lchild;
}
//给某节点插入右节点
BTree Insert_RightNode(BTree father,DataType x)
{
	BTree p=NULL,q=NULL;
	if(father==NULL)
		return NULL;
	q=father->rchild;
	p=(BTree)malloc(sizeof(BTNode));
	p->data=x;
	p->rchild=q;
	p->lchild=NULL;
	father->rchild=p;
	return father->rchild;
}
//通过释放节点达到销毁的目的
void Destroy_BTree(BTree *root)
{
	if((*root)!=NULL&&(*root)->lchild!=NULL)
		Destroy_BTree(&(*root)->lchild);
	if((*root)!=NULL&&(*root)->rchild!=NULL)
		Destroy_BTree(&(*root)->rchild);
	free(*root);                                      //这里有个BUG
}
//删除左子树
BTree Delete_LeftTree(BTree Node)
{
	if(NULL==Node->lchild&&NULL==Node->rchild)   //若要删除的为叶子节点则不删除
		return NULL;
	Destroy_BTree(&Node->lchild);   //删除该节点的左子树
	Node->lchild=NULL;
	return Node;
}
//删除右子树
BTree Delete_RightTree(BTree Node)
{
	if(NULL==Node->lchild&&NULL==Node->rchild)   若要删除的为叶子节点则不删除
		return NULL;
	Destroy_BTree(&Node->rchild);        //删除该节点的右子树
	Node->rchild=NULL;
	return Node;
}
//交换所有节点的左右子树
void Exchange_BTree(BTree root)
{
	if(root!=NULL)
	{
		Exchange_BTree(root->lchild);
		Exchange_BTree(root->rchild);       //首先不断的递归到最底层的二叉树，然后再不断的往上交换
		BTree p=root->lchild;
		root->lchild=root->rchild;
		root->rchild=p;
	}
}
void PreOrder(BTree root)   //输出后序遍历的逆序序列---想想这样为什么就解决了这个问题
{
	if(root)
	{
		printf("%f",root->data);
		PreOrder(root->rchild);
		PreOrder(root->lchild);
	}
}
//查找节点函数
int Insearch_BTree(BTree root,DataType x,BTree &p)
{
	if(!root)
	{
		p=NULL;
		return 0;
	}
	else
	{
		if(root->data==x)
		{
			printf("元素已找到,正在返回!!!\n");
			p=root;
			return 1;
		}
		if(Insearch_BTree(root->lchild,x,p))    //只要是棵二叉树(只有两个方向),这左右(方向)递归函数一起使用就能遍历整个二叉树
			return 1;
		else
			return Insearch_BTree(root->rchild,x,p);
	}
	return 0;
}
void Delay(char *p)              //延时函数的定义
{
	while(1)
	{
		if(*p!=0)
			printf("%c",*p++);
		else
			break;
		Sleep(10);               //延时控制间断语句
	}
}                        //有w存在时就表示要新建一个文件，其他情况都不会新建
void Basic_operation(BTree root)             //功能函数
{
	int n;
	char ch;BTree head,arrow,p_lchild,p_rchild;
	int count=0,depth=1;
	system("cls");
	printf("\t\t\t\t\t\t\t\t----------------------------------------------------\n");
	printf("\t\t\t\t\t\t\t\t+		  二叉树基本操作   			   +\n");
	printf("\t\t\t\t\t\t\t\t----------------------------------------------------\n");
	printf("\t\t\t\t\t\t\t\t\t*************************************\n");
	printf("\t\t\t\t\t\t\t\t       |\t  1、创建二叉树              |\n");
	printf("\t\t\t\t\t\t\t\t       |\t  2、插入左孩子              |\n");              //为什么不能在这里定义head指针---因为每次调用功能函数后，head指针又被重新初始化了
	printf("\t\t\t\t\t\t\t\t       |\t  3、插入右孩子              |\n");
	printf("\t\t\t\t\t\t\t\t       |\t  4、查找某节点              |\n");
	printf("\t\t\t\t\t\t\t\t       |\t  5、求叶子数目              |\n");
	printf("\t\t\t\t\t\t\t\t       |\t  6、求深度操作              |\n");
	printf("\t\t\t\t\t\t\t\t       |\t  7、先中后递归打印          |\n");
	printf("\t\t\t\t\t\t\t\t       |\t  8、先中后非递归打印        |\n");
	printf("\t\t\t\t\t\t\t\t       |\t  9、层次遍历                |\n");
	printf("\t\t\t\t\t\t\t\t       |\t 10、各类节点数              |\n");
	printf("\t\t\t\t\t\t\t\t       |\t 11、树左右互换              |\n");
	printf("\t\t\t\t\t\t\t\t       |\t 12、删除左子树              |\n");
	printf("\t\t\t\t\t\t\t\t       |\t 13、删除右子树              |\n");
	printf("\t\t\t\t\t\t\t\t       |\t 14、查找指定节点双亲        |\n");
	printf("\t\t\t\t\t\t\t\t       |\t 15、查找指定节点孩子        |\n");
	printf("\t\t\t\t\t\t\t\t       |\t 16、查找指定节点子孙        |\n");
	printf("\t\t\t\t\t\t\t\t       |\t 17、查找指定节点祖先        |\n");
	printf("\t\t\t\t\t\t\t\t       |\t 18、退出程序                |\n");
	printf("\t\t\t\t\t\t\t\t\t*************************************\n");
	printf("请输入你所需要完成的指令:\n");
	do{
		scanf("%d%*c",&n);
		if(n<1||n>18)
			printf("对不起，你输入的指令编号是无效的，请重新输入!!!\n");
	}while(n<1||n>18);
	switch(n)
	{
		case 1:
			Pre_order_Creat_Btree(&root);
			printf("创建成功!\n");
			system("pause");
			break;
		case 2:
			printf("请输入要插入的字母：\n");
			scanf("%c%*c",&ch);
			Insert_LeftNode(root,ch);
			printf("插入成功\n");
			system("pause");
			break;
		case 3:
			printf("请输入要插入的字母：\n");
			scanf("%c%*c",&ch);
			Insert_RightNode(root,ch);
			printf("插入成功\n");
			system("pause");
			break;
		case 4:
			printf("请输入要查找的节点元素：\n");
			scanf("%c%*c",&ch);
			head=root;
			Insearch_BTree(root,ch,head);
			if(head==NULL)
				printf("查找元素顶点不存在,查找失败!!!\n");
			else
				printf("%c\n",head->data);
			system("pause");
			break;
		case 5:
			BTree_leave_num(root,count);
			printf("二叉树叶子节点数目为：%d\n",count);
			system("pause");
			break;
		case 6:
			printf("二叉树的深度为：%d\n",	BTree_Depth_First(root));
			BTree_Depth_Second(root,1,depth);
			printf("二叉树的深度为：%d\n",depth);
			system("pause");
			break;
		case 7:
			printf("先序递归遍历后得到如下序列:\n");
			Pre_order_Rec(root);
			printf("\n");
			printf("中序遍历后得到如下序列:\n");
			In_order_Rec(root);
			printf("\n");
			printf("后序遍历后得到如下序列:\n");
			Post_order_Rec(root);
			printf("\n");
			system("pause");
			break;
		case 8:
			printf("第一种先序遍历非递归结果如下:\n");
			PreOrder_NonRec_First(root);
			printf("\n");
			printf("第二种先序遍历非递归结果如下:\n");
			PreOrder_NonRec_Second(root);
			printf("\n");
			printf("第三种先序遍历非递归结果如下:\n");
			PreOrder_NonRec_Third(root);
			printf("\n");
			printf("第四种先序遍历非递归结果如下:\n");
			PreOrder_NonRec_Fouth(root);
			printf("\n");
			printf("第一种中序遍历非递归结果如下:\n");
			InOrder_NonRec_First(root);
			printf("\n");
			printf("第二种中序遍历非递归结果如下:\n");
			InOrder_NonRec_Second(root);
			printf("\n");
			printf("第三种中序遍历非递归结果如下:\n");
			InOrder_NonRec_Third(root);
			printf("\n");
			printf("第一种后序遍历非递归结果如下:\n");
			PostOrder_NonRec_Second(root);
			printf("\n");
			printf("第二种后序遍历非递归结果如下:\n");
			PostOrder_NonRec_Third(root);
			printf("\n");
			system("pause");
			break;
		case 9:
			printf("第一种层次遍历后得到如下序列：\n");
			LevelOrder_First(root);
			printf("\n");
			printf("第二种层次遍历后得到如下序列：\n");
			LevelOrder_Second(root);
			printf("\n");
			printf("第三种层次遍历后得到如下序列：\n");
			LevelOrder_Third(root);
			printf("\n");
			system("pause");
			break;
		case 10:
			NodeCount_Rec(root);
			printf("0度节点数目为:%d\n",count_leaf);
			printf("1度节点数目为:%d\n",count_onedegree);
			printf("2度节点数目为:%d\n",count_twodegree);
			count_leaf=count_onedegree=count_twodegree=0;
			system("pause");
			break;
		case 11:
			Exchange_BTree(root);
			printf("左右子树交换成功!\n");
			system("pause");
			break;
		case 12:
			Delete_LeftTree(root);
			printf("删除左子树成功!\n");
			system("pause");
			break;
		case 13:
			Delete_RightTree(root);
			printf("删除右子树成功!\n");
			system("pause");
			break;
		case 14:
			head=arrow=root;
			printf("请输入你想要谁的父节点：\n");
			scanf("%c%*c",&ch);
			head=root;
			Insearch_BTree(root,ch,head);
			Find_Parent_Bnode(root,head,&arrow);
			if(arrow==NULL)
				printf("查找节点不存在或者为根节点!!!\n");
			else
				printf("节点%c的父节点是%c\n",head->data,arrow->data);
			system("pause");
			break;
		case 15:
			head=root;
			printf("请输入你想要谁的孩子节点：\n");
			scanf("%c%*c",&ch);
			head=root;
			Insearch_BTree(root,ch,head);
			Find_Child_Bnode(head,&p_lchild,&p_rchild);
			if(p_lchild==NULL&&p_rchild==NULL)
				printf("查找节点不存在或者为叶子节点!!!\n");
			else if(p_lchild!=NULL&&p_rchild==NULL)
				printf("节点%c的左孩子是%c\n",head->data,p_lchild->data);
			else if(p_lchild==NULL&&p_rchild!=NULL)
				printf("节点%c的右孩子是%c\n",head->data,p_rchild->data);
			else
				printf("节点%c的左右孩子分别为%c和%c\n",head->data,p_lchild->data,p_rchild->data);
			system("pause");
			break;
		case 16:
			head=root;
			printf("请输入你想要谁的子孙节点：\n");
			scanf("%c%*c",&ch);
			head=root;
			Insearch_BTree(root,ch,head);
			FindDescendants_Blist(head);
			system("pause");
			break;
		case 17:
			head=root;
			printf("请输入你想要谁的祖宗节点：\n");
			scanf("%c%*c",&ch);
			head=root;
			Insearch_BTree(root,ch,head);
			FindAncersors_Blist(root,head);
			system("pause");
			break;
		case 18:
			return ;
		default:
			Basic_operation(root);
	}
	Basic_operation(root);
}