数据结构：树、二叉树、最小堆、二叉搜索树

于 2024-08-14 19:29:15 发布
阅读量306 收藏 3
点赞数 3
文章标签： 数据结构 算法 c语言 vscode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84247058/article/details/141197882
版权

目录

树

树的概念

树是一种重要的数据结构，广泛应用于计算机科学中。树的定义如下：

根节点：深度唯一，唯一没有父节点的节点

子结点：一个节点的后继节点

叶子节点：没有后继的子结点

深度：从根到节点的路径中边的数量，树的深度是所有叶子节点深度的最大值

路径：一个节点到另一个节点边构成的有序集合，任意两个节点的路径唯一

高度：节点到叶子节点中边的最大值

兄弟节点：拥有相同父节点的节点

除了根节点，每个节点有且仅有一个前驱节点（父节点），有 0 ～ n 个后继节点（子结点）；

一棵树由n个节点和n-1条边构成。

节点定义

struct node
{
    int data;					// 数据域
    struct node *first_child;	// 第一个子结点
    struct node *next_sibling;	// 下一个兄弟节点
}

二叉树（binary tree）

概念：每个节点最多只有两个子节点的树。

二叉树分类

满二叉树：每层节点都是满的，节点数量为2^n(n为节点深度)。

完全二叉树：与满二叉树相似，但叶子节点聚集左边。

最大（小）堆：父节点大于（或小于）子节点。

二叉搜索树：左子树小于父节点，右子树大于父节点。

实现

  1. 顺序存储，基于树组，时间复杂度为O(1)

    • 满二叉树
    • 完全二叉树
      • 堆
      • 优先级队列

    节点的父、子节点位置计算公式：（n为当前节点索引）

    • 父节点：n / 2 - 1
    • 子结点：n * 2 + 1（左子树）, n * 2 + 2（右子树）

  2. 链式存储，基于节点和指针

二叉树定义
struct node
{
    int data;			// 数据域
    struct node *left;	// 左子树
    struct node *right;	// 右子树
};

二叉树的遍历

  • 先序遍历：根节点->左子树->右子树
  • 中序遍历：左->根->右
  • 后续遍历：左->右->根
  • 层序遍历：从上往下，从左到右

堆

 12，9，23，5 ，17，42 ，56 ，11 ，20 ，3

最大堆：父节点大于子结点

最小堆：父节点小于子结点

构建一个最大堆：

​							56

​					 20			    42

​				17		9		12		23

​			5	 11	  3

每次取走堆顶元素后，把最后一个元素补到空缺处，再进行堆排序，这样可以保证堆内没有空缺

堆定义

struct heap
{
    int *data;  // 使用数组实现最小堆，避免空间浪费
    int size;
    int capacity;
};

实现一个最小堆

/*
 * @Author: ZPY
 * @TODO: 实现一个最小堆
 */

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

typedef struct heap
{
    int *data;  // 使用数组实现最小堆，避免空间浪费
    int size;
    int capacity;
} Heap;

void init(Heap *heap);
void insert(Heap *heap, int data);
void delete(Heap *heap);
void swap(int *, int *);
void display(Heap *heap);

int main(int argc, char const *argv[])
{
    Heap *heap = malloc(sizeof(Heap));

    // 初始化堆
    init(heap);

    // 插入元素 12,2,31,4,15,11,17,82,54
    insert(heap, 12);
    insert(heap, 2);
    insert(heap, 31);
    insert(heap, 4);
    insert(heap, 15);
    insert(heap, 11);
    insert(heap, 17);
    insert(heap, 82);
    insert(heap, 54);

    printf("堆中元素：");
    display(heap);

    // 删除堆顶元素
    delete(heap);
    printf("删除堆顶元素后，堆中元素：");
    display(heap);
    delete(heap);
    printf("删除堆顶元素后，堆中元素：");
    display(heap);

    free(heap);
    return 0;
}

void init(Heap *heap)
{
    heap->capacity = 10;
    heap->size = 0;
    heap->data = malloc(sizeof(int) * heap->capacity);
}

void insert(Heap *heap, int data)
{
    // 插入之前检查数组余量，满了就扩容为原来的 1.5 倍
    if (heap->size == heap->capacity - 1)
    {
        int incr = heap->capacity >> 1;
        heap->capacity += incr;
        heap->data = realloc(heap->data, sizeof(int) * heap->capacity);
    }
    heap->data[heap->size] = data;
    heap->size++;

    // 插入之后，从下往上调整
    for (int i = heap->size - 1; i > 0; i--)
    {
        int parent = (i - 1) >> 1;
        if (heap->data[parent] > heap->data[i])
        {
            swap(&heap->data[parent], &heap->data[i]);
        }
        else
        {
            break;
        }
    }
}

