8608 实现二叉排序树的各种算法(2)

8608 实现二叉排序树的各种算法(2)
时间限制:1000MS  代码长度限制:10KB
提交次数:2559 通过次数:1396

题型: 编程题   语言: G++;GCC
Description
用函数实现如下二叉排序树算法： 
（1） 插入新结点 
（2） 前序、中序、后序遍历二叉树 
（3） 中序遍历的非递归算法 
（4） 层次遍历二叉树 
（5） 在二叉树中查找给定关键字(函数返回值为成功1,失败0) 
（6） 交换各结点的左右子树 
（7） 求二叉树的深度 
（8） 叶子结点数



输入格式
第一行：准备建树的结点个数n 
第二行：输入n个整数，用空格分隔 
第三行：输入待查找的关键字 
第四行：输入待查找的关键字 
第五行：输入待插入的关键字


输出格式
第一行：二叉树的先序遍历序列 
第二行：二叉树的中序遍历序列 
第三行：二叉树的后序遍历序列 
第四行：查找结果 
第五行：查找结果 
第六行~第八行：插入新结点后的二叉树的先、中、序遍历序列 
第九行：插入新结点后的二叉树的中序遍历序列(非递归算法) 
第十行：插入新结点后的二叉树的层次遍历序列 
第十一行~第十三行：第一次交换各结点的左右子树后的先、中、后序遍历序列 
第十四行~第十六行：第二次交换各结点的左右子树后的先、中、后序遍历序列 
第十七行：二叉树的深度 
第十八行：叶子结点数


输入样例
7
40 20 60 18 50 56 90
18
35
30


输出样例
40 20 18 60 50 56 90
18 20 40 50 56 60 90
18 20 56 50 90 60 40
1
0
40 20 18 30 60 50 56 90
18 20 30 40 50 56 60 90
18 30 20 56 50 90 60 40
18 20 30 40 50 56 60 90
40 20 60 18 30 50 90 56
40 60 90 50 56 20 30 18
90 60 56 50 40 30 20 18
90 56 50 60 30 18 20 40
40 20 18 30 60 50 56 90
18 20 30 40 50 56 60 90
18 30 20 56 50 90 60 40
4
4

中序遍历序列(非递归算法)借助栈stack，层次遍历序列借助队列queue实现。
对stack和queue用法不熟悉可以参考这里

Stack用法
Queue用法

交换节点先从左子树底层开始交换，再到右子树，递归实现交换。

#include "stdio.h"
#include "malloc.h"
#include <iostream>
#include <stack>
#include <queue>
using namespace std;


typedef struct BSTNode
{
    int data=0;
    struct BSTNode *lchild,*rchild;
}BSTNode,*BSTree;//结构体

int searchTree(BSTree T,int e)//在二叉树中查找给定关键字(函数返回值为成功1,失败0) 
{
    if (T==NULL)
    {
        return 0;
    }else if (e==T->data)
    {
        return 1;
    }else if (e<T->data)
    {
        return searchTree(T->lchild,e);
    }else
    {
        return searchTree(T->rchild,e);
    }
}


void InsertBST(BSTree &T,int e)//插入节点，根据节点值的大小插入
{
    if (!T)
    {
        BSTNode *S;
        S=new BSTNode;
        S->data=e;
        S->lchild=S->rchild=NULL;
        T=S;
    }
    else if (e<T->data)
    {
        InsertBST(T->lchild,e);
    }else if (e>T->data)
    {
        InsertBST(T->rchild,e);
    }
}

void preTraverse(BSTree T)//先序遍历
{
    if (T)
    {
        printf ("%d ",T->data);
        preTraverse(T->lchild);
        preTraverse(T->rchild);
    }
}

void InorderTraverse(BSTree T)//中序遍历
{
    if (T)
    {
        InorderTraverse(T->lchild);
        printf ("%d ",T->data);
        InorderTraverse(T->rchild);
    }
}

