数据结构-树

最新推荐文章于 2023-12-14 09:17:11 发布

背后——NULL

最新推荐文章于 2023-12-14 09:17:11 发布

阅读量245

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构文章标签：数据结构

本文链接：https://blog.youkuaiyun.com/qq_41433183/article/details/97829371

数据结构专栏收录该内容

14 篇文章

订阅专栏

本文深入探讨了树结构的各种表示方法，包括双亲表示法、双亲孩子表示法，以及二叉树的创建与遍历算法。特别介绍了二叉树的前序、中序和后序遍历，线索二叉树的概念与实现，以及赫夫曼树的构建过程。适合初学者和进阶读者理解树和二叉树的基本操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、树结构表示法

在这里插入图片描述

/**********************
双亲表示法
**********************/

#define MAX_TREE_SIZE 100
typedef int ElemType;
typedef struct PINode
{
    ElemType data; // 结点数据
    int parent;    // 父母
}PINode;

typedef struct 
{
    PINode nodes[MAX_TREE_SIZE];  // 所有结点
    int r;  // 根节点位置
    int n;  // 结点总数
}PTree;

/********************
双亲孩子表示法
********************/

#define MAX_TREE_SIZE 100
// 孩子结点
typedef struct CTNode
{
    int child;
    struct CTNode *next;
}ChildPtr;

// 表头结构
typedef struct 
{
    ElemType data;  // 结点数据
    int parent;     // 双亲
    ChildPtr firstchild;  // 第一个孩子
}CTBox;

// 树结构
typedef struct 
{
    CTBox nodes[MAX_TREE_SIZE];  // 节点数组
};

二、二叉树

在这里插入图片描述

代码：

#include "stdio.h"
#include "stdlib.h"

typedef char ElemType;

typedef struct BITNode
{
    ElemType data;
    struct BITNode *lchild, *rchild;
} BITNode, *BiTree;

// 创建二叉树, 用前序遍历方式输入数据
void CreteBinTree(BiTree *T)
{
    char c;
    scanf("%c", &c);
    if (' ' == c)
    {
        *T = NULL;
    }
    else
    {
        *T = (BITNode *)malloc(sizeof(BITNode));
        (*T)->data = c;
        CreteBinTree(&(*T)->lchild);
        CreteBinTree(&(*T)->rchild);
    }
}

void visit(char data, int level)
{
    printf("%c位于%d层\n", data, level);
}

/*****************
二叉树遍历(前序)
******************/
void PerOderTraverser(BiTree T, int level)
{
    if (T)
    {
        visit(T->data, level);
        PerOderTraverser(T->lchild, level + 1);
        PerOderTraverser(T->rchild, level + 1);
    }
}

int main()
{
    int level = 1;
    BiTree T = NULL;
    CreteBinTree(&T);
    PerOderTraverser(T, level);
    return 0;
}

/**********************
 线索二叉树
 *********************/

typedef enum
{
    Link,
    Thread
} PointerNag;
/*
Link == 0 ： 表示指向左右孩子的指针
Thread == 1 ： 表示指向前驱后继线索
*/

typedef struct BinThrNode
{
    ElemType data;
    struct BITNode *lchild, *rchild;
    PointerNag ltag;
    PointerNag rtag;
} BinThrNode, *BinThrTree;


BinThrTree pre; // 始终指向刚刚访问过的结点

// 创建一颗二叉树，前序遍历输入

void CreteBinThreadTree(BinThrTree *T)
{
    char c;
    scanf("%c", &c);
    if (' ' == c)
    {
        *T = NULL;
    }
    else
    {
        *T = (BITNode *)malloc(sizeof(BITNode));
        (*T)->data = c;
        (*T)->ltag = Link;
        (*T)->rtag = Link;
        CreteBinTree(&(*T)->lchild);
        CreteBinTree(&(*T)->rchild);
    }
}

// 中序遍历，线索化
void InitThreading(BinThrTree T)
{
    if (T)
    {
        InitThreading(T->lchild);  // 递归左孩子线索化
        // 结点处理
        if(!T->lchild)  // 如果没有左孩子
        {
            T->ltag = Thread;
            T->lchild = pre;
        }
        if(!pre->rchild)  // 如果没有左孩子
        {
            pre->rtag = Thread;
            pre->rchild = T;
        }
        pre = T;
        InitThreading(T->rchild);  // 递归右孩子线索化
    }
}

