二叉树(链式结构)

 

 

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>

#define MAXLEN 20;                                //最大长度

typedef char DATA;                                //定义元素类型
typedef struct CBT                                //定义二叉树结点类型
{
    DATA data;                                    //元素数据
    struct CBT *left;                            //左子树结点指针
    struct CBT *right;                            //右子树结点指针
}CBTType;

CBTType *InitTree()                                //初始化二叉树的根
{
    CBTType *node;

    if(node=(CBTType *)malloc(sizeof(CBTType)))    //申请内存
    {
        printf("请先输入一个根结点数据：\n");
        scanf("%c",&node->data);
        node->left = NULL;
        node->right = NULL;

        if(node!=NULL)                            //如果二叉树根结点不为空
        {
            return node;
        }
        else
        {
            return NULL;
        }
        return NULL;
    }
}

CBTType *TreeFindNode(CBTType *treeNode, DATA data)        //查找结点
{
    CBTType *ptr;

    if(treeNode == NULL)
    {
        return NULL;
    }
    else
    {
        if(treeNode->data == data)
        {
            return treeNode;
        }
        else
        {
            if(ptr=TreeFindNode(treeNode->left,data))            //分别向左右子树递归查找
            {
                return ptr;
            }
            else if(ptr=TreeFindNode(treeNode->right,data))
            {
                return ptr;
            }
            else
            {
                return NULL;
            }
        }
    }
}

void AddTreeNode(CBTType *treeNode)                //添加结点
{
    CBTType *pnode, *parent;
    DATA data;
    char menusel;

    if(pnode=(CBTType *)malloc(sizeof(CBTType)))    //分配内存
    {
        printf("输入二叉树结点数据：\n");
        fflush(stdin);
        scanf("%c",&pnode->data);
        pnode->left = NULL;
        pnode->right = NULL;                    //设置左右子树为空

        printf("请输入核结点父结点数据：");
        fflush(stdin);
        scanf("%c",&data);
        parent = TreeFindNode(treeNode,data);        //查找指定数据的结点
        if(!parent)                                    //如果未找到
        {
            printf("未找到该父结点！\n");
            free(pnode);                            //释放创建的结点内存
            return;
        }
        printf("1.添加该结点到左子树\n 2.添加该结点到右子树\n");
        do
        {
            menusel = _getch();                        //输入选择项
            menusel -= '0';
            if(menusel==1 || menusel==2)
            {
                if(parent==NULL)
                {
                    printf("不存在父结点，请先设置父结点！\n");
                }
                else
                {
                    switch (menusel)
                    {
                    case 1:                                //添加到左结点
                        if(parent->left)                    //左子树不为空
                        {
                            printf("左子树不为空！\n");
                        }
                        else
                        {
                            parent->left = pnode;
                        }
                        break;
                    case 2:                                //添加到右结点
                        if(parent->right)                //右子树不为空
                        {
                            printf("右子树不为空！\n");
                        }
                        else
                        {
                            parent->right = pnode;
                        }
                        break;
                    default:
                        printf("无效参数!\n");
                        break;
                    }
                }
            }            
        }while(menusel != 1 && menusel != 2);
    }
}

CBTType *TreeLeftNode(CBTType *treeNode)            //获取左子树
{
    if(treeNode)
    {
        return treeNode->left;
    }
    else
    {
        return NULL;
    }
}

CBTType *TreeRightNode(CBTType *treeNode)            //获取右子树
{
    if(treeNode)
    {
        return treeNode->right;
    }
    else
    {
        return NULL;
    }
}

int TreeIsEmpty(CBTType *treeNode)                    //判断空树
{
    if(treeNode)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

int TreeDepth(CBTType *treeNode)                    //计算二叉树的深度
{
    int depleft, depright;

    if(treeNode==NULL)
    {
        return 0;                                    //对于空树，深度为0
    }
    else
    {
        depleft = TreeDepth(treeNode->left);        //左子树深度(递归调用)
        depright = TreeDepth(treeNode->right);        //右子树深度(递归调用)
        if(depleft>depright)
        {
            return depleft + 1;
        }
        else
        {
            return depright +1;
        }
    }
}

void ClearTree(CBTType *treeNode)                    //清空二叉树
{
    if(treeNode)
    {
        ClearTree(treeNode->left);                    //清空左子树
        ClearTree(treeNode->right);                    //清空右子树
        free(treeNode);                                //释放当前结点所占内存
        treeNode = NULL;
    }
}

void TreeNodeData(CBTType *p)                        //显示结点数据
{
    printf("%c",p->data);                            //输出结点数据
}

void DLRTree(CBTType *treeNode, void(*TreeNodeData)(CBTType *p))        //先序遍历
{
    if(treeNode)
    {
        TreeNodeData(treeNode);                        //显示结点的数据
        DLRTree(treeNode->left, TreeNodeData);
        DLRTree(treeNode->right, TreeNodeData);
    }
}

void LDRTree(CBTType *treeNode, void(*TreeNodeData)(CBTType *p))        //中序遍历
{
    if(treeNode)
    {
        LDRTree(treeNode->left, TreeNodeData);        //中序遍历左子树
        TreeNodeData(treeNode);                        //显示结点数据
        LDRTree(treeNode->right, TreeNodeData);        //中序遍历右子树
    }
}

void LRDTree(CBTType *treeNode, void(*TreeNodeData)(CBTType *p))        //后序遍历
{
    if(treeNode)
    {
        LRDTree(treeNode->left, TreeNodeData);        //后序遍历左子树
        LRDTree(treeNode->right, TreeNodeData);        //后序遍历右子树
        TreeNodeData(treeNode);                        //显示结点数据
    }
}

void main()
{
    CBTType *root = NULL;                            //root为指向二叉树根结点的指针
    char menusel;
    void(*TreeNodeData1)(CBTType *p);                //指向函数的指针
    TreeNodeData1 = TreeNodeData;                    //指向具体操作的函数
    //设置根元素
    root = InitTree();
    //添加结点
    do
    {
        printf("请选择菜单添加二叉树的结点\n");
        printf("0.退出\t");                            //显示菜单
        printf("1.添加二叉树的结点\n");
        menusel = _getch();
        switch (menusel)
        {
        case '1':                                    //添加结点
            AddTreeNode(root);
            break;
        case '0':
            break;
        default:
            break;
        }
    }while(menusel!='0');

    //遍历
    do
    {
        printf("请选择菜单遍历二叉树，输入0表示退出：\n");
        printf("1.先序遍历DLR\t");                    //显示菜单
        printf("2.中序遍历LDR\n");
        printf("3.后序遍历LRD\t");
        menusel=_getch();
        switch (menusel)
        {
        case '0':
            break;
        case '1':                                    //先序遍历
            printf("\n先序遍历DLR的结果: ");
            DLRTree(root,TreeNodeData1);
            printf("\n");
            break;
        case '2':                                    //中序遍历
            printf("\n中序遍历的结果：");
            LDRTree(root, TreeNodeData1);
            printf("\n");
            break;
        case '3':                                    //后序遍历
            printf("\n后序遍历LRD的结果：");
            LRDTree(root,TreeNodeData1);
            printf("\n");
            break;
        default:
            break;
        }
    }while(menusel != '0');

    //深度
    printf("\n二叉树深度为:%d\n",TreeDepth(root));

    ClearTree(root);                                //清空二叉树
    root = NULL;
}