先自我介绍一下,小编浙江大学毕业,去过华为、字节跳动等大厂,目前阿里P7
深知大多数程序员,想要提升技能,往往是自己摸索成长,但自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年最新大数据全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上大数据知识点,真正体系化!
由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新
如果你需要这些资料,可以添加V获取:vip204888 (备注大数据)
正文
3.2现实中的二叉树
当一名普通人看到这样一颗树,可能会想:好标准的一棵树
当一个程序猿看到这样一棵树,可能会想:好像数据结构中的二叉树,并且还是一颗满二叉树
甚至有人开玩笑说,有些公司甚至会不惜重金将这样一颗满二叉树买回来,种植在公司的门口,当员工每天经过树旁都要拜一拜,并且低声祈福:拜拜二叉树,bug都消失不见。足以看出二叉树在数据结构的地位之重了,所以小伙伴们一定要认真看完这篇文章呀!
3.3特殊的二叉树
在了解完二叉树的基础概念之后,在其中还存在着两颗特殊的树:
①满二叉树:一个二叉树且每一个层的结点数都达到最大值,也就是说,如果一个二叉树的层数为K,且结点总数是2^(k一1) ,则它就是满二叉树。
②完全二叉树:完全二叉树是效率很高的数据结构,完全二叉树是由满二叉树而引出来的。对于深度为K 的,有n个结点的二叉树,当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
注:完全二叉树在去掉最后一层后就是一颗满二叉树
3.4二叉树的性质
以下的的知识点小伙伴们一定要收藏好呀,做题的时候经常会用到滴!
①若规定根节点的层数为1,则一棵非空二叉树的第i层上最多有2^(i-1)个结点.
②若规定根节点的层数为1,则深度为h的二叉树的最大结点数是2^h-1.
③对任何一棵二叉树, 如果度为0其叶结点个数为n0 , 度为2的分支结点个数为n2 ,则有n0=n2 +1,也就是度为0的永远比度为2的多一个
④若规定根节点的层数为1,具有n个结点的满二叉树的深度h=log2(n+1) (ps: 是log以2 为底,n+1为对数)
⑤对于具有n个结点的完全二叉树,如果按照从上至下从左至右的数组顺序对所有节点从0开始编号,则对 于序号为i的结点有:
若i>0,i位置节点的双亲序号:(i-1)/2;i=0,i为根节点编号,无双亲节点
若2i+1=n否则无左孩子
若2i+2=n否则无右孩子
3.5二叉树的存储结构
二叉树一般可以使用两种结构存储,一种顺序结构,一种链式结构。
①顺序存储:顺序结构存储就是使用数组来存储,一般使用数组只适合表示完全二叉树,因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储,二叉树顺序存储在物理上是一个数组,在逻辑上是一颗二叉树。
②链式存储 :二叉树的链式存储结构是指,用链表来表示一棵二叉树,即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成,数据域和左右指针域,左右指针分别用来给出该结点左孩子和右孩子所 在的链结点的存储地址 。链式结构又分为二叉链和三叉链,当前我们学习中一般都是二叉链,只有在高阶数据结构如红黑树等会用到三叉链。
具体代码如下:
typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{
struct BinTreeNode* _pLeft; // 指向当前节点左孩子
struct BinTreeNode* _pRight; // 指向当前节点右孩子
BTDataType _data; // 当前节点值域
}
// 三叉链
struct BinaryTreeNode
{
struct BinTreeNode* _pParent; // 指向当前节点的双亲
struct BinTreeNode* _pLeft; // 指向当前节点左孩子
struct BinTreeNode* _pRight; // 指向当前节点右孩子
BTDataType _data; // 当前节点值域
};
四、二叉树的顺序结构及实现
4.1二叉树的顺序结构
普通的二叉树是不适合用数组来存储的,因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储,需要注意的是这里的堆和操作系统 虚拟进程地址空间中的堆是两回事,一个是数据结构,一个是操作系统中管理内存的一块区域分段。
4.2堆的概念及结构
如果有一个关键码的集合K = {k0 ,k1 ,k2,…,kn-1 },把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中,并满足: Ki<=K2*i+1 且 Ki<=K2*i+2 ( Ki>=K2*i+1 且 Ki>=K2*i+2) i = 0,1, 2…,则称为小堆(或大堆)。通俗的来说,在大堆中,双亲结点总是大于等于子结点,而在小堆中,双亲结点重视小于等于子结点。将根节点最大的堆叫做最大堆或大根堆,根节点最小的堆叫做最小堆或小根堆。
堆的性质:
●堆中某个节点的值总是不大于或不小于其父节点的值;
●堆总是一棵完全二叉树。
4.3堆的实现
4.3.1数据类型的定义与结构体
与数据结构的其他内容一样,在进行堆的功能实现之前,我们需要堆所存储的数据类型进行定义以及在调用这个堆的时候所使用的的结构体的定义。两者皆可根据读者的实际需求进行个性化定义,本文只是采取其中一种进行编写。
本文对堆的数据类型采取整形的形式,而对于结构体的定义,我们在其中定义了三个变量,分别是存储数据的数组a、数组元素的个数size、数组的最大存储元素个数capacity ,之所以要定义size和capacity两边变量是为了后续对数组内存储的元素个数与数组存储容量进行比较,从而进行扩容的操作。
具体代码如下:
//堆的初始化声明
void HeapInit(HP* php);
//堆的初始化实现
void HeapInit (HP* php)
{
assert(php);
HeapDataType* a = (HeapDataType)malloc(sizeof(HeapDataType) * 4);
if (a == NULL)
{
perror("malloc failed");
return;
}
php->a = a;
php->capacity = 4;
php->size = 0;
}
4.3.2堆的销毁
对于堆的销毁是十分简单的,只需将数组的空间释放,并将指针置空,变量置零即可
具体代码如下:
//堆的销毁声明
void HeapDestroy(HP* php);
//堆的销毁实现
void HeapDestroy(HP* php)
{
assert(php);
free(php->a);
php->a = NULL;
php->size = php->capacity = 0;
}
4.3.3堆的判空
由于前面我们在对结构体的变量定义中引入了**“size”变量来记录堆中所存储的元素个数**,因此我们只需要对“size”的值进行判断就可以知道此时堆是否为空
具体代码如下:
//堆的判空声明
bool HeapEmpty(HP* php);
//堆的判空实现
bool HeapEmpty(HP* php)
{
assert(php);
return php->size == 0;
}
4.3.4堆的数据个数
本功能的实现与堆的判空实现类似,通过返回“size”的值便能得到堆所存储的数据个数
具体代码如下:
//返回堆的数据个数声明
int HeapSize(HP* php);
//返回堆的数据个数实现
int HeapSize(HP* php)
{
assert(php);
return php->size;
}
4.3.5堆的堆顶数据
由于我们采取的是数组的形式来实现堆,因此堆顶的数据便对应数组中下标为0的元素,因此只需返回数组内下标为0的元素即可
具体代码如下:
//堆的堆顶数据函数声明
HeapDataType HeapTop(HP* php);
//堆的堆顶数据函数实现
HeapDataType HeapTop(HP* php)
{
assert(php);
return php->a[0];
}
4.3.6堆的插入
相比于前面几个功能的实现,堆的插入和删除就略显复杂了。那么堆的插入该如何实现呢?
对于堆的插入共分两步走:第一步就是先将数据插入到数组数据的末端,即尾插数据;不过在插入数据后,这个数据可能刚刚好满足我们大/小堆的要求,但也有可能破坏原有的堆结构,因此就有了第二步:调整堆内的数据,使其符合大/小堆的要求,但是如何调整数据呢,采取的是“**向上调整”**算法。
具体思路【以大堆为例】和代码如下:
//堆的向上调整声明
void AdjustUp(HeapDataType* a, int child);
//堆的向上调整实现
void AdjustUp(HeapDataType* a, int child)
{
int parent = (child - 1) / 2;
//大堆调整
while (parent >= 0 && parent != child) //或者以child>0作为判断条件,,parent >= 0 && parent!=child
{
if (a[child] > a[parent])
{
Swap(&a[child], &a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
//小堆调整
while (parent >= 0 && parent != child) //或者以child>0作为判断条件,,parent >= 0 && parent!=child
{
if (a[child] < a[parent])
{
Swap(&a[child], &a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
//堆的插入声明
void HeapPop(HP* php);
//堆的插入实现
void HeapPush(HP* php, HeapDataType x)
{
assert(php);
//判断堆是否满
if (php->size == php->capacity)
{
HeapDataType* tmp = (HeapDataType*)realloc(php->a,sizeof(HeapDataType)* php->capacity*2);
if (tmp == NULL)
{
perror("realloc failed");
return;
}
php->a = tmp;
php->capacity *= 2;
}
//插入数据
php->a[php->size] = x;
php->size++;
AdjustUp(php->a, php->size - 1);
}
4.3.7堆的删除
堆的删除一般是删除是堆顶的元素,有的小伙伴可能就想这还不简单吗,直接删除数组内下标为0的元素,再对堆进行调整不就好了。
从逻辑上说没啥问题,但是我们堆的物理结构并不是如此,由于采取数组的形式,是一种线性结构,一旦将栈顶元素移除,就会将堆的结构破坏,就可能出现以下这种情况,当栈顶元素没删除之前,咱们两个结点还是兄弟结点,但是删除之后,可能我们两就是就是父子结点,也就是我把你当兄弟,你却想当我爸爸,而这种调整在正常情况下是不会出现的,这可不滑稽极了。
于是就出现了以下这种思路:
①先将栈顶元素与栈尾元素互换位置
②“”删除”栈尾元素
③从栈顶开始进行“向下调整”算法
具体图片和代码如下:
//堆的向下调整声明
AdjustDown(HeapDataType* a, int n, int parent);
//堆的向下调整实现
void AdjustDown(HeapDataType* a, int n, int parent)
{
int child = 2 * parent + 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 = 2 * parent + 1;
}
else
{
break;
}
}
//小堆
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 = 2 * parent + 1;
}
else
{
break;
}
}
}
//堆的删除声明
void HeapPop(HP* php);
//堆的删除实现
void HeapPop(HP* php)
{
assert(php);
//判断堆是否为空
assert(!HeapEmpty(&php));
//交换数据
Swap(&php->a[0], &php->a[php->size - 1]);
//删除数据
php->size--;
//调整数据
AdjustDown(php->a, php->size, 0);
五、完整代码
//heap.h
#pragma once
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <stdlib.h>
//数据类型定义
typedef int HeapDataType;
//结构体定义
typedef struct Heap
{
HeapDataType* a;
int size;
int capacity;
}HP;
void HeapInit(HP* php); //堆的初始化
void HeapDestroy(HP* php); //堆的销毁
void HeapPush(HP* php, HeapDataType x); //堆的插入
void HeapPop(HP* php); //堆的删除
int HeapSize(HP* php); //返回堆的元素个数
int HeapSort(int*a,int n); //堆排序
bool HeapEmpty(HP* php); //判断堆是否为空
HeapDataType HeapTop(HP* php); //返回堆顶元素
void AdjustUp(HeapDataType* a, int child); //堆的向上调整
void AdjustDown(HeapDataType* a, int n, int parent); //堆的向下调整
//heap.c
#include "heap.h"
//堆的初始化
void HeapInit (HP* php)
{
assert(php);
HeapDataType* a = (HeapDataType)malloc(sizeof(HeapDataType) * 4);
if (a == NULL)
{
perror("malloc failed");
return;
}
php->a = a;
php->capacity = 4;
php->size = 0;
}
//堆的销毁
void HeapDestroy(HP* php)
{
assert(php);
free(php->a);
php->a = NULL;
php->size = php->capacity = 0;
}
//交换数据
void Swap(HeapDataType* p1, HeapDataType* p2)
{
HeapDataType tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
//堆的向上调整
void AdjustUp(HeapDataType* a, int child)
{
int parent = (child - 1) / 2;
//大堆调整
while (parent >= 0 && parent != child) //或者以child>0作为判断条件,,parent >= 0 && parent!=child
{
if (a[child] > a[parent])
{
Swap(&a[child], &a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
//小堆调整
while (parent >= 0 && parent != child) //或者以child>0作为判断条件,,parent >= 0 && parent!=child
{
if (a[child] < a[parent])
{
Swap(&a[child], &a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
//堆的插入
void HeapPush(HP* php, HeapDataType x)
{
assert(php);
//判断堆是否满
if (php->size == php->capacity)
{
HeapDataType* tmp = (HeapDataType*)realloc(php->a,sizeof(HeapDataType)* php->capacity*2);
if (tmp == NULL)
{
perror("realloc failed");
return;
}
php->a = tmp;
php->capacity *= 2;
}
//插入数据
php->a[php->size] = x;
php->size++;
AdjustUp(php->a, php->size - 1);
}
//
void AdjustDown(HeapDataType* a, int n, int parent)
{
int child = 2 * parent + 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 = 2 * parent + 1;
}
else
{
break;
}
}
//小堆
while (child < n)
**网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。**
**需要这份系统化的资料的朋友,可以添加V获取:vip204888 (备注大数据)**
![img](https://img-blog.csdnimg.cn/img_convert/990190e4e9c426374581bec780a521b5.png)
**一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!**
p->size++;
AdjustUp(php->a, php->size - 1);
}
//
void AdjustDown(HeapDataType* a, int n, int parent)
{
int child = 2 * parent + 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 = 2 * parent + 1;
}
else
{
break;
}
}
//小堆
while (child < n)
**网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。**
**需要这份系统化的资料的朋友,可以添加V获取:vip204888 (备注大数据)**
[外链图片转存中...(img-vQ5a765W-1713409005153)]
**一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!**