void delete(Heap *heap)
{
    // 如果堆为空，则返回
    if (heap == NULL)
    {
        return;
    }
    // 每次删除堆顶元素,将最后1个元素放到堆顶
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    if (heap->size == 0)
    {
        return;
    }
    // 删除之后，从上往下调整
    for (int i = 0; i < heap->size; i++)
    {
        int left = (i << 1) + 1;
        int right = (i << 1) + 2;
        // 父节点与最小的子节点交换
        if (right < heap->size && heap->data[right] < heap->data[left] && heap->data[right] < heap->data[i])
        {
            swap(&heap->data[right], &heap->data[i]);
        }
        else if (left < heap->size && heap->data[left] < heap->data[i])
        {
            swap(&heap->data[left], &heap->data[i]);
        }
        
    }

}

void display(Heap *heap)
{
    for (int i = 0; i < heap->size; i++)
    {
        printf("%d, ", heap->data[i]);
    }
    printf("\n");
}

void swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

输出结果

堆中元素：2, 4, 11, 12, 15, 31, 17, 82, 54, 
删除堆顶元素后，堆中元素：4, 12, 11, 54, 15, 31, 17, 82, 
删除堆顶元素后，堆中元素：11, 12, 17, 54, 15, 31, 82,

二叉搜索树

为实现快速的搜索，左子树比父节点小，右子树比父节点大。

12，9，23，5 ，17，42 ，56 ，11 ，20 ，3

构建一个二叉搜索树：

​						12

​					9		23

​				5	 11   17	42

​			3	_	_  _ _  20  _   56

遍历结果：

- 先序遍历：12；9；5；3；11；23；17；20；42；56
- 中序遍历：3；5；9；11；12；17；20；23；42；56      // 排序
- 后续遍历：3；5；11；9；20；17；56；42；23；12
- 层序遍历：12；9；23；5；11；17；42；3；20；56

完全二叉树的层序遍历：A，B，C，D，E，F，G，H，I，J，K

​						A

​				B				C

​			D		E		F		G

​		H	I	J	K 

先序：A，B，D，H，I，E，J，K，C，F，G

中序：H，D，I，B，J，E，K，A，F，C，G

后序：H，I，D，J，K，E，B，F，G，C，A

二叉搜索树的实现

/*
 * @Author: ZPY
 * @TODO: 二叉搜索树
 */

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

typedef struct node
{
    int data;           // 数据域
    struct node *left;  // 左子树
    struct node *right; // 右子树
} Node;

typedef struct node Tree;

// 队列结构
typedef struct queue
{
    Tree **data;    // 队列存储节点指针
    int front;
    int rear;
    int capacity;
    int size;
} Queue;


Node *insert(Tree *t, int v); // 插入
int max(Tree *t);             // 最大值，递归/循环
int min(Tree *t);             // 最小值
void preorder(Tree *t);       // 先序遍历
void inorder(Tree *t);        // 中序遍历
void postorder(Tree *t);      // 后序遍历
void levelorder(Tree *t);     // 层序遍历，基于队列
void reverse(Tree *t);        // 翻转
void free_tree(Tree *t);      // 释放
Queue *create_queue();        // 创建队列
void enqueue(Queue *q, Tree *t);// 入队
Tree *dequeue(Queue *q);        // 出队
void destory_queue(Queue *q);   // 销毁队列


int main(int argc, char const *argv[])
{
    // 创建根节点
    Tree *t = malloc(sizeof(Tree));

    // 12,2,31,4,15,11,17,82,54
    // 插入节点
    t = insert(NULL, 12); // 将插入的第一个值作为根，否则会默认把0作为根
    t = insert(t, 2);
    t = insert(t, 31);
    t = insert(t, 4);
    t = insert(t, 15);
    t = insert(t, 11);
    t = insert(t, 17);
    t = insert(t, 82);
    t = insert(t, 54);

    printf("最大值：%d\n", max(t));
    printf("最小值：%d\n", min(t));

    printf("先序遍历：");
    preorder(t);

    printf("\n中序遍历：");
    inorder(t);

    printf("\n后序遍历：");
    postorder(t);

    printf("\n层序遍历：");
    levelorder(t);

    printf("\n=============翻转树================");
    reverse(t);
    printf("\n");

    printf("先序遍历：");
    preorder(t);

    printf("\n中序遍历：");
    inorder(t);

    printf("\n后序遍历：");
    postorder(t);

    printf("\n层序遍历：");
    levelorder(t);
    printf("\n");

    free_tree(t);
    return 0;
}

