23.二叉树--上机题：（1）编写程序生成下面所示二叉树，并采用前序、中序和后续遍历算法分别对二叉树进行遍历。（2）然后，往树中插入两个节点（7和8），并给出其后序遍历结果。（3）P196课后习

54 阅读 0 评论 36 点赞

我是靠谱客的博主感性音响，最近开发中收集的这篇文章主要介绍23.二叉树--上机题：（1）编写程序生成下面所示二叉树，并采用前序、中序和后续遍历算法分别对二叉树进行遍历。（2）然后，往树中插入两个节点（7和8），并给出其后序遍历结果。（3）P196课后习，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

23.二叉树–上机题：
（1）编写程序生成下面所示二叉树，并采用前序、中序和后续遍历算法分别对二叉树进行遍历。
（2）然后，往树中插入两个节点（7和8），并给出其后序遍历结果。
（3）P196课后习题7-20：编写求二叉树中叶结点个数的函数（提示：这是一个遍历问题）。

头文件1：BiTree.h

#include<stdio.h>
#include<stdlib.h>

typedef char DataType;

typedef struct Node
{
    DataType data;
    struct Node* leftChild;
    struct Node* rightChild;
}BiTreeNode;

void Initiate(BiTreeNode** root)
{
    *root = (BiTreeNode*)malloc(sizeof(BiTreeNode));
    (*root)->leftChild = NULL;
    (*root)->rightChild = NULL;
}

BiTreeNode* InsertLeftNode(BiTreeNode* curr, DataType x)
{
    BiTreeNode* s, * t;
    if (curr == NULL)
        return NULL;
    t = curr->leftChild;
    s = (BiTreeNode*)malloc(sizeof(BiTreeNode));
    s->data = x;
    s->leftChild = t;
    s->rightChild = NULL;
    curr->leftChild = s;
    return curr->leftChild;
}

BiTreeNode* InsertRightNode(BiTreeNode* curr, DataType x)
{
    BiTreeNode* s, * t;
    if (curr == NULL)
        return NULL;
    t = curr->rightChild;
    s = (BiTreeNode*)malloc(sizeof(BiTreeNode));
    s->data = x;
    s->rightChild = t;
    s->leftChild = NULL;
    curr->rightChild = s;
    return curr->rightChild;
}

void Destroy(BiTreeNode** root)
{
    if ((*root) != NULL && (*root)->leftChild != NULL)
        Destroy(&(*root)->leftChild);
    if ((*root) != NULL && (*root)->rightChild != NULL)
        Destroy(&(*root)->rightChild);
    free(*root);
}

头文件2：BiTreeTraverse.h

#include"BiTree.h"

void Visit(DataType item)
{
    printf("%c ", item);
}

void PrintBiTree(BiTreeNode* root, int n)
{
    int i;
    if (root == NULL)
        return;
    PrintBiTree(root->rightChild, n + 1);
    for (i = 0; i < n - 1; i++)
        printf("   ");
    if (n > 0)
    {
        printf("---");
        printf("%cn", root->data);
    }
    PrintBiTree(root->leftChild, n + 1);
}

BiTreeNode* Search(BiTreeNode* root, DataType x)
{
    BiTreeNode* find = NULL;
    if (root != NULL)
    {
        if (root->data == x)
            find = root;
        else
        {
            find = Search(root->leftChild, x);
            if (find == NULL)
                find = Search(root->rightChild, x);
        }
    }
    return find;
}

void PreOrder(BiTreeNode* t, void Visit(DataType item))
{
    if (t != NULL)
    {
        Visit(t->data);
        PreOrder(t->leftChild, Visit);
        PreOrder(t->rightChild, Visit);
    }
}

void InOrder(BiTreeNode* t, void Visit(DataType item))
{
    if (t != NULL)
    {
        InOrder(t->leftChild, Visit);
        Visit(t->data);
        InOrder(t->rightChild, Visit);
    }
}

void PostOrder(BiTreeNode* t, void Visit(DataType item))
{
    if (t != NULL)
    {
        PostOrder(t->leftChild, Visit);
        PostOrder(t->rightChild, Visit);
        Visit(t->data);
    }
}

//求叶子结点个数 （法一） 
int BiTreeLeaves(BiTreeNode* bt)
{
    if (bt == NULL)
    {
        return 0;
    }
    if (bt->leftChild == NULL && bt->rightChild == NULL)
    {
        return 1;
    }
    return(BiTreeLeaves(bt->leftChild) + BiTreeLeaves(bt->rightChild));
}

//求叶子结点个数 （法二） 
int TreeLeaves(BiTreeNode* bt)
{
    static int count = 0;
    if (bt == NULL)
    {
        return 0;
    }
    if (bt->leftChild == NULL && bt->rightChild == NULL)
    {
        count++;
    }
    TreeLeaves(bt->leftChild);
    TreeLeaves(bt->rightChild);
    return count;
}

//求树的深度 
int Depth(BiTreeNode* bt)
{
    int leftDepth = 0;
    int rightDepth = 0;
    if (bt == NULL)
    {
        return -1;
    }
    if (bt->leftChild != NULL)
    {
        leftDepth = Depth(bt->leftChild);
    }
    else
    {
        leftDepth = -1;
    }
    if (bt->rightChild != NULL)
    {
        rightDepth = Depth(bt->rightChild);
    }
    else
    {
        rightDepth = -1;
    }
    return(rightDepth > leftDepth) ? rightDepth + 1 : leftDepth + 1;
}

源文件：main.c

#include"BiTreeTraverse.h"

int main()
{
	BiTreeNode* root, * p, * pp;

	Initiate(&root);

	p = InsertLeftNode(root, '1');
	p = InsertLeftNode(p, '2');
	p = InsertRightNode(root->leftChild, '3');

	pp = p;

	p = InsertLeftNode(p, '4');
	p = InsertLeftNode(p, '6');

	InsertRightNode(pp, '5');

	PrintBiTree(root, 0);

	printf("前序遍历:");
	PreOrder(root->leftChild, Visit);
	printf("n中序遍历:");
	InOrder(root->leftChild, Visit);
	printf("n后序遍历:");
	PostOrder(root->leftChild, Visit);

	printf("n");

	p = Search(root->leftChild, '2');
	InsertLeftNode(p, '7');
	p = Search(root->leftChild, '5');
	InsertRightNode(p, '8');

	PrintBiTree(root, 0);

	printf("n后序遍历:");
	PostOrder(root->leftChild, Visit);

//	printf("n叶子的个数为:");
//	printf("%d个", BiTreeLeaves(root->leftChild));

	printf("n叶子的个数为:");
	printf("%d个",TreeLeaves(root->leftChild));

	printf("n树的深度为%d", Depth(root->leftChild));

	Destroy(&root);

	return 0;
}