数据结构6---树

看月落月升2024-06-22 9:02

一、定义

树(Tree)是n(n>=0)个结点的有限集。当n=0时成为空树,在任意一棵非空树中:

1、有且仅有一个特定的称为根(Root)的结点;

2、当n>1时,其余结点可分为m(m>日)个互不相交的有限集T1、T2、...、 Tm，其中每一个集合本身又是一棵树，并且称为根的子树(SubTree)。

需要注意的是：

1、n>6时，根结点是唯一的，坚决不可能存在多个根结点。

2、m>0时,子树的个数是没有限制的，但它们互相是一定不会相交的。

二、节点分类

刚才所有图片中，每一个圈圈我们就称为树的一个结点。结点拥有的子树数称为结点的度-

(Degree)，树的度取树内各结点的度的最大值。

1、度为0的结点称为叶结点(Leaf)或终端结点;

2、度不为0的结点称为分支结点或非终端结点，除根结点外，分支结点也称为内部结点。

三、结点间的关系

结点的子树的根称为结点的孩子(Child)，相应的，该结点称为孩子的双亲(Parent)，同一双亲的孩子之间互称为兄弟(Sibling)。

结点的祖先是从根到该结点所经分支上的所有结点。

四、节点的层次

  • 结点的层次(Level)从根开始定一起，根为第一层，根的孩子为第二层。
  • 其双亲在同一层的结点互为堂兄弟。
  • 树中结点的最大层次称为树的深度(Depth)或高度。

五、其他概念

  • 如果将树中结点的各子树看成从左至右是有次序的，不能互换的，则称该树为有序树，否则称为无序树。
  • 森林(Forest)是 m(m>=0)棵互不相交的树的集合。对树中每个结点而言，其子树的集合即为森林。

六、树的存储结构

1、双亲表示法

双亲表示法,言外之意就是以双亲作为索引的关键词的一种存储方式。

我们假设以一组连续空间存储树的结点，同时在每个结点中，附设一个指示其双亲结点在数组中位置的元素。

也就是说，每个结点除了知道自己是谁之外，还知道它的粑粑妈妈在哪里。

定义一个结构体

objectivec 复制代码 
#define MAXSIZE 100

typedef struct PTNode {
	int data;	//结点数据
	int parent;	//双亲位置
}PTNode;

typedef struct {
	PTNode node[MAXSIZE];
	int r;	//根的位置
	int n;	//节点数目
}PTree;

这样的存储结构，我们可以根据某结点的parent指针找到它的双亲结点,所用的时间复杂度是0(1)，索引到parent的值为-1时，表示找到了树结点的根。

可是，如果我们要知道某结点的孩子是什么?那么不好意思，请遍历整个树结构

2、孩子表示法

3、双亲孩子表示法

objectivec 复制代码 
//孩子节点
typedef struct CTNode {
	int child;	//孩子结点的下标
	struct CTNode* next;	//指向下一个孩子结点的指针
}*ChildPtr;

//表头结构
typedef struct {
	int data;	//存放在树中的节点数据
	int paraent;	//存放双亲的下标
	ChildPtr friendchild;	//指向第一个孩子的指针
}CTBox;

//树结构
typedef struct {
	CTBox node[MAXSIZE];
	int r, n;
}CTTree;

七、二叉树

1、定义

二叉树（Binary Tree）是n(n>=0）个结点的有限集合,该集合或者为空集（空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。

注意：

每个结点最多有两棵子树，所以二叉树中不存在度大于2的结点。（注意:不是都需要两棵子树，而是最多可以是两棵，没有子树或者有一棵子树也都是可以的。)

左子树和右子树是有顺序的，次序不能颠倒。

即使树中某结点只有一棵子树,也要区分它是左子树还是右子树，下面是完全不同的二叉树:

2、五种基本形态

（1）空二叉树

（2）只有一个根结点

（3）根结点只有左子树

（4）根结点只有右子树

（5）根结点既有左子树又有右子树

3、特殊二叉树

（1）斜树

斜树是一定要斜的，但斜也要斜寻有范儿

（2）满二叉树

在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上,这样的二叉树称为满二叉树。

特点：

  • 叶子只能出现在最下一层。
  • 非叶子结点的度一定是2。
  • 在同样深度的二叉树中，满二又树的结点个数一定最多，同时叶子也是最多。

（3）完全二叉树

