【排序算法】总结篇

✨✨这些 排序算法都是指的 需要进行比较的排序算法

✨✨下面都是略微讲解一下思路，如果需要详细了解哪一个排序，点击👉链接即可

✨✨对于时间、空间复杂度、稳定性，希望你🧑‍🎓能够理解记忆🧑‍🎓而不是背表格

目录

一、稳定性定义：

 二、各个排序：

 1、直接插入排序：【排序算法】插入排序-CSDN博客

2、希尔排序：【排序算法】希尔排序-CSDN博客

3、选择排序：【排序算法】选择排序-CSDN博客

4、堆排序：【排序算法】堆排序(Heapsort)-CSDN博客

5、冒泡排序：【排序算法】冒泡排序-CSDN博客

6、快速排序：【排序算法】快速排序-CSDN博客

7、归并排序：【排序算法】归并排序-CSDN博客

三、性能比较：

Sort.h

Sort.c

 test.c

四、总结：​编辑

一、稳定性定义：

        排序算法的稳定性指的是在排序过程中，相等的元素在排序后保持它们原有的相对顺序。也就是说，如果两个元素在原始未排序的序列中是相等的，并且其中一个在另一个之前，那么在排序后的序列中，这个顺序依然保持不变。

当然使用可能对我们来说不够明显，但是在实践中，在对结构体进行排序非常有意义

✨👉 假设我们要按总分进行排名，但是如果总分相同的情况，按照数学成绩高的排前头，这个时候，我们先按照数学成绩排好序，相当于第一名是张三，那么按照总分拍好后，张三还是排在李四的前面，从这个表来看，第一是张三，第二是李四，第三是小翔，这就是稳定性，总分相同的情况下，张三还是在李四的前面

 二、各个排序：

 1、直接插入排序：【排序算法】插入排序-CSDN博客

✨直接插入排序的思想：前一个数有序，我拿这一个数和你比，如果比你小，前一个数往后移动。相当于插扑克牌，那么前一个和我手上的牌相等的话，不会取挪前一张牌。

所以》》 稳定性：✨稳定

时间复杂度：O(N^2)

空间复杂度：O(1)

稳定性：稳定

2、希尔排序：【排序算法】希尔排序-CSDN博客

✨希尔的思想是分gap组，对每个组都进行插入排序，然后gap会不断变小，当到1时进行直接插入排序，那么想想场景：👉👉相同的元素在预排序的时候如果被分到不同的组，顺序也可能被打断，那么就是不稳定，因为预排序无法控制，所以直接认为不稳定🧑‍🎓

时间复杂度：O(N^1.3)

空间复杂度：O(1)

稳定性：不稳定

3、选择排序：【排序算法】选择排序-CSDN博客

✨在数组里面选小的数，选到小的就更新一下，相同的不更新，然后继续找，直到遍历结束，把最小的放到左边🤔看着好像是稳定的，真是一回事，但是我们只是注意了小的耶🐸，忘记了我们在，在第一个位置的数的情况，如下：我的5和原来的5相对顺序是不是就已经发生改变了🤔记住这个例子它是不稳定的

时间复杂度：O(N^2)

空间复杂度：O(1)

稳定性：不稳定

4、堆排序：【排序算法】堆排序(Heapsort)-CSDN博客

✨思想：向下调整建堆，建好堆后，将尾元素和栈顶元素交换，交换以后，重现堆n-1个元素的堆进行调整；比如：全是2的大堆，将2取出来，全乱了，乱套了

时间复杂度：O(N*logN)

空间复杂度：O(1)

稳定性：不稳定

5、冒泡排序：【排序算法】冒泡排序-CSDN博客

✨思想：前一个和后一个比较，大于后一个就交换，相等的s；》》》稳定的

时间复杂度：O(N^2)

空间复杂度：O(1)

稳定性：稳定

6、快速排序：【排序算法】快速排序-CSDN博客

✨思想：找比kyi小的和比kyi大的，小的放前半部分，大的放到后半部分，最后kyi放到中间》》

kyi交换到后面，顺序乱了，所以✨不稳定

时间复杂度：O(N*logN)

空间复杂度：O(logN)

稳定性：不稳定

7、归并排序：【排序算法】归并排序-CSDN博客

