算法与数据结构：树型数据结构及其应用

Posted 2023-02-15 咳咳n

实验目的：通过实验达到：
⑴ 理解和掌握树及二叉树的基本概念；
⑵ 理解和掌握二叉树的顺序存储结构、链式存储结构；
⑶ 理解和掌握采用二叉链式存储结构下二叉树的各种遍历操作的思想及其应用；
⑷ 加深对堆栈、队列的概念及其典型操作思想的理解；
⑸ 掌握典型二叉树操作算法的算法分析。
2. 实验题目：二叉树的建立、遍历及其应用
设树结点的元素类型为char，实现以下二叉树的各种基本操作的程序：
① 建立不少于10个结点的二叉树T；
② 用非递归方式先序遍历方式输出树T的结点；
③ 用非递归方式中序遍历方式输出树T的结点；
④ 用后序遍历方式输出树T的结点；
⑥ 用层次遍历方式输出树T的结点；
⑦ 输出树T的深度；
⑦ 输出树T的叶子结点和非叶子结点；
⑧ 主函数通过函数调用实现以上各项操作。
⑨ 哈夫曼树编码问题的设计和实现（选做）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "BTStackAndQueue.h"

BiTreeNode CreatBiTree(char *s, int &i, int len);   //创建二叉树
void visit(Datatype item);                          //访问结点数据
void PreOrder(BiTreeNode root);                     //非递归前序遍历二叉树
void InOrder(BiTreeNode root);                      //非递归中序遍历二叉树
void PostOrder(BiTreeNode root);                    //递归后序遍历二叉树
void LevelOrder(BiTreeNode root);                   //层次遍历二叉树
int GetDepth(BiTreeNode root);                      //求二叉树深度
void FindLeavesNode(BiTreeNode root);               //寻找叶子结点
void FindNotLeavesNode(BiTreeNode root);            //寻找非叶子结点

int main() 
    int i = 0;
    char *str;
    FILE *fp;
    //从文件中读入测试例:  ABD#GJ##K###CE##FH##I##  或者  ABD##EGJ##K###C#FH#L##I## 进行测试
    if (!(fp = fopen("D:\\\\Appication\\\\Clion\\\\MyCppProjects\\\\lab\\\\lab2\\\\NodeDataFile.txt", "r"))) 
        printf("file open fail\\n");
        exit(0);
    
    fscanf(fp, "%s", str);
    BiTreeNode root = CreatBiTree(str, *(&i), strlen(str));

    printf("非递归前序遍历:\\n");
    PreOrder(root);

    printf("非递归中序遍历：\\n");
    InOrder(root);

    printf("后序遍历：\\n");
    PostOrder(root);
    printf("\\n\\n");

    printf("层次遍历：\\n");
    LevelOrder(root);

    int depth = GetDepth(root);
    printf("树的深度为：%d \\n\\n", depth);

    printf("输出非叶子结点：\\n");
    FindNotLeavesNode(root);
    printf("\\n\\n");

    printf("输出叶子结点：\\n");
    FindLeavesNode(root);
    printf("\\n\\n");
    return 0;


void visit(Datatype item) 
    printf("%c ", item);


void PreOrder(BiTreeNode root) 
    SeqStack s = (SeqStack) malloc(sizeof(Stack));
    InitStack(s);
    StackPush(s, root);
    while (s->top) 
        BiTreeNode q = StackPop(s);
        visit(q->data);
        if (q->rightChild)
            StackPush(s, q->rightChild);
        if (q->leftChild)
            StackPush(s, q->leftChild);
    
    printf("\\n\\n");


void InOrder(BiTreeNode root) 
    SeqStack s = (SeqStack) malloc(sizeof(SeqStack));
    InitStack(s);
    BiTreeNode p = root;
    while (s->top || p) 
        if (p) 
            StackPush(s, p);
            p = p->leftChild;
         else 
            p = StackPop(s);
            visit(p->data);
            p = p->rightChild;
        
    
    printf("\\n\\n");


void PostOrder(BiTreeNode root) 
    if (!root)return;
    PostOrder(root->leftChild);
    PostOrder(root->rightChild);
    visit(root->data);


void LevelOrder(BiTreeNode root) 
    CircleQueue q = (CircleQueue) malloc(sizeof(CircleQueue));
    BiTreeNode p;
    InitQueue(q);
    InQueue(q, root);
    while (q->front != q->rear) 
        p = OutQueue(q);
        visit(p->data);
        if (p->leftChild)
            InQueue(q, p->leftChild);
        if (p->rightChild)
            InQueue(q, p->rightChild);
    
    printf("\\n\\n");


int GetDepth(BiTreeNode root) 
    if (root == NULL) 
        return 0;
    
    int rightMax = GetDepth(root->rightChild);
    int leftMax = GetDepth(root->leftChild);
    return rightMax > leftMax ? rightMax + 1 : leftMax + 1;


void FindLeavesNode(BiTreeNode root) 
    if (!root)return;
    BiTreeNode p = root;
    if (!p->leftChild && !p->rightChild)
        visit(p->data);
    FindLeavesNode(p->leftChild);
    FindLeavesNode(p->rightChild);


void FindNotLeavesNode(BiTreeNode root) 
    if (!root)return;
    BiTreeNode p = root;
    if (p->leftChild || p->rightChild)
        visit(p->data);
    FindNotLeavesNode(p->leftChild);
    FindNotLeavesNode(p->rightChild);

#define maxsize 100 //栈和二叉树的最大容量

typedef char Datatype;
typedef struct Node 
    Datatype data;
    struct Node *leftChild;
    struct Node *rightChild;
 *BiTreeNode;       //定义二叉树结点
//利用先序遍历创建二叉树
BiTreeNode CreatBiTree(char *s, int &i, int len) 
    BiTreeNode root;
    char c = s[i++];
    if (i >= len || c == '#') 
        root = NULL;
     else 
        root = (BiTreeNode) malloc(sizeof(BiTreeNode));
        root->data = c;
        root->leftChild = CreatBiTree(s, i, len);
        root->rightChild = CreatBiTree(s, i, len);
    
    return root;


//定义队列结构体
typedef struct Queue 
    BiTreeNode *p;  //存放的是二叉树指针
    int front;
    int rear;
 *CircleQueue;

//初始化队列
void InitQueue(CircleQueue q) 
    q->p = (BiTreeNode *) malloc((sizeof(BiTreeNode)) * maxsize);
    q->front = 0;
    q->rear = 0;


//入队列
int InQueue(CircleQueue q, BiTreeNode root) 
    if (q->front == (q->rear + 1) % maxsize) 
        printf("队列已满\\n");
        return 0;
     else 
        q->p[q->rear] = root;
        q->rear = (q->rear + 1) % maxsize;
        return 1;
    


//出队列
BiTreeNode OutQueue(CircleQueue q) 
    if (q->front == q->rear) 
        printf("队列为空\\n");
        return NULL;
     else 
        BiTreeNode root = q->p[q->front];
        q->front = (q->front + 1) % maxsize;
        return root;
    


//定义栈的结构体
typedef struct Stack 
    BiTreeNode stack[maxsize];
    int top;
 *SeqStack;

//初始化
void InitStack(SeqStack s) 
    s->top = 0;


//入栈
void StackPush(SeqStack s, BiTreeNode root) 
    if (s->top == maxsize) 
        printf("栈已满\\n");
        return;
     else 
        s->stack[s->top] = root;
        s->top++;
    


//出栈
BiTreeNode StackPop(SeqStack s) 
    if (s->top == 0) 
        printf("栈已空\\n");
        return NULL;
    
    return s->stack[--s->top];

从文件读入数据。