对一棵具有n个结点的二叉树按层序编号，如果编号为i(1<=i<=n)的结点与同样深度的满二叉树中编号为i的结点位置完全相同，则这棵二叉树称为完全二叉树。

这个也是满二叉树

特点：

  • 叶子结点只能出现在最下两层。
  • 最下层的叶子一定集中在左部连续位置。
  • 倒数第二层，若有叶子结点，一定都在右部连续位置。
  • 如果结点度为1，则该结点只有左孩子。
  • 同样结点树的二叉树，完全二叉树的深度最小。

注意:满二叉树一定是完全二叉树，但完全二叉树不一定是满二叉树。

重点：

二叉树的性质一:在二叉树的第i层上至多2^(i-1)个结点(i>=1)

二叉树的性质二:深度为k的二叉树至多有2^k-1个结点(k>=1)

二叉树的性质三:对任何一棵二叉树T，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1

（打岔一下，在纸面上写写画画很重要的！！！）

二叉树的性质四:具有n个结点的完全二叉树的深度为 ,向下取整

二叉树的性质五:如果对一棵有n个结点的完全二叉树(其深度为[log2n]+1)的结点按层序编号，对任一结点i(1<=i<=n)有以下性质:

  1. 如果i =1，则结点i是二叉树的根，无双亲;如果i >1，则其双亲是结点
  2. 如果2i > n，则结点i无左孩子(结点i为叶子结点);否则其左孩子是结点2i
  3. 如果2i＋1 >n，则结点i无右孩子;否则其右孩子是结点2i+1

4、存储结构

（1）顺序存储

对于完全二叉树是十分方便的，但是一般二叉树就不行了，空间会造成极大的浪费

（2）链式存储！！！！

结点结构

代码

objectivec 复制代码 
typedef struct BiNode {
	int data;
	struct BiTNode* lchild, * rchild;
}BiTNode,*BiTree;

5、二叉树的遍历

（1）先序遍历

根------>左子树------>右子树

ABDHIEJCFKG

（2）中序遍历

左子树------>根------>右子树

HDIBEGAFKCG

（3）后序遍历

左子树------>右子树------>根

HIDJEBKFGCA

（4）层序遍历

ABCDEFGHIJK

八、二叉树的建立和遍历算法

代码（包括递归和非递归遍历）：

objectivec 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1;
#include <stdio.h>  
#include <stdlib.h>  

