数据结构——七大排序[源码+动图+性能测试]

本章代码gitee仓库：排序

文章目录

  • 🎃0. 思维导图
  • 🧨1. 插入排序
    • ✨1.1 直接插入排序
    • ✨1.2 希尔排序
  • 🎊2. 选择排序
    • 🎋2.1 直接选择排序
    • 🎋2.2 堆排序
  • 🎏3. 交换排序
    • 🎐3.1 冒泡排序
    • 🎐3.2 快速排序
      • 🎑hoare版本
      • 🎑挖坑法
      • 🎑前后指针
      • 🎑小区间优化
      • 🎑非递归
  • 🎀4. 归并排序
    • 🎁4.1 递归
    • 🎁4.2 非递归
  • 🎫5. 性能测试
    • 🎖5.1 1w数据
    • 🎖5.2 10w数据
    • 🎖5.3 100w数据
    • 🎖5.4 1000w数据
    • 🎖5.5 1亿数据

🎃0. 思维导图

image-20230903205328348

🧨1. 插入排序

insert_s

✨1.1 直接插入排序

我们日常打扑克牌，摸牌，让后将牌按顺序插入好，这其实就是插入排序的过程，打小插入排序的思想就植入我们的脑海

第一张牌不用管，直接拿在手里，之后的牌按照大小再一个一个插入即可

//直接插入排序
void InsertSort(int* a, int n)
{//第一张牌不用排，所以直接从下标1开始走for (int i = 1; i < n; i++){int end = i - 1;int tmp = a[i];while (end >= 0){if (a[end] > tmp){//往后挪数据a[end + 1] = a[end];end--;}elsebreak;}//直接break出来 或者 end = -1a[end + 1] = tmp;}
}

直接插入排序特性：

  1. 越接近有序，效率越高(不用那么多次挪动数据)

  2. 时间复杂度：O(N2)

    逆序最坏O(N2)，有序最好O(N)

  3. 空间复杂度：O(1)

  4. 稳定性：稳定

✨1.2 希尔排序

希尔排序是基于直接插入排序的一种优化，将数据分为gap组，对每组进行排序，然后再缩小间隔，知道gap为1的时候，该序列为有序

image-20230902160102530