✨思想：2个有序的数组合并，2个有序数组，相等的情况，取前一个尾插

✨ 稳定的

时间复杂度：O(NlogN)   

空间复杂度：O(N) 

稳定性：稳定

三、性能比较：

👉✨拿上代码可以自己测试玩哦，感兴趣的可以拿走;

Sort.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<assert.h>
#include"Stack.h"
#include<string.h>
//插入排序：有实践意义
void InsertSort(int* a, int n);
//希尔排序：
void ShellSort(int* a, int n);//堆排序：
void Swp(int* p1, int* p2);
void AdjustDwon(int* a, int n, int paret);
void HeapSort(int* a, int n);
//选择排序：
void SelectSort(int* a, int n);//冒泡排序：
void BubbleSort(int* a, int n);//快速排序：left和right传的都是下标
void QuickSort1(int* a, int left, int right);
//挖坑法
void QuickSort2(int* a, int left, int right);
//前后指针法：
void QuickSort3(int* a, int left, int right);
//非递归法：
void QuickSortNonR(int* a, int left, int right);//归并排序：
void MergeSort(int* a, int n);
//非递归：
void MergeSortNonR(int* a, int n);//计数排序：
void CountSort(int* a, int n);

Sort.c

#define _CRT_SECURE_NO_WARNINGS 3
#include"Sort.h"//堆排序：
//交换数据
void Swp(int* p1, int* p2)
{assert(p1 && p2);int tmp = *p2;*p2 = *p1;*p1 = tmp;
}
void AdjustDwon(int* a, int n, int parent)
{assert(a);//孩子int child = parent * 2 + 1;while (child<n){if (child + 1 < n && a[child + 1] > a[child]){child = child + 1;}if (a[parent] < a[child]){Swp(&a[parent], &a[child]);parent = child;child = parent * 2 + 1;}else{break;}}
}
void HeapSort(int* a, int n)
{//向下调整建堆int i;for (i = (n - 1 - 1) / 2; i >= 0; i--){AdjustDwon(a, n, i);}for (i = n - 1; i > 0; i--){Swp(&a[0], &a[i]);AdjustDwon(a, i, 0);}
}
//选择排序：
//void SelectSort(int* a, int n)
//{
//	for (int i = 0; i < n; i++)
//	{
//		int min = i;
//		for (int j = i; j < n; j++)
//		{
//			if (a[j] < a[min])
//			{
//				min = j;
//			}
//		}
//		Swp(&a[min], &a[i]);
//	}
//
//}
选择排序
//void SelectSort(int* a, int n)
//{
//	int begin = 0, end = n - 1;
//	while (begin < end)
//	{
//		int mini = begin, maxi = begin;
//		for (int i = begin + 1; i <= end; ++i)
//		{
//			if (a[i] > a[maxi])
//			{
//				maxi = i;
//			}
//
//			if (a[i] < a[mini])
//			{
//				mini = i;
//			}
//		}
//		if (mini == end && maxi == begin)
//		{
//			Swp(&a[maxi], &a[mini]);
//			
//		}
//		else if (maxi == begin)
//		{
//			//谁先换掉
//			Swp(&a[end], &a[maxi]);
//			Swp(&a[begin], &a[mini]);
//		}
//		else
//		{
//			Swp(&a[begin], &a[mini]);
//			Swp(&a[end], &a[maxi]);
//		}
//		begin++;
//		end--;
//	}
//}
void SelectSort(int* a, int n)
{int begin = 0;int end = n - 1;while (begin < end){int maxi = begin;int mini = begin;for (int i = begin + 1; i <= end; i++){if (a[maxi] < a[i]){maxi = i;}if (a[mini] > a[i]){mini = i;}}Swp(&a[mini], &a[begin]);if (maxi == begin){maxi = mini;}Swp(&a[maxi], &a[end]);begin++;end--;}
}//插入排序：end+1前面的是有序的，不断拿end+1去比较
void InsertSort(int* a, int n)
{int i;for (i = 0; i < n - 1; i++){int end = i;int tmp = a[end + 1];while (end >= 0){if (a[end] > tmp){a[end + 1] = a[end];end--;}else{break;}}a[end + 1] = tmp;}
}//希尔排序:插入的优化，1、预排序 2、插入排序
void ShellSort(int* a, int n)
{int gap = n;//gap的组数越大，数据可以更快的跳到后面，小的更快跳到前面，但是越不接近有序；反之，gap越接近有序while (gap > 1){//巧妙的用的除法，/2 /3 /4都行，但是有人证明了/3更好，还要加1，因为gap小于3的话gap/3==0//最后一次gap一定是1,也就是插入排序，数据变成有序的呢！！！gap = gap / 3 + 1;for (int i = 0; i < n - gap; i++){int end = i;int tmp = a[end + gap];while (end >= 0){if (a[end] > tmp){a[end + gap] = a[end];end -= gap;}else{break;}}a[end + gap] = tmp;}}}
//4层循环(方法二)
//void ShellSort(int* a, int n)
//{
//
//	int gap = n;
//	while (gap > 1)
//	{
//		gap = gap / 3 + 1;
//		for (int i = 0; i < gap; i++)
//		{
//			for (int j = i; j < n - i-gap; j += gap)
//			{
//				int end = j;
//				int tmp = a[end + gap];
//				while (end >= 0)
//				{
//					if (a[end] > tmp)
//					{
//						a[end + gap] = a[end];
//						end -= gap;
//					}
//					else
//					{
//						break;
//					}
//				}
//				a[end + gap] = tmp;			}
//		}
//
//	}
//
//
//}//冒泡排序：
void BubbleSort(int* a, int n)
{int i;for (i = 0; i < n - 1; i++){int flag = 0;//从前往后冒泡，第一趟最后一个为最大值；只要n-1趟即可for (int j=1; j < n-i; j++){if (a[j] < a[j - 1]){int tmp = a[j];a[j] = a[j - 1];a[j - 1] = tmp;flag = 1;}}if (flag == 0){break;}}}//快速排序：
//递归实现：
//优化：先三个数找中间：
int GetMin(int* a, int left, int right)
{int min = ((right - left) >> 1)+ left;if (a[min] < a[left]){if (a[min] > a[right]){return min;}else if (a[right]<a[left]){return right;}else{return left;}}else{if (a[min] < a[right]){return min;}else if (a[right] > a[left]){return right;}else{return left;}}}
//Hoare
void QuickSort1(int* a, int left, int right)
{//递归结束条件/*if (right <= left){return;}*///优化后：递归结束条件变成了当剩下10个以内的元素需要排序时，就使用插入排序if (right - left + 1 < 10){InsertSort(a + left, right - left + 1);}else {//3个取中int mid = GetMin(a, left, right);//将中的元素换到leftSwp(&a[mid], &a[left]);int keyi = left;int begin = left;int end = right;while (begin < end){//右边找小的，左边找大的while (a[end] >= a[keyi] && end > begin){end--;}while (a[begin] <= a[keyi] && end > begin){begin++;}//交换Swp(&a[begin], &a[end]);}Swp(&a[keyi], &a[begin]);QuickSort1(a, left, begin - 1);QuickSort1(a, end + 1, right);}
}
//挖坑法(有一个人要蹲坑)效率差不多
void QuickSort2(int* a, int left, int right){if (right - left + 1 < 10){InsertSort(a + left, right - left + 1);}else{int mid = GetMin(a, left, right);Swp(&a[left], &a[mid]);int keyi = a[left];int begin = left;int end = right;while (begin < end){//仍然是左边找大，右边找小while (begin < end && a[end] >= keyi){end--;}a[begin] = a[end];while (begin < end && a[begin] <= keyi){begin++;}a[end] = a[begin];}a[end] = keyi;QuickSort2(a, left, begin - 1);QuickSort2(a, end + 1, right);}}
//前后指针法：
void QuickSort3(int* a, int left, int right)
{/*if (left >= right){return;}*/if (right - left + 1 < 10){//小于10个数据进行插入排序InsertSort(a + left, right - left + 1);}else{int mid = GetMin(a, left, right);Swp(&a[mid], &a[left]);int keyi = left;int prev = left;int cur = left + 1;//cur先走，找小的while (cur <= right){//若小于a[keyi]则prev后移一位 再交换if (a[cur] <= a[keyi]){prev++;Swp(&a[prev], &a[cur]);}cur++;}Swp(&a[prev], &a[keyi]);QuickSort3(a, left, prev - 1);QuickSort3(a, prev + 1, right);}
}
//非递归，将递归变成迭代，最重要的是区间
void QuickSortNonR(int* a, int left, int right)
{SL pts;SLInit(&pts);SLPush(&pts,right);SLPush(&pts, left);while (!SLEmpty(&pts)){int begin = SLPot(&pts);SLPop(&pts);int end = SLPot(&pts);SLPop(&pts);int mid = GetMin(a, begin,end);Swp(&a[mid], &a[begin]);int keyi = begin;int prev = begin;int cur = begin + 1;//cur先走，找小的while (cur <= end){//若小于a[keyi]则prev后移一位 再交换if (a[cur] <= a[keyi]){prev++;Swp(&a[prev], &a[cur]);}cur++;}Swp(&a[prev], &a[keyi]);if (prev + 1 < end){SLPush(&pts, end);SLPush(&pts, prev + 1);}if (prev - 1 > begin){SLPush(&pts, prev-1);SLPush(&pts, 0);}}SLDestroy(&pts);}//归并排序:
//子函数:实现递归
void _MergeSort(int* tmp, int* a, int left, int right)
{if (left >= right){return;}int mid = ((right-left)>>1)+left;_MergeSort(tmp, a, left, mid);_MergeSort(tmp, a, mid + 1,right);int begin1 = left;int end1 = mid;int begin2 = mid + 1;int end2 = right;int i = 0;while (begin1 <= end1 && begin2 <= end2){if (a[begin1] <= a[begin2]){tmp[i++] = a[begin1++];}else{tmp[i++] = a[begin2++];}}while (begin1 <= end1){tmp[i++] = a[begin1++];}while (begin2 <= end2){tmp[i++] = a[begin2++];}memcpy(a + left, tmp, (right - left + 1)*sizeof(int));}
void MergeSort(int* a, int n)
{int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc fail");return;}_MergeSort(tmp, a, 0, n-1);free(tmp);tmp = NULL;
}
//非递归归并
void MergeSortNonR(int* a, int n)
{//额外创造一个空间int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc fail");return;}int gap = 1;while (gap < n){for (int i = 0; i < n; i+=2*gap){int begin1 = i;int end1 = i + gap - 1;int begin2 = i + gap;int end2 = i + 2 * gap-1;int j = i;if (begin2>=n){break;}	 if (end2 >= n){end2 = n - 1;}//printf("[%d,%d][%d,%d]", begin1, end1, begin2, end2);while (begin1 <= end1 && begin2 <= end2){if (a[begin1] < a[begin2]){tmp[j++] = a[begin1++];}else{tmp[j++] = a[begin2++];}}while (begin1 <= end1){tmp[j++] = a[begin1++];}while (begin2 <= end2){tmp[j++] = a[begin2++];}memcpy(a + i, tmp+i, sizeof(int)*(end2 - i + 1));}putchar('\n');gap *= 2;}free(tmp);tmp = NULL;
}//计数排序：
void CountSort(int* a, int n)
{//求最大和最小值int max = a[0];int min = a[0];for (int i = 1; i < n; i++){if (a[i] < min){min = a[i];}if (a[i] > max){max = a[i];}}int ragem = max - min + 1;//计数的数组int* count = (int*)calloc(ragem, sizeof(int));;if (count == NULL){perror("calloc fail");return;}//计数for (int i = 0; i < n; i++){count[a[i] - min]++;}int j = 0;//排序for (int i = 0; i< ragem; i++){while (count[i]--){a[j++] = i+ min;}}}

 test.c

#define _CRT_SECURE_NO_WARNINGS 3#include"Sort.h"//打印
void InPrin(int* a, int n)
{int i;for (i = 0; i < n; i++){printf("%d ", a[i]);}
}
//验证函数是否成功
void SortTest()
{int a[] = { 10,9,7,1,3,9,4,2,12,3,5,7};int n = sizeof(a) / sizeof(a[0]);//HeapSort(a, n);/*printf("InsertSort:");InsertSort(a, n);InPrin(a, n);putchar('\n');puts("对比");printf("ShellSort:");*///ShellSort(a, n);//InPrin(a, n);//BubbleSort(a, n);//SelectSort(a, n);//QuickSort1(a, 0, n - 1);//QuickSort3(a, 0, n - 1);//QuickSortNonR(a, 0, n - 1);//MergeSort(a, n);//MergeSortNonR(a, n);CountSort(a, n);InPrin(a, n);
}
//性能测试
void SortTest1()
{int n = 10000000;srand((unsigned int)time(NULL));int* a1 = (int*)malloc(sizeof(int) * n);if (a1 == NULL){perror("malloc:a1");return;}int* a2 = (int*)malloc(sizeof(int) * n);if (a2 == NULL){perror("malloc:a2");return;}int* a3 = (int*)malloc(sizeof(int) * n);if (a3 == NULL){perror("malloc:a3");return;}int* a4 = (int*)malloc(sizeof(int) * n);if (a4 == NULL){perror("malloc:a4");return;}int* a5 = (int*)malloc(sizeof(int) * n);if (a5 == NULL){perror("malloc:a5");return;}int* a6 = (int*)malloc(sizeof(int) * n);if (a6 == NULL){perror("malloc:a6");return;}int* a7 = (int*)malloc(sizeof(int) * n);if (a7 == NULL){perror("malloc:a7");return;}int* a8 = (int*)malloc(sizeof(int) * n);if (a8 == NULL){perror("malloc:a8");return;}for (int i = 0; i < n; i++){//尽可能保证多个随机数a1[i] = rand()+i;a2[i] = a1[i];a3[i] = a1[i];a4[i] = a1[i];a5[i] = a1[i];a6[i] = a1[i];a7[i] = a1[i];a8[i] = a1[i];}//冒泡int begin1 = clock();//BubbleSort(a1, n);int end1 = clock();//堆排序int begin2 = clock();HeapSort(a2, n);int end2 = clock();//希尔int begin3 = clock();ShellSort(a3, n);int end3 = clock();//插入（数据太多，也得下桌）int begin4 = clock();//InsertSort(a4, n);int end4 = clock();//选择(下桌，太慢了，影响到其他数据计算)int begin5 = clock();//SelectSort(a5,n);int end5 = clock();//快排int begin6 = clock();QuickSort3(a6, 0, n - 1);int end6 = clock();int begin7 = clock();MergeSort(a7, n);//MergeSortNonR(a7, n);int end7 = clock();int begin8 = clock();CountSort(a8, n);int end8 = clock();printf("BubbleSort:%d\n", end1 - begin1);printf("HeadSort:%d\n", end2 - begin2);printf("ShellSort:%d\n", end3 - begin3);printf("InsertSort:%d\n", end4 - begin4);printf("SelectSort:%d\n", end5 - begin5);printf("QuickSort:%d\n", end6 - begin6);printf("MergeSort:%d\n", end7 - begin7);printf("CountSort:%d\n", end8 - begin8);free(a1);a1 = NULL;free(a2);a2 = NULL;free(a3);a3 = NULL;free(a4);a4 = NULL;free(a5);a5 = NULL;free(a6);a6 = NULL;free(a7);a7 = NULL;free(a8);a8 = NULL;
}int main()
{//SortTest();SortTest1();return 0;
}

四、总结：排序算法

提醒一句：希望你还是通过代码理解性的记忆，明确这个值是怎么计算出来的，而不是记住冰冷的表格❤️🫰

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/bicheng/24743.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

如何优化Vue组件的性能和通信效率？

如何优化Vue组件的性能和通信效率？

优化Vue组件的性能和通信效率涉及多个方面&#xff0c;包括组件的设计、懒加载、条件渲染、事件通信以及避免不必要的重新渲染等。下面是一些实用的优化策略&#xff1a; 组件懒加载&#xff1a; 使用异步组件加载机制&#xff0c;只有在组件需要显示时才去加载该组件。例如&a…
阅读更多...
Science刊发！乌普萨拉大学最新神经形态触觉人造皮肤可快速精准识别物体

Science刊发！乌普萨拉大学最新神经形态触觉人造皮肤可快速精准识别物体

当前&#xff0c;人形机器人使用的传统电子皮肤在处理触觉感知信息方面的能力并不强&#xff0c;尤其是在时间信息编码和快速特征提取方面存在一定的局限性。简单来说就是机器人无法完成在接触到物品的瞬间&#xff0c;判断用怎样的力度去对该物品做出反应。尽管多模态大模型和…
阅读更多...
顶级域名和二级域名的区别

顶级域名和二级域名的区别

互联网是一个由无数个网络节点组成的复杂系统&#xff0c;而域名则是这个系统中用于识别和定位这些节点的重要工具。在域名体系中&#xff0c;顶级域名(Top-Level Domain&#xff0c;TLD)和二级域名(Second-Level Domain&#xff0c;SLD)是两个基本的层级概念。本文将探讨这两者…
阅读更多...
备战 清华大学 上机编程考试-冲刺前50%,倒数第6天

备战 清华大学 上机编程考试-冲刺前50%,倒数第6天

真题训练&#xff1a; T1:舞蹈团 - 排序滑动窗口 生活在在外星球X上的小Z想要找一些小朋友组成一个舞蹈团&#xff0c;于是他在网上发布了信息&#xff0c;一共有 \(n\) 个人报名面试。面试必须按照报名的顺序依次进行。小Z可以选择在面试完若干小朋友以后&#xff0c;在所有…
阅读更多...
手搓文件格式转换

手搓文件格式转换

最初目标&#xff1a; 自己搞一个免费的pdf文件转换 根据现有的开源jar 项目实现思路&#xff1a; 1. 项目原因a. 我想转换文件b. wps 文件转换 2. 最初的状态a. jar运行的b. main,输入文件路径c. 一定的编程能力的人才能得 3. 开始构思项目a. 网页版本b. 想着大家一起用 4. …
阅读更多...
MyBatis二级缓存开启条件

MyBatis二级缓存开启条件

MyBatis缓存为俩层体系。分为一级缓存和二级缓存。 一级缓存&#xff1a; 一级缓存默认开启&#xff0c;一级缓存的作用域是SqlSession级别的&#xff0c;这意味着当你更换SqlSession之后就不能再利用原来的SqlSession的一级缓存了。不同的SqlSession之间的一级缓存是隔离的。…
阅读更多...
Django更改超级用户密码

Django更改超级用户密码

Django更改超级用户密码 1、打开shell 在工程文件目录下敲入&#xff1a; python manage.py shell再在python交互界面输入&#xff1a; from django.contrib.auth.models import User user User.objects.get(username root) user.set_password(123456) user.save()其中ro…
阅读更多...
adb 删除文件或文件夹

adb 删除文件或文件夹

1. 通过adb shell 进入终端shell 2. cd sdcard/data //进入系统内指定文件夹 3. ls //列表显示当前文件夹内容 4. remount //挂载 5. rm -r xxx // 删除名字为xxx的文件夹及其里面的所有文件 6. rm xxx // 删除文件xxx 7. rm dir xxx // 删除xxx的文件夹 8. cat 123…
阅读更多...
递归【2】（组合回溯（生成括号）、子集回溯（背包问题））

递归【2】（组合回溯（生成括号）、子集回溯（背包问题））

括号对 &#xff08;组合型回溯&#xff09; 分解成子问题&#xff0c;每一次添加括号分两步&#xff1a; if左括号小于n&#xff0c;加左括号&#xff0c;然后k(index1), if左括号大于有括号&#xff0c;加右括号&#xff0c;k(index1),然后收尾括号单独考虑&#xff0c;到…
阅读更多...
二叉树----7-3 列出叶结点

二叉树----7-3 列出叶结点

对于给定的二叉树，本题要求你按从上到下、从左到右的顺序输出其所有叶结点。 输入格式： 首先第一行给出一个正整数 n（≤10），为树中结点总数。树中的结点从 0 到 n−1 编号。随后 n 行，每行给出一个对应结点左右孩子的编号。如果某个孩子不存在，则在对应位置给出 "…
阅读更多...
【Ardiuno】实验使用ESP32连接Wifi（图文）

【Ardiuno】实验使用ESP32连接Wifi（图文）

ESP32最为精华和有特色的地方当然是wifi连接&#xff0c;这里我们就写程序实验一下适使用ESP32主板连接wifi&#xff0c;为了简化实验我们这里只做了连接部分&#xff0c;其他实验在后续再继续。 由于本实验只要在串口监视器中查看结果状态即可&#xff0c;因此电路板上无需连…
阅读更多...
Transformer模型结构解析：编码器与完整模型的应用场景

Transformer模型结构解析：编码器与完整模型的应用场景

Transformer模型结构解析&#xff1a;编码器与完整模型的应用场景 Transformer模型自2017年由Google的研究者提出以来&#xff0c;已经在自然语言处理&#xff08;NLP&#xff09;领域产生了革命性的影响。Transformer模型的核心特点是其使用了自注意力&#xff08;Self-Atten…
阅读更多...
ToxVidLLM：一个用于检测有害视频的多模态多任务框架

ToxVidLLM：一个用于检测有害视频的多模态多任务框架

在一个社交媒体平台赋予用户成为内容创作者力量的时代&#xff0c;数字领域见证了前所未有的信息传播激增&#xff0c;到2023年&#xff0c;近82%的互联网流量是视频内容。因此&#xff0c;像抖音和YouTub这样的平台已经成为主要的信息来源。一个显著的统计数据凸显了这些平台的…
阅读更多...
【java并发】知识框架

【java并发】知识框架

文章目录 一. 并发基础1.多线程基础2. 线程安全性3. 同步机制4. 线程间通信5. 并发集合 二. java 进阶1. 并发工具类2. 原子操作和 CAS3. 线程池 三、并发架构1. 并发设计模式2. 性能调优与高级主题3. 并发框架与实践4. 线程分析 一. 并发基础 1.多线程基础 学习 Java 中如何…
阅读更多...
线段树模板

线段树模板

0、基本模板 0.1单点修改 class Node:def __init__(self,l,r,s):self.llself.rrself.ss def pushup(u,l,r):u.s l.s r.s def build(u,l,r):if lr:tr[u]Node(l,r,a[l])else:mid lr>>1tr[u]Node(l,r,0)build(u<<1,l,mid); build(u<<1|1,mid1,r)pushup(tr[…
阅读更多...
发布处理方案 —— 前台项目构建与发布处理

发布处理方案 —— 前台项目构建与发布处理

目录 01: 前言 02: 域名、DNS、公网IP、服务器、Nginx之间的关系 03: 阿里云服务器购买指南 04: 服务器连接方式 05: Nginx 环境处理 06: 项目发布 07: 小结 01: 前言 现在我们来看一下项目的打包和发布功能&#xff0c;这两个功能也就是我们本篇文章的主要功能。 对…
阅读更多...
大泽动力30KW静音汽油发电机

大泽动力30KW静音汽油发电机

安全操作&#xff1a; 在使用前&#xff0c;确保发电机放置在通风良好、干燥、无易燃物品的地方。 避免在发电机运行时触摸其热表面或运转部件&#xff0c;以免烫伤或受伤。 遵循发电机的启动和停机程序&#xff0c;不要随意操作。 燃油管理&#xff1a; 使用高质量的汽油&…
阅读更多...
关于Redis的持久化

关于Redis的持久化

Redis与MySQL的不同 MySQL的事务&#xff0c;有四个核心特性&#xff1a;原子性、一致性、持久性和隔离性 把数据存储在磁盘上就是持久化的&#xff0c;把数据存储在内存上则是不持久化的。区别在于重启进程/主机后&#xff0c;数据是否存在。 而Redis是一个内存数据库&#x…
阅读更多...
Avalonia TreeView 示例代码

Avalonia TreeView 示例代码

参考文档 https://docs.avaloniaui.net/docs/reference/controls/detailed-reference/treeview-1 新建一个avalonia MVVM工程AvaloniaAppTreeview&#xff0c;删掉MainWindow.xaml里的<TextBlock Text"{Binding Greeting}" HorizontalAlignment"Center"…
阅读更多...
数据可视化：Matplotlib 与 Seaborn

数据可视化：Matplotlib 与 Seaborn

数据可视化是数据分析中至关重要的一部分&#xff0c;它能帮助我们直观地理解数据的分布、趋势和关系。Python 中&#xff0c;Matplotlib 和 Seaborn 是两个最常用的可视化库。本文将详细介绍如何使用 Matplotlib 和 Seaborn 进行数据可视化&#xff0c;包括基本图形、图形定制…
阅读更多...
最新文章

Copyright @ 2022~2023