typedef struct TreeNode {
    char val;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

TreeNode* createTree(char** str) {
    //*str就是 char数组的指针
    if (**str == '#') {
        (*str)++;   //指针偏移
        return NULL;
    }

    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    node->val = **str;
    (*str)++;

    //这里递归实现，从根节点开始往左子树里填
    node->left = createTree(str);
    node->right = createTree(str);

    return node;
}

// 递归遍历  
void preOrderRecursive(TreeNode* root) {
    if (root == NULL) return;
    printf("%c ", root->val);
    preOrderRecursive(root->left);
    preOrderRecursive(root->right);
}

void inOrderRecursive(TreeNode* root) {
    if (root == NULL) return;
    inOrderRecursive(root->left);
    printf("%c ", root->val);
    inOrderRecursive(root->right);
}

void postOrderRecursive(TreeNode* root) {
    if (root == NULL) return;
    postOrderRecursive(root->left);
    postOrderRecursive(root->right);
    printf("%c ", root->val);
}

// 非递归遍历使用栈来辅助  
#define MAX_SIZE 100  
typedef struct {
    TreeNode* data[MAX_SIZE];
    int top;
} Stack;

void initStack(Stack* s) {
    s->top = -1;
}

int isEmpty(Stack* s) {
    return s->top == -1;
}

int isFull(Stack* s) {
    return s->top == MAX_SIZE - 1;
}

void push(Stack* s, TreeNode* node) {
    if (isFull(s)) return;
    s->data[++(s->top)] = node;
}

TreeNode* pop(Stack* s) {
    if (isEmpty(s)) return NULL;
    return s->data[(s->top)--];
}

void preOrderNonRecursive(TreeNode* root) {
    if (root == NULL) return;
    Stack s;
    initStack(&s);
    push(&s, root);
    while (!isEmpty(&s)) {
        TreeNode* node = pop(&s);
        printf("%c ", node->val);
        if (node->right) push(&s, node->right);
        if (node->left) push(&s, node->left);
    }
}

void inOrderNonRecursive(TreeNode* root) {
    Stack s;
    initStack(&s);
    TreeNode* cur = root;
    while (cur || !isEmpty(&s)) {
        while (cur) {
            push(&s, cur);
            cur = cur->left;
        }
        cur = pop(&s);
        printf("%c ", cur->val);
        cur = cur->right;
    }
}

void postOrderNonRecursive(TreeNode* root) {
    if (root == NULL) return;
    Stack s1, s2;
    initStack(&s1);
    initStack(&s2);
    push(&s1, root);
    while (!isEmpty(&s1)) {
        TreeNode* node = pop(&s1);
        push(&s2, node);
        if (node->left) push(&s1, node->left);
        if (node->right) push(&s1, node->right);
    }
    while (!isEmpty(&s2)) {
        TreeNode* node = pop(&s2);
        printf("%c ", node->val);
    }
}

int main() {
    char input[101];
    scanf("%s", input);
    char* str = input;
    TreeNode* root = createTree(&str);

    // 递归遍历  
    preOrderRecursive(root);
    printf("\n");
    inOrderRecursive(root);
    printf("\n");
    postOrderRecursive(root);
    printf("\n");

    // 非递归遍历  
    preOrderNonRecursive(root);
    printf("\n");
    inOrderNonRecursive(root);
    printf("\n");
    postOrderNonRecursive(root);
    printf("\n");

    return 0;
}

这里的递归好理解，对于非递归

九、线索二叉树

结构体

objectivec 复制代码 
//二叉树的二又线索存储表示
typedef struct BiThrNode{
    TElemType data;
    struct BiThrNode *lchild, *rchild;
    int LTag, RTag;
}BiThrNode, *BiThrTree;

用实线表示孩子节点，虚线表示前驱后继

中序线索代码实现

结构体

objectivec 复制代码 
typedef struct Thread {
	struct Thread* left_node, * right_node;//左右指针
	int data;//需要存放的数据
	/*默认0代表左右孩子 1代表前驱或者后继*/
	int left_type;//类型标志
	int right_type;//类型标志
}Node;

Node* pre;//前驱结点的变量
Node* head;//头指针 指向某种遍历的第一个结点

线索化

objectivec 复制代码 
void inOrderThreadTree(Node* node)
{
	//如果当前结点为NULL 直接返回
	if (node == NULL) {
		return;
	}
	//先处理左子树
	inOrderThreadTree(node->left_node);
	if (node->left_node == NULL)
	{
		//设置前驱结点
		node->left_type = 1;
		node->left_node = pre;
	}
	//如果结点的右子节点为NULL 处理前驱的右指针
	if (pre !=NULL && pre->right_node == NULL)
	{
		//设置后继
		pre->right_node = node;
		pre->right_type = 1;
	}
	//每处理一个节点 当前结点是下一个节点的前驱
	pre = node;
	//最后处理右子树
	inOrderThreadTree(node->right_node);
}

遍历

objectivec 复制代码 
void inOrderTraverse(Node* root)
{
	//从根节点开始先找到最左边
	if (root == NULL)
	{
		return;
	}
	Node* temp = root;
	//先找到最左边结点 然后根据线索化直接向右遍历
	while (temp != NULL && temp->left_type == 0)
	{
		temp = temp->left_node;
	}
	while (temp != NULL)
	{
		//输出
		temp = temp->right_node;
	}
}

这里停一下，时间不多，前驱后继就不写了哈

十、树、森林继二叉树的相互转换

1、树转换为二叉树

树转换成相应的二叉树分两个步骤:

  1. 在树中所有的兄弟结点之间加一连线
  2. 对每个结点，除了保留与其长子的连线外，去掉该结点与其他孩子的连线

只有左子树

2、森林到二叉树的转换

森林转换为二叉树分两个步骤:

  1. 先将森林中的每棵树变为二叉树
  2. 再将各二叉树的根结点视为兄弟从左至右连在一起，就形成了一棵二叉树

3、二叉树到树、森林的转换

  1. 若结点x是其双亲y的左孩子，则把x的右孩子，右孩子的右孩子，...,都与y用连线连起来。
  2. 去掉所有双亲到右孩子之间的连线

4、树与森林的遍历

树的遍历分为两种方式:一种是先根遍历，另一种是后根遍历。

  • 先根遍历:先访问树的根结点，然后再依次先根遍历根的每棵子树。
  • 后根遍历:先依次遍历每棵子树,然后再访问根结点。

先根遍历：ABEFCGDHIJ

后根遍历：EFBGCHIJDA

森林的遍历也分为前序遍历和后序遍历，其实就是按照树的先根遍历和后根遍历依次访问森林的每一棵树。

我们的惊人发现:树、森林的前根（序）遍历和二叉树的前序遍历结果相同，树、森林的后根（序）遍历和二叉树的中序遍历结果相同!

十一、哈夫曼树

1、定义

我们先把这两棵二叉树简化成叶子结点带权的二叉树（注:树结点间的连线相关的数叫做权,Weight) 。

  • 结点的路径长度:从根结点到该结点的路径上的连接数。 第一幅图C的就是3
  • 树的路径长度:树中每个叶子结点的路径长度之和。 第一幅图为1+2+3+3 = 9
  • 结点带权路径长度:结点的路径长度与结点权值的乘积。 第一幅图C的就是3*70=210
  • 树的带权路径长度:-WPL(Weighted Path Length)是树中所有叶子结点的带权路径长度之和。第一幅图为1*5+2*15+3*70+3*10 = 275