Node *insert(Tree *t, int v)
{
    if (t == NULL)
    {
        // 创建根节点
        t = malloc(sizeof(Tree));
        t->data = v;
        t->left = t->right = NULL;
    }
    else if (v < t->data)
    {
        t->left = insert(t->left, v);
    }
    else if (v > t->data)
    {
        t->right = insert(t->right, v);
    }

    return t;
}

int max(Tree *t)
{
    int max = t->data;

    while (t->right) // 循环实现
    {
        max = t->right->data;
        t = t->right;
    }

    return max;
}

int min(Tree *t)
{
    if (t->left == NULL)
    {
        return t->data;
    }

    return min(t->left); // 递归实现，最左边的一定是最小的
}

void preorder(Tree *t)
{
    if (t == NULL)
    {
        return;
    }

    // 根->左->右
    printf("%d, ", t->data); // 访问根
    preorder(t->left);       // 递归遍历左子树
    preorder(t->right);      // 递归遍历右子树
}

void inorder(Tree *t)
{
    if (t != NULL)
    {
        // 左->根->右
        inorder(t->left);        // 递归遍历左子树
        printf("%d, ", t->data); // 访问根
        inorder(t->right);       // 递归遍历右子树
    }
}

void postorder(Tree *t)
{
    if (t != NULL)
    {
        // 左->右->根
        postorder(t->left);      // 递归遍历左子树
        postorder(t->right);     // 递归遍历右子树
        printf("%d, ", t->data); // 访问根
    }
}

void levelorder(Tree *t)
{
    if (t == NULL)
    {
        return;
    }
    Queue *q = create_queue();
    enqueue(q, t);
    while (q->size)
    {
        t = dequeue(q);
        printf("%d, ", t->data);
        if (t->left)
        {
            enqueue(q, t->left);
        }
        if (t->right)
        {
            enqueue(q, t->right);
        }
    }
    destory_queue(q);
}

void reverse(Tree *t)
{
    if (t == NULL)
    {
        return;
    }

    // 交换左右子树
    Tree *temp = t->left;
    t->left = t->right;
    t->right = temp;

    // 递归遍历左右子树
    reverse(t->left);
    reverse(t->right);
}

void free_tree(Tree *t)
{
    if (t != NULL)
    {
        free_tree(t->left);
        free_tree(t->right);
        free(t);
    }
}

// 创建队列
Queue *create_queue()
{
    Queue *q = malloc(sizeof(Queue));
    if (q == NULL)
    {
        printf("创建队列失败\n");
        return NULL;
    }
    q->front = 0;
    q->rear = 0;
    q->size = 0;
    q->capacity = 10;
    q->data = malloc(sizeof(Tree *) * q->capacity);

    return q;   // 返回队列指针
}

// 入队
void enqueue(Queue *q, Tree *t)
{
    if (q->size == q->capacity)
    {
        printf("队列已满\n");
        return;
    }
    q->data[q->rear] = t;  // 队尾入队
    q->rear = (q->rear + 1) % q->capacity;  // 队尾移到下一个位置
    q->size++;
}

// 出队
Tree *dequeue(Queue *q)
{
    if (q->size == 0)
    {
        printf("队列为空\n");
        return NULL;
    }
    Tree *t = q->data[q->front];
    q->data[q->front] = NULL;    // 清除指针
    q->front = (q->front + 1) % q->capacity;    // 队首移到下一个位置
    q->size--;


    return t;
}

// 销毁队列
void destory_queue(Queue *q)
{
    for (int i = 0; i < q->capacity; i++)
    {
        q->data[i] = NULL;
    }
    free(q->data);
    free(q);
}

输出结果