InOderThreading(BinThrTree *p, BinThrTree T)
{
    *p = (BinThrTree)malloc(sizeof(BinThrTree));
    (*p)->ltag = Link;
    (*p)->rtag = Link;
    (*p)->rchild = *p;
    if(!T)
    {
        (*p)->rchild = *p;
    }
    else
    {
        (*p)->rchild = T;
        pre = *p;
        InitThreading(T);
        pre->rchild = *p;
        pre->rtag = Thread;
        (*p)->rchild = pre;        
    }
    
}

int main()
{
    BinThrTree T = NULL;
    BinThrTree p;
    CreteBinThreadTree(&T);
    InOderThreading(&p, T);
    return 0;
}

三、二叉树遍历
在这里插入图片描述

在这里插入图片描述

代码：

// 前序遍历
void PreOderTraverse(BiTree T)
{
    if (T == NULL)
    {
        return 0;
    }
    printf("%c\t", T->data);
    PreOderTraverse(T->lchild);
    PreOderTraverse(T->rchild);
}

别的遍历改变打印位置即可

四、线索二叉树

在这里插入图片描述

代码：

#include "stdio.h"
#include "stdlib.h"

/**********************
 线索二叉树
 *********************/

typedef char ElemType;

typedef enum
{
    Link,
    Thread
} PointerNag;
/*
Link == 0 ： 表示指向左右孩子的指针
Thread == 1 ： 表示指向前驱后继线索
*/

typedef struct BinThrNode
{
    ElemType data;
    struct BITNode *lchild, *rchild;
    PointerNag ltag;
    PointerNag rtag;
} BinThrNode, *BinThrTree;

BinThrTree pre; // 始终指向刚刚访问过的结点

// 创建一颗二叉树，前序遍历输入

void CreteBinThreadTree(BinThrTree *T)
{
    char c;
    scanf("%c", &c);
    if (' ' == c)
    {
        *T = NULL;
    }
    else
    {
        *T = (BinThrNode *)malloc(sizeof(BinThrNode));
        (*T)->data = c;
        (*T)->ltag = Link;
        (*T)->rtag = Link;
        CreteBinThreadTree(&(*T)->lchild);
        CreteBinThreadTree(&(*T)->rchild);
    }
}

// 中序遍历，线索化
void InitThreading(BinThrTree T)
{
    if (T)
    {
        InitThreading(T->lchild); // 递归左孩子线索化
        // 结点处理
        if (!T->lchild) // 如果没有左孩子
        {
            T->ltag = Thread;
            T->lchild = pre;
        }
        if (!pre->rchild) // 如果没有左孩子
        {
            pre->rtag = Thread;
            pre->rchild = T;
        }
        pre = T;
        InitThreading(T->rchild); // 递归右孩子线索化
    }
}

void InOderThreading(BinThrTree *p, BinThrTree T)
{
    *p = (BinThrTree)malloc(sizeof(BinThrNode));
    (*p)->ltag = Link;
    (*p)->rtag = Thread;
    (*p)->rchild = *p;
    if (!T)
    {
        (*p)->rchild = *p;
    }
    else
    {
        (*p)->lchild = T;
        pre = *p;
        InitThreading(T);
        pre->rchild = *p;
        pre->rtag = Thread;
        (*p)->rchild = pre;
    }
}

void visit(char c)
{
    printf("%c\t", c);
}

// 中序遍历二叉树（非递归）
void InOderTraverse(BinThrTree T)
{
    BinThrTree p;
    p = T->lchild;
    while (p != T)
    {
        while (p->ltag == Link)
        {
            p = p->lchild;
        }
        visit(p->data);
        while (p->rtag == Thread && p->rchild != T)
        {
            p = p->rchild;
            visit(p->data);
        }
        p = p->rchild;
    }
}



int main()
{
    BinThrTree T = NULL;
    BinThrTree p;
    CreteBinThreadTree(&T);
    InOderThreading(&p, T);
    printf("中序遍历结果为\n");
    InOderTraverse(p);
    return 0;
}

在这里插入图片描述
五、赫夫曼树

