✅博客主页:爆打维c-CSDN博客 🐾
🔹分享c语言知识及代码
目录
1.树概念及结构
1.1树的概念
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 有一个特殊的结点，称为根结点，根结点没有前驱结点除根结点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继 因此，树是递归定义的。注意：树形结构中，子树之间不能有交集，否则就不是树形结构。
1.2 树的相关概念
结点的度：一个结点含有的子树的个数称为该结点的度； 如上图：A的为6
叶结点或终端结点：度为0的结点称为叶结点； 如上图：B、C、H、I...等结点为叶结点
非终端结点或分支结点：度不为0的结点； 如上图：D、E、F、G...等结点为分支结点
双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图：A是B的父结点
孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点； 如上图：B是A的孩子结点
兄弟结点：具有相同父结点的结点互称为兄弟结点； 如上图：B、C是兄弟结点
树的度：一棵树中，最大的结点的度称为树的度； 如上图：树的度为6 结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；
树的高度或深度：树中结点的最大层次； 如上图：树的高度为4
堂兄弟结点：双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点
结点的祖先：从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先
子孙：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙
森林：由m（m>0）棵互不相交的树的集合称为森林；
1.3 树的表示
树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间 的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法 等。我们这里就简单的了解其中最常用的孩子兄弟表示法。
2.二叉树概念及结构
2.1概念
一棵二叉树是结点的一个有限集合
该集合: 1. 或者为空 2. 由一个根结点加上两棵别称为左子树和右子树的二叉树组成
请注意！
1. 二叉树不存在度大于2的结点
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
2.2 特殊的二叉树
1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是 说，如果一个二叉树的层数为K，且结点总数是，则它就是满二叉树。
2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K 的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对 应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树
文字繁多！直接上图！
2.3二叉树的性质
2.4二叉树的存储结构
二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构
1. 顺序存储
顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。
2. 链式存储
二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。链式结构又分为二叉链和三叉链。
3.二叉树顺序结构及实现
普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。
3.1 堆的概念及结构
堆就是以二叉树的顺序存储方式来存储元素，同时又要满足父亲结点存储数据都要大于儿子结点存储数据（也可以是父亲结点数据都要小于儿子结点数据）的一种数据结构。堆只有两种，即大堆和小堆，大堆就是父亲结点数据大于儿子结点数据，小堆则反之
堆的性质：
- 堆中某个结点的值总是不大于或不小于其父结点的值；
- 堆总是一棵完全二叉树。
3.2 堆的实现
题目：创建一个数组，要将它排序为小堆。
给出一个数组，逻辑上看做一颗完全二叉树。我们通过从根结点开始的向下调整算法可以把它调整 成一个小堆。向下调整算法有一个前提：左右子树必须是一个堆，才能调整。
int array[] = {27,15,19,18,28,34,65,49,25,37};🔹堆向下调整算法
调整过程如下：（以创建小堆为例）
1.设此时节点【27】（下标0）为父节点，【15】（下标1）为子节点。
2.比较父子节点，若子节点小于父节点则交换位置，反之则不改变位置。
3.调整父节点 子节点的指向
父节点定为【27】（下标1），子节点定为【18】（下标3）。
4.反复上述操作，直到子节点到叶子节点(度为0）则停止。
实现代码如下：
void AdjustDown(HPdataType* a, int n,int parent) { //n表示堆里面的元素个数
assert(a);
//int parent = 0;
//假设左孩子比较小 与右孩子相比
int child = parent * 2 + 1;
while (child <n) { //child>=n 孩子不存在 调整到叶子了
if (child + 1 < n && a[child] >a[child + 1]) {
//若右孩子比较小 则
child++;
}
if (a[child] <a[parent]) {
//孩子比父亲小 则交换数值
Swap(&(a[child]), &(a[parent]));
//继续往下
parent = child;
child = parent * 2 + 1;
}
else {
break;
}
}
}🔹堆向上调整算法
void AdjustUp(HPdataType* a, int child)
{
// 初始条件
// 中间过程
// 结束条件
int parent = (child - 1) / 2;
//while (parent >= 0)
while (child > 0)
{
if (a[child] < a[parent])
{
Swap(&a[child], &a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}3.3堆的创建
下面我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。根结点左右子树不是堆，我们怎么调整呢？这里我们从倒数的第一个非叶子结点的子树开始调整（此处用到向上调整算法），一直调整到根结点的树，就可以调整成堆。
int a[] = {1,5,3,8,7,6};
3.4堆的代码实现
//Heap.h
typedef int HPDataType;
typedef struct Heap
{
HPDataType* _a;
int _size;
int _capacity;
}Heap;
void HeapInit(HP* php);
// 堆的销毁
void HeapDestory(Heap* hp);
// 堆的插入
void HeapPush(Heap* hp, HPDataType x);
// 堆的删除
void HeapPop(Heap* hp);
// 取堆顶的数据
HPDataType HeapTop(Heap* hp);
// 堆的数据个数
int HeapSize(Heap* hp);
// 堆的判空
int HeapEmpty(Heap* hp);
//Heap.cpp
#include "Heap.h"
void Swap(HPDataType* x1, HPDataType* x2)
{
HPDataType x = *x1;
*x1 = *x2;
*x2 = x;
}
void AdjustDown(HPDataType* a, int n, int root)
{
int parent = root;
int child = parent*2+1;
while (child < n)
{
// 选左右孩纸中大的一个
if (child+1 < n
&& a[child+1] > a[child])
{
++child;
}
//如果孩子大于父亲，进行调整交换
if(a[child] > a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent*2+1;
}
else
{
break;
}
}
}
void AdjustUp(HPDataType* a, int n, int child)
{
int parent;
assert(a);
parent = (child-1)/2;
//while (parent >= 0)
while (child > 0)
{
//如果孩子大于父亲，进行交换
if (a[child] > a[parent])
{
Swap(&a[parent], &a[child]);
child = parent;
parent = (child-1)/2;
}
else
{
break;
}
}
}
void HeapInit(Heap* hp)
{
int i;
assert(hp);
hp->_a = NULL;
hp->_size = n;
hp->_capacity = n;
}
void HeapDestory(Heap* hp)
{
assert(hp);
free(hp->_a);
hp->_a = NULL;
hp->_size = hp->_capacity = 0;
}
void HeapPush(Heap* hp, HPDataType x)
{
assert(hp);
//检查容量
if (hp->_size == hp->_capacity)
{
hp->_capacity *= 2;
hp->_a = (HPDataType*)realloc(hp->_a, sizeof(HPDataType)*hp->_capacity);
}
//尾插
hp->_a[hp->_size] = x;
hp->_size++;
//向上调整
AdjustUp(hp->_a, hp->_size, hp->_size-1);
}
void HeapPop(Heap* hp)
{
assert(hp);
//交换
Swap(&hp->_a[0], &hp->_a[hp->_size-1]);
hp->_size--;
//向下调整
AdjustDown(hp->_a, hp->_size, 0);
}
HPDataType HeapTop(Heap* hp)
{
assert(hp);
return hp->_a[0];
}
int HeapSize(Heap* hp)
{
return hp->_size;
}
int HeapEmpty(Heap* hp)
{
return hp->_size == 0 ? 0 : 1;
}
void HeapPrint(Heap* hp)
{
int i;
for (i = 0; i < hp->_size; ++i)
{
printf("%d ", hp->_a[i]);
}
printf("\n");
}3.5 堆排序
堆排序即利用堆的思想来进行排序，总共分为两个步骤：
1. 建堆
升序：建大堆
降序：建小堆
2. 利用堆删除思想来进行排序
代码实现如下：
void HeapSort(HPdataType* a,int size) { //size为元素个数
int i = 0;
//1.先建成一个堆 降序建小堆 升序建大堆
//向上调整 时间复杂度O（N*logN)
/*for (i = size-1; i > 0; i--) {
AdjustUp(a, i);
}*/
//从第一个非叶节点开始，依次向下调整
//向下调整 时间复杂度O(N)
for (i = (size - 1 - 1) / 2; i >= 0; i--) {
AdjustDown(a, size, i);
}
int end = size-1; //元素下标最大为size-1
//2.把最小的与最后的数 交换位置 (end向前走）
//3.再向下调整 选出次小的 重复第一
while (end>0) {
Swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
end--;
}
}3.6 TOP-K问题
void PrintTopK(int* a, int k) {
int i = 0;
while (i < k) {
printf("%d ", a[i]);
i++;
}
}
void test03() {
//找TopK问题
srand(time(0));
int n = 10;
int* a = (int*)malloc(sizeof(int) * n);
int i = 0;
for (i = 0; i < n; i++) {
a[i] = rand() % 1000 + i;
//printf("%d ", a[i]);
}
a[1] = 100000;
a[5] = 2123213;
a[9] = 9999999;
/*法1：数据量小的时候
for (i = (n - 2) / 2; i >= 0; i--) {
AdjustDown(a, n, i);
}
for (i = n - 1; i > 0; i--) {
Swap(&a[0], &a[i]);
AdjustDown(a, i, 0);
}*/
int* ans = (int*)malloc(sizeof(int) * 5); //若内存有限 先创建一个小堆
for (i = 0; i < 5; i++) {
ans[i] = a[i];
}
for (i = (5 - 2) / 2; i >= 0; i--) {
AdjustDown(ans, 5, i);
}
for (i = 5; i < n;i++) { //剩余n-k个数据依次比较 若比堆顶大则成为新堆顶元素 再向下调整成为新堆
if (a[i] > ans[0]) {
ans[0] = a[i];
AdjustDown(ans, 5, 0);
}
}
HeapSort(ans, 5);
int k = 3;
PrintTopK(ans, k);
}本文仅简单介绍了有关二叉树的一些基本概念和相关代码实现，以上个人拙见，若有错误之处，希望各位能提出宝贵的建议和更正，感谢您的观看。
下篇博文将讲到 二叉树链式结构的实现
818
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