WPL的值越小，说明构造出来的二叉树性能越优。

构造过程：

1、构造森林全是根; 2、选用两小造新树;

3、删除两小添新人 ;4、重复2、3剩单根。

2、哈夫曼树的构建

结构体

objectivec 复制代码 
//哈夫曼树结点结构
typedef struct {
    int weight;//结点权重
    int parent, left, right;//父结点、左孩子、右孩子在数组中的位置下标
}HTNode, *HuffmanTree;

构建

objectivec 复制代码 
//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;
    }
}

3、重难点：哈夫曼编码

  1. 计算字符串中每个字符的频率

  2. 按照字符出现的频率进行排序，组成一个队列 Q

  3. 把这些字符作为叶子节点开始构建一棵哈夫曼树

  4. 对字符进行编码

哈夫曼树和编码都不唯一！只有树的WPL(带权路径长度)才是唯一的！

代码实现：

objectivec 复制代码 
#include <stdio.h>
#include <stdlib.h>

// 定义哈夫曼树节点结构
typedef struct HuffmanNode {
    char data;              // 字符
    int freq;               // 频率
    struct HuffmanNode* left, * right;   // 左右子节点
} HuffmanNode;

// 定义优先级队列结构
typedef struct PriorityQueue {
    int size;               // 队列当前大小
    int capacity;           // 队列容量
    HuffmanNode** array;    // 存储哈夫曼树节点的数组指针
} PriorityQueue;

// 创建哈夫曼树节点
HuffmanNode* createNode(char data, int freq) {
    HuffmanNode* node = (HuffmanNode*)malloc(sizeof(HuffmanNode));  // 分配内存空间
    node->data = data;  // 设置节点字符
    node->freq = freq;  // 设置节点频率
    node->left = node->right = NULL;   // 初始化左右子节点为空
    return node;  // 返回节点指针
}

// 创建优先级队列
PriorityQueue* createPriorityQueue(int capacity) {
    PriorityQueue* queue = (PriorityQueue*)malloc(sizeof(PriorityQueue));  // 分配内存空间
    queue->size = 0;  // 初始化队列大小为0
    queue->capacity = capacity;  // 设置队列容量
    queue->array = (HuffmanNode**)malloc(queue->capacity * sizeof(HuffmanNode*));  // 分配内存空间
    return queue;  // 返回队列指针
}

// 交换两个节点
void swapNodes(HuffmanNode** a, HuffmanNode** b) {
    HuffmanNode* temp = *a;
    *a = *b;
    *b = temp;
}

// 向下堆化
void minHeapify(PriorityQueue* queue, int idx) {
    int smallest = idx;
    int left = 2 * idx + 1;  // 计算左子节点索引
    int right = 2 * idx + 2;  // 计算右子节点索引

    // 找出三个节点中最小的节点
    if (left < queue->size && queue->array[left]->freq < queue->array[smallest]->freq) {
        smallest = left;
    }
    if (right < queue->size && queue->array[right]->freq < queue->array[smallest]->freq) {
        smallest = right;
    }

    // 如果最小节点不是当前节点，交换节点并递归向下堆化
    if (smallest != idx) {
        swapNodes(&queue->array[idx], &queue->array[smallest]);
        minHeapify(queue, smallest);
    }
}