void lastTraverse(BSTree T)//后序遍历
{
    if (T)
    {
        lastTraverse(T->lchild);
        lastTraverse(T->rchild);
        printf ("%d ",T->data);
    }
}

void zfTraverse(BSTree T)//中序遍历，非递归（使用栈实现）
{
    stack<BSTree> S;//创建栈 S
    BSTNode *p,*q;
    p=T;//p为头节点

    q=new BSTNode;
    while(p||!S.empty())
    {
        if (p)//p节点不为空，入栈
        {
            S.push(p);
            p=p->lchild;
        }
        else//循环到最底层左节点即p为空
        {
            q=S.top();//取出栈头
            S.pop();
            printf ("%d ",q->data);
            p=q->rchild;
        }
    }
}

void cengTraverse(BSTree T)//层次遍历（使用队列实现）
{
    queue<BSTree> M;//创建队列
    int f=0,r=0;//f为头指针，r为尾指针
    if (T)
    {
        M.push(T);
        r++;
    }
    while(f!=r)
    {
        BSTree temp=M.front();//取队列头元素
        M.pop();
        f++;
        printf ("%d ",temp->data);
        if (temp->lchild)//左节点不为空
        {
            M.push(temp->lchild);
            r++;
        }
        if (temp->rchild)//右节点不为空
        {
            M.push(temp->rchild);
            r++;
        }
    }
}

void CreatBST(BSTree &T)//创建二叉树
{
    T=NULL;
    int e,n,i,j;
    scanf("%d",&n);
    for (i=0;i<n;i++)
    {
        scanf("%d",&e);
        InsertBST(T,e);
    }
}

void swapTree(BSTree &T)// 交换各结点的左右子树 
{
    if ((T)&&T->lchild==NULL&&T->rchild==NULL)
    {
        return;
    }
    if (T->lchild)
    {
        swapTree(T->lchild);
    }
    if (T->rchild)
    {
        swapTree(T->rchild);
    }
    swap(T->lchild,T->rchild);
}

int depth(BSTree T)//求二叉树的深度
{
    int d=0;
    if (T)
    {
        d++;
    }else
    {
        return d;
    }
    d=d+max(depth(T->lchild),depth(T->rchild));
    return d;
}

int leaves(BSTree T)// 叶子结点数
{
    if(!T)
	return 0;
	if(!T->lchild&&!T->rchild)
	return 1;
	return leaves(T->lchild)+leaves(T->rchild);//左右子树的叶子节点
}

int main()
{
    BSTree T;
    CreatBST(T);
    int a,b,c,d=0,num=0;
    int flag=0;
    scanf("%d",&a);//输入待查找的关键字 
    scanf("%d",&b);//输入待查找的关键字 
    scanf("%d",&c);//输入待插入的关键字
    
    preTraverse(T);//先序遍历
    printf ("\n");
    InorderTraverse(T);//中序遍历
    printf ("\n");
    lastTraverse(T);//后序遍历
    printf("\n");

    flag=searchTree(T,a);//查找结果，查找关键字
    printf ("%d\n",flag);
    flag=searchTree(T,b);
    printf ("%d\n",flag);

    InsertBST(T,c);//插入节点
    preTraverse(T);//先序遍历
    printf ("\n");
    InorderTraverse(T);//中序遍历
    printf ("\n");
    lastTraverse(T);//后序遍历
    printf("\n");
    zfTraverse(T);//中序遍历（非递归）
    printf("\n");
    cengTraverse(T);//层次遍历
    printf("\n");

    swapTree(T);//交换节点
    preTraverse(T);
    printf ("\n");
    InorderTraverse(T);
    printf ("\n");
    lastTraverse(T);
    printf("\n");

    swapTree(T);
    preTraverse(T);
    printf ("\n");
    InorderTraverse(T);
    printf ("\n");
    lastTraverse(T);
    printf("\n");

    d=depth(T);//计算深度
    printf("%d\n",d);
    num=leaves(T);//叶子节点数
    printf ("%d\n",num);
    return 0;
}