代码：（别人的代码）

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
//哈夫曼树结点结构
typedef struct {
    int weight;//结点权重
    int parent, left, right;//父结点、左孩子、右孩子在数组中的位置下标
}HTNode, *HuffmanTree;
//动态二维数组，存储哈夫曼编码
typedef char ** HuffmanCode;
//HT数组中存放的哈夫曼树，end表示HT数组中存放结点的最终位置，s1和s2传递的是HT数组中权重值最小的两个结点在数组中的位置
void Select(HuffmanTree HT, int end, int *s1, int *s2)
{
    int min1, min2;
    //遍历数组初始下标为 1
    int i = 1;
    //找到还没构建树的结点
    while(HT[i].parent != 0 && i <= end){
        i++;
    }
    min1 = HT[i].weight;
    *s1 = i;
   
    i++;
    while(HT[i].parent != 0 && i <= end){
        i++;
    }
    //对找到的两个结点比较大小，min2为大的，min1为小的
    if(HT[i].weight < min1){
        min2 = min1;
        *s2 = *s1;
        min1 = HT[i].weight;
        *s1 = i;
    }else{
        min2 = HT[i].weight;
        *s2 = i;
    }
    //两个结点和后续的所有未构建成树的结点做比较
    for(int j=i+1; j <= end; j++)
    {
        //如果有父结点，直接跳过，进行下一个
        if(HT[j].parent != 0){
            continue;
        }
        //如果比最小的还小，将min2=min1，min1赋值新的结点的下标
        if(HT[j].weight < min1){
            min2 = min1;
            min1 = HT[j].weight;
            *s2 = *s1;
            *s1 = j;
        }
        //如果介于两者之间，min2赋值为新的结点的位置下标
        else if(HT[j].weight >= min1 && HT[j].weight < min2){
            min2 = HT[j].weight;
            *s2 = j;
        }
    }
}
//HT为地址传递的存储哈夫曼树的数组，w为存储结点权重值的数组，n为结点个数
void CreateHuffmanTree(HuffmanTree *HT, int *w, int n)
{
    if(n<=1) return; // 如果只有一个编码就相当于0
    int m = 2*n-1; // 哈夫曼树总节点数，n就是叶子结点
    *HT = (HuffmanTree) malloc((m+1) * sizeof(HTNode)); // 0号位置不用
    HuffmanTree p = *HT;
    // 初始化哈夫曼树中的所有结点
    for(int i = 1; i <= n; i++)
    {
        (p+i)->weight = *(w+i-1);
        (p+i)->parent = 0;
        (p+i)->left = 0;
        (p+i)->right = 0;
    }
    //从树组的下标 n+1 开始初始化哈夫曼树中除叶子结点外的结点
    for(int i = n+1; i <= m; i++)
    {
        (p+i)->weight = 0;
        (p+i)->parent = 0;
        (p+i)->left = 0;
        (p+i)->right = 0;
    }
    //构建哈夫曼树
    for(int i = n+1; i <= m; i++)
    {
        int s1, s2;
        Select(*HT, i-1, &s1, &s2);
        (*HT)[s1].parent = (*HT)[s2].parent = i;
        (*HT)[i].left = s1;
        (*HT)[i].right = s2;
        (*HT)[i].weight = (*HT)[s1].weight + (*HT)[s2].weight;
    }
}
//HT为哈夫曼树，HC为存储结点哈夫曼编码的二维动态数组，n为结点的个数
void HuffmanCoding(HuffmanTree HT, HuffmanCode *HC,int n){
    *HC = (HuffmanCode) malloc((n+1) * sizeof(char *));
    char *cd = (char *)malloc(n*sizeof(char)); //存放结点哈夫曼编码的字符串数组
    cd[n-1] = '\0';//字符串结束符
   
    for(int i=1; i<=n; i++){
        //从叶子结点出发，得到的哈夫曼编码是逆序的，需要在字符串数组中逆序存放
        int start = n-1;
        //当前结点在数组中的位置
        int c = i;
        //当前结点的父结点在数组中的位置
        int j = HT[i].parent;
        // 一直寻找到根结点
        while(j != 0){
            // 如果该结点是父结点的左孩子则对应路径编码为0，否则为右孩子编码为1
            if(HT[j].left == c)
                cd[--start] = '0';
            else
                cd[--start] = '1';
            //以父结点为孩子结点，继续朝树根的方向遍历
            c = j;
            j = HT[j].parent;
        }
        //跳出循环后，cd数组中从下标 start 开始，存放的就是该结点的哈夫曼编码
        (*HC)[i] = (char *)malloc((n-start)*sizeof(char));
        strcpy((*HC)[i], &cd[start]);
    }
    //使用malloc申请的cd动态数组需要手动释放
    free(cd);
}
//打印哈夫曼编码的函数
void PrintHuffmanCode(HuffmanCode htable,int *w,int n)
{
    printf("Huffman code : \n");
    for(int i = 1; i <= n; i++)
        printf("%d code = %s\n",w[i-1], htable[i]);
}
int main(void)
{
    int w[5] = {2, 8, 7, 6, 5};
    int n = 5;
    HuffmanTree htree;
    HuffmanCode htable;
    CreateHuffmanTree(&htree, w, n);
    HuffmanCoding(htree, &htable, n);
    PrintHuffmanCode(htable,w, n);
    return 0;
}