先自我介绍一下,小编浙江大学毕业,去过华为、字节跳动等大厂,目前阿里P7
深知大多数程序员,想要提升技能,往往是自己摸索成长,但自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年最新大数据全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上大数据知识点,真正体系化!
由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新
如果你需要这些资料,可以添加V获取:vip204888 (备注大数据)
正文
➡️方法:
- 1️⃣建堆
假如我们调转一下思路,排升序
不用小堆
,而是:
- 升序:建
大堆
- 降序:建
小堆
Eg:
- 2️⃣利用
堆删除
的思想进行排序
- 将
堆顶
的数据与堆尾
数据进行交换,这样就达到排好最大值的效果
- 将排好的数字不再纳入
建堆
中【即建堆
的目的就是选出最大值
,所以已经选出来的,就无需要再参加】 - 并将交换后产生新的树进行重新
建堆
【因为此时只有根节点发生变化,而左、右子树的关系并没有改变,所以可以利用向下调整算法
进行建堆】
- 重复上述步骤即可,直至
堆
里只剩下一个元素,才截止
✊动图示例: 完整过程
✊综上:堆排序的代码实现【时间复杂度:
O
(
N
∗
l
o
g
N
)
O(N*logN)
O(N∗logN)】
void ADjustDown(int \* a, int n, int parent)
{
//大堆
int child = parent \* 2 + 1;
while (child < n)
//当 孩子的下标 超出 数组的范围,则说明不存在
{
//1.选出左右孩子中,较小的一个
//child -- 左孩子下标;child+1 -- 右孩子下标
if (child + 1 < n && a[child + 1] > a[child])
{
//想象的时候:默认左孩子是比右孩子小
//如果大的话,child就走到右孩子下标处
child++;
}
//2.交换
if (a[child] > a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent \* 2 + 1;
}
else
{
//满足的情况
break;
}
}
}
void HeadSort(int\* a,int n)
{
//建堆 --- 时间复杂度:O(N)
//大堆
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
ADjustDown(a, n, i);
}
int end = n - 1;
while (end > 0)
//end = 0的时候就截止:即 长度为0就截止
{
Swap(&a[0], &a[end]);
//选出次大值
ADjustDown(a, end, 0);
end--;
}
}
**🥐Ⅱ.**Top-K问题
💡Top - K:
- 意思就是:求数据中
前K个
最大的元素或者最小的元素 - 比如:在高考出成绩时,需要对全省考生的成绩进行排序并取出前50名考生的成绩进行封锁,此时就涉及
Top-K
问题了
👉我们便以题目去理解它吧~
🏷️最小的K个数【难度:简单】
🔍题目传送门:
剑指 Offer 40. 最小的k个数 |
---|
输入整数数组 arr
,找出其中最小的 k
个数
例如,输入4、5、1、6、2、7、3、8这8个数字,则最小的4个数字是1、2、3、4
- 示例 1:
输入:arr = [3,2,1], k = 2
输出:[1,2] 或者 [2,1]
- 示例 2:
输入:arr = [0,1,2,1], k = 1
输出:[0]
💡解题关键: 找出前K
个最小的元素
➡️ 思路一:堆排序
- 利用我们刚刚所学的
堆排序
,对数组进行排序,然后取出前K
个即可
❗特别注意:
- 我们需要自己先实现一个
堆排序
,再进行使用 - 在用完
堆
后,记得销毁,否则会造成内存泄露
👉实现:
int\* getLeastNumbers(int\* arr, int arrSize, int k, int\* returnSize)
{
int\* returnArray = (int\*)malloc(k \* sizeof(int)) ;
HeadSort(arr,arrSize);
for(int i = 0; i < k; i++)
{
returnArray[i] = arr[i];
}
\*returnSize = k;
return returnArray;
}
💫但目前
堆排序
的效率为:O
(
N
∗
l
o
g
N
)
O(N*logN)
O(N∗logN),是否还能优化呢?
⭐答案是可以的
➡️ 思路二: 建堆
- 根据题意,我们只需要取出最小的前
K
个数即可,那我们便可以不对数组进行排序,而是利用小堆
的特性:每个父亲结点的值总是≤
孩子结点的值 - 只需要对这个数组进行
建堆
(建成小堆)即可,然后每次都取出根节点
(最小值),一共取K
次,便是最小的前K
个元素
❗特别注意:
- 我们需要自己先实现一个
堆
,再进行使用
👉实现:
1️⃣实现堆
typedef int HPDataType;
typedef struct Heap
{
HPDataType\* a;
int size;
int capacity;
}HP;
void Swap(HPDataType\* p1, HPDataType\* p2);
void AdjustDwon(HPDataType\* a, int size, int parent);
void AdjustUp(HPDataType\* a, int child);
void HeapDestroy(HP\* php);
void HeapPop(HP\* php);
HPDataType HeapTop(HP\* php);
void Swap(HPDataType\* p1, HPDataType\* p2)
{
HPDataType tmp = \*p1;
\*p1 = \*p2;
\*p2 = tmp;
}
void HeapInit(HP\* php, HPDataType\* a, int n)
{
assert(php);
php->a = (HPDataType\*)malloc(sizeof(HPDataType)\*n);
if (php->a == NULL)
{
printf("malloc fail\n");
exit(-1);
}
//1.拷贝
memcpy(php->a, a, sizeof(HPDataType)\*n);
php->size = n;
php->capacity = n;
//2.建堆
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDwon(php->a, php->size, i);
}
}
void HeapDestroy(HP\* php)
{
assert(php);
free(php->a);
php->a = NULL;
php->size = php->capacity = 0;
}
void AdjustUp(HPDataType\* a, int child)
{
int parent = (child - 1) / 2;
//while (parent >= 0)
while (child > 0)
{
//if (a[child] < a[parent])
if (a[child] > a[parent])
{
Swap(&a[child], &a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
//建小堆
void AdjustDwon(HPDataType\* a, int size, int parent)
{
int child = parent \* 2 + 1;
while (child < size)
{
// 选出左右孩子中小/大的那个
if (child+1 < size && 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 HeapPop(HP\* php)
{
assert(php);
assert(php->size > 0);
Swap(&(php->a[0]), &(php->a[php->size - 1]));
php->size--;
AdjustDwon(php->a, php->size, 0);
}
HPDataType HeapTop(HP\* php)
{
assert(php);
assert(php->size > 0);
return php->a[0];
}
2️⃣实现Top-K
int\* getLeastNumbers(int\* arr, int arrSize, int k, int\* returnSize)
{
HP hp;
HeapInit(&hp,arr,arrSize);
int\* retArr = (int\*)malloc(sizeof(int)\*k);
for(int i = 0;i < k; i++)
{
retArr[i] = HeapTop(&hp);
HeapPop(&hp);
}
HeapDestroy(&hp);
\*returnSize = k;
return retArr;
}
💫但目前
堆
的效率为:O
(
N
k
∗
l
o
g
N
)
O(N + k*logN)
O(N+k∗logN),是否还能优化呢?
⭐答案是可以的
➡️ 思路三: 建前K个数的堆
- 类似于
建堆
的操作,但不同的是,建堆
是对数组内全部元素进行调整 - 但我们现在只需要针对前
K
个数进行建堆即可
❗特别注意:
- 找前
k
个最大的元素,则建小堆
- 找前
k
个最小的元素,则建大堆
👉步骤:
- 1️⃣用数据集合中前
K
个元素来建堆【因为这里需要找前K
个最小的元素,所以建大堆
】 - 2️⃣剩余的
N-K
个元素(N
为总元素个数)依次与堆顶元素来比较,不满足则替换堆顶元素,再向下调整 - 3️⃣将剩余
N-K
个元素依次与堆顶元素比完之后,堆中剩余的K
个元素就是所求的前K
个最小或者最大的元素
【我们现在这里建的是大堆
,如果与堆顶元素比较时,外面的某个元素小于
堆顶的值,则为不满足】
❗特别注意:
-
🔴本质:通过数组剩下的
N-K
个元素,找到比前K
个元素的堆中的堆顶
元素小的元素,进行轮换- 1️⃣即在剩下的元素中,找到比堆顶还小的元素,不断轮换
堆
中元素的最大值 - 2️⃣因为要找的是最小的
K
个元素,所以最小的前K
个一定比大堆堆顶
的数据小,一定可以进堆中
- 1️⃣即在剩下的元素中,找到比堆顶还小的元素,不断轮换
-
🟡这也是为什么建
大堆
的原因,保证前K
个最小的元素中的最小值进来一定不会在堆顶
位置(以防前K
个最小的元素中的最大值进不来) -
🔵现在即使是前
K
个最小的元素中的最大值进堆,那前K-1
个最小的元素还是依然可以进堆 -
🟣直至这
K
个数据的堆不再进入元素,说明此时堆内的K
个数据就是前K
个最小的元素【堆外面没有比这K
个元素更小的数了】
⭐亮点:
- 1️⃣在面对大量数据且无论多大的时候,需要解决
Top-K
问题时,这个方法依然受用,因为我们始终是在维护一个K
个数的堆【只需要遍历剩下的元素进行比较、进堆、向下调整而已】 - 2️⃣此方法的时间复杂度始终为:
O
(
(
N
−
K
)
∗
l
o
g
K
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
需要这份系统化的资料的朋友,可以添加V获取:vip204888 (备注大数据)
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
最小的元素中的最大值进堆,那前K-1
个最小的元素还是依然可以进堆
- 🟣直至这
K
个数据的堆不再进入元素,说明此时堆内的K
个数据就是前K
个最小的元素【堆外面没有比这K
个元素更小的数了】
⭐亮点:
- 1️⃣在面对大量数据且无论多大的时候,需要解决
Top-K
问题时,这个方法依然受用,因为我们始终是在维护一个K
个数的堆【只需要遍历剩下的元素进行比较、进堆、向下调整而已】 - 2️⃣此方法的时间复杂度始终为:
O
(
(
N
−
K
)
∗
l
o
g
K
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
需要这份系统化的资料的朋友,可以添加V获取:vip204888 (备注大数据)
[外链图片转存中…(img-hESTpFuC-1713360214842)]
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!