最大值：82
最小值：2
先序遍历：12, 2, 4, 11, 31, 15, 17, 82, 54, 
中序遍历：2, 4, 11, 12, 15, 17, 31, 54, 82, 
后序遍历：11, 4, 2, 17, 15, 54, 82, 31, 12, 
层序遍历：12, 2, 31, 4, 15, 82, 11, 17, 54, 
=============翻转树================
先序遍历：12, 31, 82, 54, 15, 17, 2, 4, 11, 
中序遍历：82, 54, 31, 17, 15, 12, 11, 4, 2, 
后序遍历：54, 82, 17, 15, 31, 11, 4, 2, 12, 
层序遍历：12, 31, 2, 82, 15, 4, 54, 17, 11,
小朱在敲代码
关注
哈夫曼树(最优二叉树)
qq_30166729的博客
11-25 1778
给定N个权值作为N个叶子节点，构造一个二叉树，带权路径长度总和最小，这样二叉树称做哈夫曼树，又称做最优二叉树。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 哈夫曼编码 数据通信中，需要将传输的文字转为二进制的字符串，为了使编码后字符串尽可能端，在不等长编码中，可以让使用频率高的字符用短码，频率低的字符使用长码。 为了使不等长编码为前缀编码（要求一个字符的编码不能是另一个字符的编码的前缀...
二叉树--二叉搜索树
Hy_2267的博客
04-11 711
编号2的二叉树中，叶子节点全都在最底层，除了叶子节点之外，每个节点都有左右两个子节点，这种二叉树就叫做满二叉树。 叶子节点都在最底下两层，最后一层的叶子节点都靠左排列，并且除了最后一层，其他层的节点个数都要达到最大，这种二叉树叫做完全二叉树。 如何表示（或者存储）一棵二叉树？ 链式存储法：一种是基于指针或者引用的二叉链式存储法 基于数组的顺序存储法：一种是基于数组的顺序存储法 把根节点存储在下标i = 1的位置，那左子节点存储在下标2 * i = 2的位置，右子节点存储在2 * i + 1..
几种二叉树的定义
HFGD2019的博客
10-18 2451
相关术语 节点：包含一个数据元素及若干指向子树分支的信息 节点的度：一个结点拥有子树的数目称为结点的度 叶子节点：也称为终端结点，没有子树的节点或者度为零的节点 分支节点：也称为非终端结点，度不为零的节点称为非终端节点 树的度：树中所有节点的度的最大值 节点的层次（深度）：从根节点开始，假设根节点为第1层，根节点的子节点为第2层，依此类推，如果某一个节点位于第L层，则其子节点位于第L+1层 树的高度：树中所有节点的层次最大值称为树的高度；高度是从下往上，深度是从上向下数 有序树：如果树中各棵子树的次序是有
二叉树
柳絮
09-16 314
二叉树 一：二叉树是树的特殊一种，具有如下特点： 1、每个结点最多有两颗子树，结点的度最大为2。 2、左子树和右子树是有顺序的，次序不能颠倒。 3、即使某结点只有一个子树，也要区分左右子树。 二：特殊的部分二叉树： 1、满二叉树：所有的分支结点都存在左子树和右子树，并且所有的叶子结点都在同一层上，这样就是满二叉树。就是完美圆满的意思，关键在于树的平衡。 根据满二叉树的定义，得到...
简单易懂的介绍----哈夫曼树
文艺的小码农专栏
11-21 1925
1、什么是哈夫曼树 哈夫曼树：它是 n 个带权叶子结点构成的所有二叉树中，带权路径长度 WPL 最小的二叉树（又称最优二叉树）。  WPL树的带权路径长度: wi表示权值 li表示树的深度 例如: 上面三棵树的带权路径长度分别是： WPL(1) = 4*2+7*3+5*3+2*1=46 WPL(2)=7*2+5*2+2*2+4*2=36 WPL(3)=7*1+5*...
关于数据结构中一些二叉树的定义
清风皓月长歌
08-02 1057
1、满二叉树 定义：除最后一层的结点外，每一层的所有结点都有两个子结点。 另外一个定义：深度为k且有2^k-1个结点的二叉树。   满二叉树是一颗树深度为h，最大层数为k，且深度与最大层数相同，即k=h; 它的叶子数是： 2^(h-1) 第k层的结点数是： 2^(k-1) 总结点数是： 2^k-1 (2的k次方减一) 总节点数一定是奇数。   2、完全二叉树
二叉树的二叉搜索表示.rar_二叉搜索树_二叉树的二叉搜索
09-22
遍历二叉搜索树：** 由于二叉搜索树的有序性，我们可以很容易地进行前序、中序和后序遍历。 - 前序遍历：根 -> 左 -> 右 - 中序遍历：左 -> 根 -> 右 - 后序遍历：左 -> 右 -> 根 遍历算法通常使用递归来实现。 ...
数据结构——二叉树搜索树（二叉搜索树的概念、实现、先序遍历、中序遍历、后序遍历）
qq_52301431的博客
08-24 801
二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树二叉搜索树是一颗二叉树, 可以为空；如果不为空，满足以下性质：- 非空左子树的所有键值小于其根结点的键值。- 非空右子树的所有键值大于其根结点的键值。- 左、右子树本身也都是二叉搜索树。二叉搜索树的特点:- 二叉搜索树的特点就是相对较小的值总是保存在左结点上, 相对较大的值总是保存在右结点上.- 那么利用这个特点, 我们可以做什么事情呢?- 查找效率非常高, 这也是二叉搜索树中, 搜索的来源.
数据结构（四）——二叉搜索树和平衡二叉树
LongXinKou的博客
04-13 1426
文章目录1. 二叉排序树（BST）1.1 二叉排序树的定义1.2 查找1.3 插入1.4 构造1.5 删除2. 二叉平衡树（AVL）2.1 平衡二叉树的定义2.2 插入 1. 二叉排序树（BST） 1.1 二叉排序树的定义 左子树上所有节点的值小于根节点的值。 右子树上所有节点的值大于根节点的值。 对二叉排序树进行中序遍历，可以获得递增的有序序列。 1.2 查找 （1）思想 二叉排序树的查找是从根节点开始，自顶向下比较的过程。 若相等，则查找成功。 当根节点非空时，若小于根节点的值，则在左子树上查找。
数据结构二叉树二叉搜索树堆相关C++代码.pdf
11-22
【二叉树与二叉搜索树】 在计算机科学中，二叉树是一种特殊的树结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树经常被用于实现各种算法，如搜索、排序等。二叉搜索树（Binary Search Tree...
二叉树最小深度
06-04
java求二叉树最小深度,注释十分详细，
动态规划-最小二叉搜索树（OBST)
Q1n6
04-10 5150
二叉查找树是按照二叉树结构来组织的，因此可以用二叉链表结构表示。二叉查找树中的关键字的存储方式满足的特征是：设x为二叉查找树中的一个结点。如果y是x的左子树中的一个结点，则key[y]≤key[x]。 递归解法（盗图~） 构造三个表，w表存储各节点出现频率，e表存储最优二叉搜索树的搜索成本期望值，root表存储最优子树的树根。 根据三个表，可以利用递归来构建最优二叉搜
最小二叉树
weixin_42770536的博客
03-31 3604
给定有序数组: [-10,-3,0,5,9], 一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树： 0 / \ -3 9 / / -10 5 #include<iostream> #include<Queue> using namespace std; struct T...
树10——求二叉树的高度和宽度
凌空的桨
04-02 3033
二叉树 二叉树采用二叉链表存储。（1）编写计算整个二叉树高度的算法。（2）编写计算二叉树最宽的算法。二叉树的最大宽度是指二叉树左右层中结点个数的最大值。 这是西北大学考研试题。 二叉树的高度递归定义为： 当二叉树为空时，其深度为0。当二叉树只有根结点时，即结点的左、右子树为空，二叉树的深度为1。其他情况下，二叉树的左、右子树高度的最大值再加1（根结点）就是二叉树的高度。 求二叉树的最大...
二叉树最大宽度和高度
bo-jwolf的专栏
07-19 2503
题目描述 Description     给出一个二叉树，输出它的最大宽度和高度。 输入描述 Input Description 第一行一个整数n。 下面n行每行有两个数，是这个二叉树连接到的节点的编号，如果没有连接到节点，则为0。 输出描述 Output Description 输出共一行，输出二叉树的最大宽度和高度，用
二叉树的宽度与高度
weixin_30501857的博客
07-20 205
分冶策略． 1.二叉树的高度 2.二叉树的宽度 3.比较两个二叉树是否相等 数据结构的定义 先定义一个简单的二叉树，由于只是演示，所以定义得比较简单． <span style="font-size:14px;"> #include <stdio.h> #define MAX(x,y) ((...
二叉树最小结构(C++版本)
xupeng1644的博客
12-11 1487
二叉树节点类型为ListNode struct BinaryTreeNode { BinaryTreeNode(int newData) : data(newData), pLeft(nullptr), pRight(nullptr) {} int data; BinaryTreeNode* pLeft; BinaryTreeNode* pRight; }; 二叉树类型为MyBinar...
二叉树的深度及宽度
qq_37740113的博客
05-21 223
#include <stdio.h> #include <stdlib.h> #define MaxSize 50 typedef struct BiTNode{ char data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; BiTree CreateBiTree( ){ char ...
关于二叉树的宽度，高度，相等
07-22 5055
关于二叉树的宽度，高度，相等2008-07-12 15:01:53|  分类： 面试题|字号 订阅经常会遇到关于二叉树的算法问题，虽然比较简单，不过我觉得还是有必要总结一下．顺便写了个sample程序，以供参考．本文中主要讨论关于二叉树的以下3个问题,都是用递归来实现，Divid
C#实现数据结构测试：最小堆与二叉搜索树
项目中特别关注了三种主要的数据结构：最小堆（Min Heap）、二叉搜索树（Binary Search Tree，简称BST）以及霍夫曼编码（Huffman Coding）。文件的标题暗示了它与C++语言编写的最小堆实现有关，描述则明确指出了C#...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值