// 插入节点
void insertNode(PriorityQueue* queue, HuffmanNode* node) {
    queue->size++;  // 队列大小加1
    int i = queue->size - 1;  // 获取最后一个位置的索引

    queue->array[i] = node;  // 将节点插入最后一个位置

    // 如果插入节点的频率小于父节点的频率，向上调整
    while (i && queue->array[i]->freq < queue->array[(i - 1) / 2]->freq) {
        swapNodes(&queue->array[i], &queue->array[(i - 1) / 2]);
        i = (i - 1) / 2;
    }
}

// 提取最小节点
HuffmanNode* extractMin(PriorityQueue* queue) {
    if (queue->size == 0) return NULL;  // 如果队列为空，返回空指针

    HuffmanNode* root = queue->array[0];  // 获取根节点
    queue->array[0] = queue->array[queue->size - 1];  // 将最后一个节点移到根节点位置
    queue->size--;  // 队列大小减1

    minHeapify(queue, 0);  // 向下堆化

    return root;  // 返回根节点
}

// 构建哈夫曼树
HuffmanNode* buildHuffmanTree(char data[], int freq[], int size) {
    PriorityQueue* queue = createPriorityQueue(size);  // 创建优先级队列

    // 将字符和频率构建成哈夫曼树节点，并插入优先级队列中
    for (int i = 0; i < size; i++) {
        insertNode(queue, createNode(data[i], freq[i]));
    }

    // 从优先级队列中不断取出最小的两个节点，构建哈夫曼树，直到队列中只剩一个节点
    while (queue->size != 1) {
        HuffmanNode* left = extractMin(queue);
        HuffmanNode* right = extractMin(queue);

        // 创建新节点作为父节点，频率为左右子节点频率之和
        HuffmanNode* top = createNode('\0', left->freq + right->freq);
        top->left = left;
        top->right = right;

        // 插入新节点到队列中
        insertNode(queue, top);
    }

    // 返回根节点
    return extractMin(queue);
}

// 打印哈夫曼编码
void printHuffmanCodes(HuffmanNode* root, int arr[], int top) {
    // 遍历树，生成编码
    if (root->left) {
        arr[top] = 0;
        printHuffmanCodes(root->left, arr, top + 1);
    }

    if (root->right) {
        arr[top] = 1;
        printHuffmanCodes(root->right, arr, top + 1);
    }

    // 当遍历到叶子节点时，打印字符及其编码
    if (!root->left && !root->right) {
        printf("%c: ", root->data);
        for (int i = 0; i < top; i++) {
            printf("%d", arr[i]);
        }
        printf("\n");
    }
}

// 主函数
int main() {
    char data[] = { 'a', 'b', 'c', 'd', 'e', 'f' };  // 字符集合
    int freq[] = { 5, 9, 12, 13, 16, 45 };           // 字符频率
    int size = sizeof(data) / sizeof(data[0]);       // 字符集合大小

    // 构建哈夫曼树
    HuffmanNode* root = buildHuffmanTree(data, freq, size);

    int arr[100];  // 存储编码的数组
    int top = 0;   // 记录编码
    // 打印哈夫曼编码
    printf("哈夫曼编码:\n");
    printHuffmanCodes(root, arr, top);

    return 0;
}

有点难，啧，我再想想

相关推荐
搬砖的小码农_Sky5 小时前
C语言：数组
c语言·数据结构
先鱼鲨生7 小时前
数据结构——栈、队列
数据结构
一念之坤7 小时前
零基础学Python之数据结构 -- 01篇
数据结构·python
IT 青年7 小时前
数据结构 （1）基本概念和术语
数据结构·算法
熬夜学编程的小王7 小时前
【初阶数据结构篇】双向链表的实现（赋源码）
数据结构·c++·链表·双向链表
liujjjiyun8 小时前
小R的随机播放顺序
数据结构·c++·算法
Reese_Cool9 小时前
【数据结构与算法】排序
java·c语言·开发语言·数据结构·c++·算法·排序算法
djk888810 小时前
.net将List＜实体1＞的数据转到List＜实体2＞
数据结构·list·.net
搬砖的小码农_Sky10 小时前
C语言：结构体
c语言·数据结构
_OLi_12 小时前
力扣 LeetCode 106. 从中序与后序遍历序列构造二叉树（Day9：二叉树）
数据结构·算法·leetcode
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作