//希尔排序
void ShellSort(int* a, int n)
{int gap = n;while (gap > 1){//最后一次gap一定要是1gap = gap / 3 + 1;//分组插入排序 预排序for (int i = 0; i < n - gap; i++){int end = i;int tmp = a[i + gap];while (end >= 0){if (a[end] > tmp){a[end + gap] = a[end];end -= gap;}elsebreak;}a[end + gap] = tmp;}}
}

希尔排序特性：

  1. 希尔排序有2层循环，一个是gap的逐渐缩小，一个是分为gap组之后的插入排序，我们一般以为时间复杂度为**O(N*logN)**这个量级。image-20230902162331699但其实这其中的N，一直是在变化的，可理解为先上升，后下降

    image-20230902162738748

    所以这个量级是略大于N*logN，查阅资料可得知，希尔排序的时间复杂度大概为O(N1.3~2)image-20230902163132607

  2. 稳定性：不稳定

🎊2. 选择排序

还是以打扑克来举例，有时候我们感觉一张一张摸牌十分费时间，所以就指定一个人来发牌，发完之后我们将这一把牌拿到手中再开始理牌

select_s

🎋2.1 直接选择排序

这个选择排序每次都是趟都是选出最小的数，我们可以在此基础上做出优化，每次选出2个数，即最小值和最大值

//选择排序
void SelectSort(int* a, int n)
{int left = 0;int right = n - 1;while (left < right){int mini = left;int maxi = left;for (int i = left + 1; i <= right; i++){if (a[i] < a[mini]){mini = i;}if (a[i] > a[maxi]){maxi = i;}}Swap(&a[left], &a[mini]);//数据修正if (a[left] == a[maxi]){maxi = mini;}Swap(&a[right], &a[maxi]);left++;right--;}
}

直接选择排序特性：

  1. 不考虑序列的有序性，每次都找出最小最大值，效率较低

  2. 时间复杂度：O(N2)

    最好情况：O(N2)

    最坏情况：O(N2)

  3. 空间复杂度：O(1)

  4. 稳定性：不稳定

🎋2.2 堆排序

堆排序也是选择排序的一种，只不过没有直接选择排序那么朴实，堆排序有一些“华丽”的技巧。

堆排序在之前二叉树的章节讲过了，这里就不再过多赘述，有兴趣的可以查看此篇文章：数据结构——二叉树

//向下调整 前提：子树都是堆
void AdjustDown(int* val, int sz, int parent)
{//默认左孩子大int child = parent * 2 + 1;//至多叶子结点结束while (child < sz){//不越界 选出更大的孩子if (child + 1 < sz && val[child] < val[child + 1]){child++;}if (val[child] > val[parent]){Swap(&val[child], &val[parent]);parent = child;child = parent * 2 + 1;}else{break;}}
}//堆排序
void HeapSort(int* a, int n)
{//向下调整 O(N)for (int i = (n - 1 - 1) / 2; i >= 0; --i){AdjustDown(a,n, i);}//向下调整排序 O(N*logN)for (int i = 0; i < n; i++){Swap(&a[0], &a[n - 1 - i]);AdjustDown(a, n - 1 - i, 0);}
}

堆排序特性：

  1. 堆排序进行选数据效率较高
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

🎏3. 交换排序

🎐3.1 冒泡排序

冒泡排序应该是多数人的启蒙排序算法，思路较为简单

bubble_s

//冒泡排序
void BubbleSort(int* a, int n)
{for (int i = 0; i < n; i++){for (int j = 0; j < n - i - 1; j++){if (a[j] > a[j + 1]){Swap(&a[j], &a[j + 1]);}}}
}

冒泡排序特性：

  1. 时间复杂度：O(N2)

    最坏情况：O(N2)

    最好情况：O(N)

  2. 空间复杂度：O(1)

  3. 稳定性：稳定

这里的最好情况，就是里面没有发送交换了，就证明此时序列已经有序，则不需要往后再遍历，优化如下：

//冒泡排序
void BubbleSort(int* a, int n)
{for (int i = 0; i < n; i++){bool falg = true;for (int j = 0; j < n - i - 1; j++){if (a[j] > a[j + 1]){Swap(&a[j], &a[j + 1]);falg = false;}}if (falg)break;}
}

🎐3.2 快速排序

快速排序，顾名思义，速度很快，效率很高，排序算法里面的大哥大

快排的思想是选出一个基准值key，然后把这个值放入正确的位置（最终排好序要去的位置）

例如6,2,9,1,5,7,4这组数据

我们选出6为key值，然后将比6小的放左边，比6大的放右边

这一趟下来，6就在正确的位置上了

quick_s

🎑hoare版本

img

//快速排序
void QuickSort(int* a, int left,int right)
{if (left >= right)return;//记录起始int begin = left;int end = right;//选取最左边为key值int keyi = left;while (left < right){//选左 右先走 找小值while (left<right && a[right] >= a[keyi]){right--;}while (left < right && a[left] <= a[keyi]){left++;}//交换两边的值Swap(&a[left], &a[right]);}Swap(& a[keyi], & a[left]);keyi = left;//左右区间递归QuickSort(a, begin, keyi - 1);QuickSort(a, keyi+1, end);
}

hoare版本为快排的最初始版本，这个版本不容易控制：

  1. 找大值/小值的时候，如果该值等于key值，也需要挪动，即a[right] >= a[keyi]、a[left] <= a[keyi]

    image-20230903090330597

    另外，判断条件还应加上left<right，防止越界

    image-20230903090949353

  2. 左边作为key，右边先走，这样就能保证相对位置比key要小或者就是key的位置

    右边作为key，左边先走，相遇位置比key大或者就是key的位置

  3. 已排序或者逆序的情况都是最糟糕的情况

    image-20230903100850115

    有多少个数据，就有递归多少层栈帧，最终会导致栈溢出

  • 随机选key

    这个keyi影响了快排的效率，只要keyi取的数，每次越接近于中间，那么每次就越接近于二分，所以我们可以考虑随机选key，这样就不必担心序列是否接近有序

    //快速排序
void QuickSort(int* a, int left,int right)
{if (left >= right)return;//记录起始int begin = left;int end = right;//left可能不是0，加上leftint randi = left + (rand() % (right - left));//还是选择左边为key，交换一下Swap(&a[left], &a[randi]);//选取最左边为key值int keyi = left;while (left < right){//选左 右先走 找小值while (left<right && a[right] >= a[keyi]){right--;}//左边找大值while (left < right && a[left] <= a[keyi]){left++;}//交换两边的值Swap(&a[left], &a[right]);}Swap(& a[keyi], & a[left]);keyi = left;//[begin,keyi-1] keyi [keyi+1,end]//左右区间递归QuickSort(a, begin, keyi - 1);QuickSort(a, keyi+1, end);
}

  • 三数取中

    int GetMidNumi(int* a, int left, int right)
{int mid = (left + right) / 2;if (a[left] < a[mid]){if (a[mid] < a[right])return mid;else if (a[left] > a[right])return left;elsereturn right;}else	//a[left] >a[mid]{if (a[mid] > a[right])return mid;else if (a[left] < a[right])return left;elsereturn right;}
}
int Partition1(int* a, int left, int right)
{//三数取中	开始 中间 末尾 选中间值int midi = GetMidNumi(a, left, right);if (midi != left)Swap(&a[left], &a[midi]);//选取最左边为key值int keyi = left;while (left < right){//选左 右先走 找小值while (left < right && a[right] >= a[keyi]){right--;}//左边找大值while (left < right && a[left] <= a[keyi]){left++;}Swap(&a[left], &a[right]);}Swap(&a[keyi], &a[left]);keyi = left;return keyi;
}
void QuickSort(int* a, int left, int right)
{if (left > right)return;int keyi = Partition1(a, left, right);QuickSort(a, left, keyi - 1);QuickSort(a, keyi + 1, right);
}

🎑挖坑法

img

基本思路不边，只是这个更好理解，挖坑填坑、挖坑填坑，最后相遇位置一定是坑位

//挖坑
int Partition2(int* a, int left, int right)
{//三数取中	开始 中间 末尾 选中间值int midi = GetMidNumi(a, left, right);if (midi != left)Swap(&a[left], &a[midi]);//选取最左边为key值int key = a[left];int hole = left;while (left < right){//选左 右先走 找小值while (left < right && a[right] >= key){right--;}//填坑a[hole] = a[right];//挖坑hole = right;//左边找大值while (left < right && a[left] <= key){left++;}a[hole] = a[left];hole = left;}a[hole] = key;return hole;
}
void QuickSort(int* a, int left, int right)
{if (left > right)return;int keyi = Partition2(a, left, right);QuickSort(a, left, keyi - 1);QuickSort(a, keyi + 1, right);
}

🎑前后指针

img

  1. cur找的值比key小，++prev，cur与prev位置的值交换，++cur
  2. cur找的值比key大，++cur
//前后指针
int Partition3(int* a, int left, int right)
{//三数取中	开始 中间 末尾 选中间值int midi = GetMidNumi(a, left, right);if (midi != left)Swap(&a[left], &a[midi]);int keyi = left;int prev = left;int cur = left + 1;while (cur <= right){if (a[cur] < a[keyi] && ++prev != cur){Swap(&a[prev], &a[cur]);}++cur;}Swap(&a[keyi], &a[prev]);keyi = prev;return keyi;
}
void QuickSort(int* a, int left, int right)
{if (left > right)return;int keyi = Partition3(a, left, right);QuickSort(a, left, keyi - 1);QuickSort(a, keyi + 1, right);
}

🎑小区间优化

当大量的数据递归到小量数据的时候，递归就会很麻烦，所以当数据量较小的时候，我们可以采用插入排序进行辅助，直接将这一小段数据排成有序

image-20230903141230825

#define INSERTION_SORT_THRESHOLD 10
void QuickSort(int* a, int left, int right)
{if (left > right)return;//区间自己决定 一般采用10左右if ((right - left + 1) > INSERTION_SORT_THRESHOLD){int keyi = Partition2(a, left, right);QuickSort(a, left, keyi - 1);QuickSort(a, keyi + 1, right);}elseInsertSort(a + left, right - left + 1);
}

🎑非递归

模拟递归，将区间放入栈

void QuickSortNonR(int* a, int left, int right)
{//用C++的stl库stack<int> st;st.push(right);st.push(left);while (!st.empty()){int begin = st.top();st.pop();int end = st.top();st.pop();int keyi = Partition2(a, begin, end);//[begin,keyi-1] keyi [keyi+1,end]if (keyi + 1 < end){st.push(end);st.push(keyi + 1);}if (begin < keyi - 1){st.push(keyi - 1);st.push(begin);}}
}

快排特性：

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

    快排比较像二叉树

    image-20230903094437641

    单趟排序的时间复杂度为O(N)，而递归的深度是O(logN)，合计起来就是O(N*logN)这个量级

  2. 空间复杂度：O(logN)

  3. 稳定性：不稳定

🎀4. 归并排序

mer_s

归并排序的思想就是分治，将一个序列看作n个子序列，然后将子序列排好序之后两两归并，这个方法也成为二路归并

image-20230903155116968

🎁4.1 递归

//归并排序
void _MergeSort(int* a, int begin, int end, int* tmp)
{if (begin >= end)return;//分割区间int mid = (begin + end) / 2;//子区间递归排序//[begin,mid] [mid+1,end]_MergeSort(a, begin, mid, tmp);_MergeSort(a, mid+1, end, tmp);//归并int begin1 = begin;int begin2 = mid+1;int end1 = mid;int end2 = end;int index = begin;while (begin1 <= end1 && begin2 <= end2){if (a[begin1] < a[begin2])tmp[index++] = a[begin1++];elsetmp[index++] = a[begin2++];}//防止未结束的区间while (begin1 <= end1){tmp[index++] = a[begin1++];}while (begin2 <= end2){tmp[index++] = a[begin2++];}//拷贝回原序列memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + (int)1));
}void MergeSort(int* a, int n)
{//开辟临时空间int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc fail\n");exit(-1);}_MergeSort(a, 0, n - 1, tmp);free(tmp);
}

🎁4.2 非递归

image-20230903222757844

归并排序的非递归需要注意的就是边界问题，我们每次都是分为2组归并，如果是单数的话，会发生越界行为，所以要查看这两组的区间：

image-20230903225002835

  1. begin1，取值为i，所以肯定不会越界

  2. end1如果越界，后面的肯定越界，无需进行归并

  3. end1没有越界，begin2如果越界，无需进行归并

  4. begin2没有越界，end2越界，需要归并，修正end2

void MergeSortNonR(int* a, int n)
{int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc fail\n");exit(-1);}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;//修正	外面一次性拷贝//if (end1 >= n)//{//	//不归并//	end1 = n - 1;//	//给一个不存在区间//	begin2 = n;//	end2 = n - 1;//}//else if (begin2 >= n)//{//	//不归并		修正成不存在的区间//	begin2 = n;//	end2 = n - 1;//}//else if (end2 >= n)//{//	//修正//	end2 = n - 1;//}if (end1 >= n || begin2 >= n){break;}if (end2 >= n){end2 = n - 1;}int index = i;while (begin1 <= end1 && begin2 <= end2){if (a[begin1] < a[begin2])tmp[index++] = a[begin1++];elsetmp[index++] = a[begin2++];}//防止未结束的区间while (begin1 <= end1){tmp[index++] = a[begin1++];}while (begin2 <= end2){tmp[index++] = a[begin2++];}memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));}//外面拷贝，一把梭哈//memcpy(a, tmp, sizeof(int) * n);gap *= 2;}free(tmp);
}

归并排序特性：

  1. 时间复杂度：O(N*logN)
  2. 空间复杂度：O(N)
  3. 稳定性：稳定
  4. 归并排序更多解决的是磁盘中的外排序问题

🎫5. 性能测试

测试性能我们开release版本，火力全开；

测试环境为Linux的g++

本次只是简单的进行测试，可能会有偶然性

void TestOP()
{srand(time(0));const int N = 10000;	//1w//const int N = 100000;	//10w//const int N = 5000000;	//100w//const int N = 10000000;	//1000w//const int N = 100000000;	//1亿int* a1 = (int*)malloc(sizeof(int) * N);int* a2 = (int*)malloc(sizeof(int) * N);int* a3 = (int*)malloc(sizeof(int) * N);int* a4 = (int*)malloc(sizeof(int) * N);int* a5 = (int*)malloc(sizeof(int) * N);int* a6 = (int*)malloc(sizeof(int) * N);int* a7 = (int*)malloc(sizeof(int) * N);int* a8 = (int*)malloc(sizeof(int) * N);for (int i = 0; i < N; i++){a1[i] = rand();a2[i] = a1[i];a3[i] = a1[i];a4[i] = a1[i];//a4[i] = 2;a5[i] = a1[i];a6[i] = a1[i];a7[i] = a1[i];a8[i] = a1[i];}int begin1 = clock();InsertSort(a1, N);int end1 = clock();int begin2 = clock();ShellSort(a2, N);int end2 = clock();int begin3 = clock();SelectSort(a3, N);int end3 = clock();int begin4 = clock();HeapSort(a3, N);int end4 = clock();int begin5 = clock();BubbleSort(a5, N);int end5 = clock();int begin6 = clock();QuickSort(a4, 0, N - 1);int end6 = clock();int begin7 = clock();MergeSort(a6, N);int end7 = clock();std::vector<int> v(a8, a8 + N);int begin8 = clock();std::sort(v.begin(),v.end());int end8 = clock();printf("InsertSort:%d\n", end1 - begin1);printf("ShellSort:%d\n", end2 - begin2);printf("SeletSort:%d\n", end3 - begin3);printf("HeapSort:%d\n", end4 - begin4);printf("BubbleSort:%d\n", end5 - begin5);printf("QuickSort:%d\n", end6 - begin6);printf("MergeSort:%d\n", end7 - begin7);printf("STLSort:%d\n", end8 - begin8);free(a1);free(a2);free(a3);free(a4);free(a5);free(a6);free(a7);free(a8);
}

🎖5.1 1w数据

在1w数据这个量级，对于希尔排序、堆排序、快排、归并排序，都是挠痒痒，忽略不计

image-20230903234042810

🎖5.2 10w数据

在10w这个量级，显然直接插入排序、直接选择排序、冒泡排序都以不堪重负，而对于这些时间复杂度度在O(N*logN)量级的排序，才刚刚开始

image-20230903234713804

🎖5.3 100w数据

到了100w这个量级，就不再对量级为O(N2)进行测试了，他们坐小孩儿那桌

image-20230903235017232

这里可以看出，快排还得是快排

🎖5.4 1000w数据

到1000w这个量级，堆排序就有点扛不住了

image-20230903235510985

🎖5.5 1亿数据

在一亿这个量级，服务器有点跑不动了

image-20230904000200387

换到Windows环境参考，这个具体还得看机器和优化，不是特别具有参考意义，但可以看一下C++库里面的快排实现
image-20230904000816347

那本期的分享就到这里，我们下期再见，如果还有下期的话。

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

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

相关文章

Qt应用开发(基础篇)——工具按钮类 QToolButton

Qt应用开发(基础篇)——工具按钮类 QToolButton

一、前言 QToolButton类继承于QAbstractButton&#xff0c;该部件为命令或选项提供了一个快速访问按钮&#xff0c;通常用于QToolBar中。 按钮基类 QAbstractButton QToolButton是一个特殊的按钮&#xff0c;一般显示文本&#xff0c;只显示图标&#xff0c;结合toolBar使用。它…
阅读更多...
【图文并茂】c++介绍之队列

【图文并茂】c++介绍之队列

1.1队列的定义 队列&#xff08;queue&#xff09;简称队&#xff0c;它也是一种操作受限的线性表&#xff0c;其限制为仅允许在表的一端进行插入操作&#xff0c;而在表的另一端进行删除操作 一些基础概念&#xff1a; 队尾&#xff08;rear&#xff09; &#xff1a;进行插…
阅读更多...
MFC新建内部消息

MFC新建内部消息

提示&#xff1a;记录一下MFC新建内部消息的成功过程 文章目录 前言一、第一阶段二、第二阶段三、第三阶段总结 前言 先说一下基本情况&#xff0c;因为要在mapview上增加一个显示加载时间的功能。然后发现是要等加载完再显示时间&#xff0c;显示在主窗口。所以就是在子线程中…
阅读更多...
开开心心带你学习MySQL数据库之节尾篇

开开心心带你学习MySQL数据库之节尾篇

Java的JDBC编程 各种数据库,MySQL, Oracle, SQL Server在开发的时候,就会提供一组编程接口(API) API ~~ Application Programming Interface ~~ 应用程序编程接口 计算机领域里面的一个非常常见的概念, 给你个软件,你能对他干啥(从代码层次上的) 基于它提供的这些功能,就可以写…
阅读更多...
AJAX学习笔记5同步与异步理解

AJAX学习笔记5同步与异步理解

AJAX学习笔记4解决乱码问题_biubiubiu0706的博客-CSDN博客 示例 前端代码 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>演示AJAX同步和异步</title> </head> <body> <script…
阅读更多...
深眸科技自研轻辙视觉引擎，以AI机器视觉赋能杆号牌识别与分拣

深眸科技自研轻辙视觉引擎，以AI机器视觉赋能杆号牌识别与分拣

电线杆号牌作为电力行业标识的一种&#xff0c;相当于电线杆的“身份证”&#xff0c;担负着宣传电力知识、安全警示的作用&#xff0c;用于户外使用标记输电线路电压等级、线路名称、杆塔编号等&#xff0c;能够清晰地记录电力线路杆的信息&#xff0c;并为电力线路的更改以及…
阅读更多...
ChatGPT是如何辅助高效撰写论文及使用ChatGPT注意事项

ChatGPT是如何辅助高效撰写论文及使用ChatGPT注意事项

ChatGPT发布近1年&#xff0c;各大高校对它的态度也发生了极大转变&#xff0c;今年3月发布ChatGPT禁令的牛剑等世界顶级名校也在近期解除了ChatGPT禁令&#xff0c;发布了生成式人工智能使用指南。 ChatGPT一定程度上可以解放科研人员的劳动力&#xff0c;与其直接禁止不如教…
阅读更多...
Docker笔记-概念安装简单使用

Docker笔记-概念安装简单使用

概念 docker通用词汇。 镜像&#xff1a;Build&#xff0c;创建一个镜像。 仓库&#xff1a;Ship&#xff0c;从仓库和主机上运输镜像。 容器&#xff1a;Run&#xff0c;运行的镜像就是一个容器。 安装 Windows上安装 Docker对win10有原生的支持&#xff0c;win10下的是…
阅读更多...
thinkphp6-简简单单地开发接口

thinkphp6-简简单单地开发接口

目录 1.前言TP6简介 2.项目目录3.运行项目运行命令访问规则 4.model db使用db连接配置model编写及调用调用接口 5.返回json格式 1.前言 基于上篇文章环境搭建后&#xff0c;便开始简单学习上手开发接口…记录重要的过程&#xff01; Windows-试用phpthink发现原来可这样快速搭…
阅读更多...
IDEA在创建包时如何把包分开实现自动分层

IDEA在创建包时如何把包分开实现自动分层

IDEA在创建包时如何把包分开实现自动分层 文章目录 IDEA在创建包时如何把包分开实现自动分层一、为什么要把包分开二、建包时如何把包自动分开三、如何编写配置文件路径&#xff1f; 一、为什么要把包分开 一开始的时候&#xff0c;我也一直以为包连在一起和分开没什么区别&am…
阅读更多...
linux内核模块编译方法之模块编程详解

linux内核模块编译方法之模块编程详解

文章目录 一、模块传参二、模块依赖三、内核空间和用户空间四、执行流五、模块编程与应用编程的比较六、内核接口头文件查询总结 本期和大家主要分享的是驱动开发内核编译过程中对于模块是如何设计的&#xff0c;进行了详细的分享&#xff0c;从模块传参、模块依赖一直到内核空…
阅读更多...
Linux dup dup2函数

Linux dup dup2函数

/*#include <unistd.h>int dup2(int oldfd, int newfd);作用&#xff1a;重定向文件描述符oldfd 指向 a.txt, newfd 指向b.txt,调用函数之后&#xff0c;newfd和b.txt close&#xff0c;newfd指向a.txtoldfd必须是一个有效的文件描述符 */ #include <unistd.h> #i…
阅读更多...
Python怎么实现更高效的数据结构和算法？ - 易智编译EaseEditing

Python怎么实现更高效的数据结构和算法？ - 易智编译EaseEditing

要实现更高效的数据结构和算法&#xff0c;你可以考虑以下几个方面的优化&#xff1a; 选择合适的数据结构&#xff1a; 选择最适合你问题的数据结构至关重要。例如&#xff0c;如果需要频繁插入和删除操作&#xff0c;可能链表比数组更合适。如果需要高效查找操作&#xff0…
阅读更多...
基于java SpringBoot和Vue uniapp的影楼摄影预约小程序

基于java SpringBoot和Vue uniapp的影楼摄影预约小程序

摘要 今天信息技术的发展很快&#xff0c;其足迹在我们的生活中随处可见。它影响着我们的衣食住行等各种需求。影响也在逐渐增加&#xff0c;逐渐渗透到各行各业&#xff0c;在这种背景下&#xff0c;经过实地考察后&#xff0c;为了让婚纱照管理更加高效方便&#xff0c;我决定…
阅读更多...
Mac系统 AndroidStudio Missing essential plugin:org.jetbrains.android报错

Mac系统 AndroidStudio Missing essential plugin:org.jetbrains.android报错

打开Android Studio,提示 Missing essential plugin:org.jetbrains.android错误&#xff0c;产生的原因是Kotlin被禁用。 解决的方法是删除disabled_plugins.txt&#xff0c;Mac OS对应的路径为&#xff1a; /Users/xzh/Library/Application Support/Google/AndroidStudio202…
阅读更多...
C高级 DAY4

C高级 DAY4

一、分支语句 case ...in语句 shell中的switch语句 case $变量名 in常量1)语句;; ------->类似于C中break的作用&#xff0c;;;除了最后一条分之外&#xff0c;都不能省略常量2)语句;; 常量n)语句;;*) ------->类似于C中default&#xff0c;但…
阅读更多...
【码银送书第六期】《ChatGPT原理与实战：大型语言模型的算法、技术和私有化》

【码银送书第六期】《ChatGPT原理与实战：大型语言模型的算法、技术和私有化》

写在前面 2022年11月30日&#xff0c;ChatGPT模型问世后&#xff0c;立刻在全球范围内掀起了轩然大波。无论AI从业者还是非从业者&#xff0c;都在热议ChatGPT极具冲击力的交互体验和惊人的生成内容。这使得广大群众重新认识到人工智能的潜力和价值。对于AI从业者来说&#xf…
阅读更多...
【多线程】volatile 关键字

【多线程】volatile 关键字

volatile 关键字 1. 保证内存可见性2. 禁止指令重排序3. 不保证原子性 1. 保证内存可见性 内存可见性问题: 一个线程针对一个变量进行读取操作&#xff0c;另一个线程针对这个变量进行修改操作&#xff0c; 此时读到的值&#xff0c;不一定是修改后的值&#xff0c;即这个读线…
阅读更多...
【动态规划】01背包问题

【动态规划】01背包问题

文章目录 动态规划&#xff08;背包问题&#xff09;1. 01背包2. 分割等和子集3. 目标和4. 最后一块石头的重量 || 动态规划&#xff08;背包问题&#xff09; 1. 01背包 题目链接 状态表示 dp[i][j] 表示从前i个物品当中挑选&#xff0c;总体积不超过j,所有选法当中能挑选出…
阅读更多...
UDP协议

UDP协议

目录 一、UDP协议端格式 二、UDP的特点 一、UDP协议端格式 16位UDP长度&#xff0c;表示整个数据报&#xff08;UDP首部UDP数据&#xff09;的最大长度&#xff1b;如果校验和出错&#xff0c;就会直接丢弃 二、UDP的特点 UDP相对于TCP来说是相对简单的&#xff0c;但是在传输…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023