【数据结构】：破译排序算法--数字世界的秩序密码（二）

文章目录

  • 前言
  • 一.比较排序算法
    • 1.`Bubble Sort`冒泡排序
      • 1.1.冒泡排序原理
      • 1.2.冒泡排序过程
      • 1.3.代码实现
      • 1.4.复杂度和稳定性
    • 2.`Quick Sort`快速排序
      • 2.1递归快速排序
        • 2.1.1.递归快速排序原理
        • 2.1.2.递归快速排序过程
        • 2.1.3.代码实现
      • 2.2.非递归快速排序
        • 2.2.1.非递归快速排序原理
        • 2.2.2.非递归快速排序过程
        • 2.2.3.代码实现
      • 2.3.复杂度和稳定性
  • 二.归并排序算法
    • `Merge Sort`归并排序
      • 1.递归归并排序
        • 1.1.递归归并排序原理
        • 1.2.递归归并排序过程
        • 1.3.代码实现
      • 2.非递归归并排序
        • 2.1.非递归归并排序原理
        • 2.2.非递归归并排序过程
        • 2.3.代码实现
      • 3.复杂度和稳定性
  • 三.非比较排序算法
    • ` Cout Sort`计数排序
      • 计数排序原理
      • 计数排序过程
      • 代码实现
      • 复杂度和稳定性
  • 四.代码文件
    • 1.头文件`Sort.h`
    • 2.测试文件`test.c`
    • 3.测试结果

前言

在上一篇文章中，主要讲了插入排序，希尔排序，选择排序，堆排序（详细可以看我上一篇文章哦），在接下来的这篇文章中，将重点讲解冒泡排序，快速排序，归并排序以及计数排序。

一.比较排序算法

1.Bubble Sort冒泡排序

1.1.冒泡排序原理

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地遍历要排序的数列，一次比较相邻的两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小（或越大）的元素会经由交换慢慢“浮”到数列的顶端。

1.2.冒泡排序过程

  • 比较相邻的元素，如果第一个比第二个大（升序），就交换他们两个。

  • 遍历数列，对每一对相邻元素做同样的工作，从开始的第一对到结尾的最后一对，这步结束后，最大（或最小）的元素会在数列的结尾。

  • 针对所有的元素重复以上步骤，除了最后一个。

  • 重复上面的步骤，直到没有任何一对元素需要比较。

在这里插入图片描述

在这里插入图片描述

1.3.代码实现

//交换
void Swap(int*a,int*b){int t=*a;*a=*b;*b=t;
}
void BubbleSort(int*a,int n){for(int j=0;j<n;j++){//设置一个变量用来判断每一趟是否交换bool exchange=false;//内层循环是每一趟的比较交换for(int i=1;i<n-j;i++){if(a[i-1]>a[i]){Swap(&a[i-1],&a[i]);exchange=true;}}//如果某一趟没有进行交换就是序列已经有序，直接结束排序if(exchange==false){break;}}
}

1.4.复杂度和稳定性

  • 时间复杂度：冒泡排序的平均和最坏时间复杂度都是O(n^2)。
  • 空间复杂度；冒泡排序的空间复杂度为O(1)。
  • 稳定性：冒泡排序是稳定的排序算法，即相等的元素在排序后的序列中保持原来的顺序。但由于其效率较低，通常不被用作主要的排序算法。

2.Quick Sort快速排序

2.1递归快速排序

2.1.1.递归快速排序原理

快速排序（Quick Sort）是一种高效的排序算法，由C. A. R. Hoare在1960年提出。它采用分治（Divide and Conquer）的策略来把一个序列分为较小和较大的两个子序列，然后递归地排序两个子序列。

快速排序的基本思想是：通过一趟排序将待排记录分隔成独立的两部分，其中一部分的所有记录均比另一部分的所有记录小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

2.1.2.递归快速排序过程

  • 选择基准值：从代排序的数列中选出一个元素作为基准值（key），最常用的就是三数取中法，通过比较数列的第一个和最后一个以及中间的值，选出这三个数的中间值，然后和最左端的也就是第一个数交换。基准值的选择对于排序的效率有重要影响。

  • 分区：重新排列数列，所有比基准值小的元素排在基准值前面，比基准值大的元素排在基准值后面（相同的数可以放在任意一边）。分区的操作有多种实现方法，如hoare法，挖坑法，前后指针法。

    1.hoare法：

    在这里插入图片描述

    2.挖坑法：

    在这里插入图片描述

    3.前后指针法：

    在这里插入图片描述

  • 递归排序子序列：递归地将小于基准值的子序列和大于基准值的子序列排序。递归的最底部情形是数列的大小是零活着一，也就是已经排好序。

2.1.3.代码实现
//获取基准值
int Getmid(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[right] > a[left]) {return left;}else{return right;}}else {if (a[right] > a[mid]) {return mid;}else if (a[left] > a[right]) {return left;}else {return right;}}
}
//hoare法
int keysort1(int* a, int left, int right) {int key = Getmid(a, left, right);Swap(&a[left], &a[key]);key = left;while (left < right) {while (left < right && a[right] >= a[key]) {right--;}while (left < right && a[left] <= a[key]) {left++;}Swap(&a[left], &a[right]);}Swap(&a[left], &a[key]);key = left;return key;
}
//挖坑法
int keysort2(int* a, int left, int right) {int key = Getmid(a, left, right);Swap(&a[left], &a[key]);int keyi = a[left];int hole = left;while (left < right) {while (left<right && a[right]>=keyi) {right--;}a[hole] = a[right];hole = right;while (left < right && a[left] <= keyi) {left++;}a[hole] = a[left];hole = left;}a[hole] = keyi;hole = left;return hole;
}
//前后指针法
int keysort3(int* a, int left, int right) {int mid = Getmid(a, left, right);Swap(&a[left], &a[mid]);int key = left;//后指针int prev = left;//快指针int cur = left + 1;while (cur <= right) {if (a[cur] < a[key] && ++prev != cur) {Swap(&a[cur], &a[prev]);}cur++;}Swap(&a[key], &a[prev]);key = prev;return key;
}void QuickSort(int* a, int left,int right) {if (left >= right) {return;}int begin = left;int end = right;//分区，三种方法选一种即可int key = keysort3(a, left, right);QuickSort(a, begin, key - 1);QuickSort(a, key + 1, end);
}

2.2.非递归快速排序

2.2.1.非递归快速排序原理

非递归快速排序的原理和过程与递归快速排序相似，但主要区别在于非递归版本通过显式地使用一个辅助栈（或队列）来模拟递归过程中的函数调用栈，从而避免了递归调用。

2.2.2.非递归快速排序过程

  1. 初始化栈：

    • 创建一个空栈用于保存待排序子数组的起始和结束索引。

  2. 将初始数组的起始和结束索引入栈：

    • 这对应于最初的排序问题。

  3. 循环处理栈中的元素：

    • 当栈不为空时，进行以下操作：

      1. 弹出栈顶的一对索引（起始和结束索引），这指定了当前要处理的子数组。

      2. 在当前子数组上选择一个基准元素，并进行分区操作。

        (分区操作会将数组分为左右两部分，并返回基准元素的最终位置。)

      3. 如果基准元素左侧的子数组有超过一个元素，则将其起始和结束索引作为一对入栈。

      4. 如果基准元素右侧的子数组有超过一个元素，也将其起始和结束索引作为一对入栈。

  4. 重复步骤3，直到栈为空，此时所有子数组都已经被正确排序。

2.2.3.代码实现
void QuickSortNoNR(int* a, int left, int right) {//创建栈Stack st;//初始化栈InitStack(&st);int begin = left;int end = right;//将第一个区间入栈pushStack(&st, end);pushStack(&st, begin);//循环条件栈不为空while (!IsEmpty(&st)) {//将区间出栈begin = getpopStack(&st);popStack(&st);end = getpopStack(&st);popStack(&st);//获取key值下标，分区int key = keysort3(a, begin, end);//右子区间满足条件入栈if (key + 1 < end) {pushStack(&st, end);pushStack(&st, key + 1);}//左子区间满足条件入栈if (begin < key - 1) {pushStack(&st, key - 1);pushStack(&st, begin);}}//销毁栈DestroyStack(&st);
}

2.3.复杂度和稳定性

  • 时间复杂度：快速排序的时间复杂度平均为O(n log n)，但在最坏情况下（如数组已经有序时）会退化到O(n^2)。
  • 空间复杂度：
  • 稳定性：快速排序是不稳定的排序算法，即相同的元素可能在排序过程中改变相对位置。

二.归并排序算法

Merge Sort归并排序

1.递归归并排序

1.1.递归归并排序原理

递归归并排序是建立在归并操作上的一种有效排序算法，它采用分治法（Divide and Conquer）来进行排序。分治法的基本思想是将一个复杂的问题分解成两个或更多的相同或相似的子问题，子问题再继续分解，直到这些子问题变得简单到可以直接解决，然后再合并子问题的解为原问题的解。

在归并排序中，分治法的应用体现在：

  1. 分解：将待排序的数组分解成两个较小的子数组，然后子数组再继续分解，直到子数组的大小为1（即只有一个元素，此时认为它是有序的）。
  2. 解决：递归地对子数组进行排序并合并，得到有序的子数组。
  3. 合并：将两个有序的子数组合并成一个有序的大数组，直到合并为1个完整的数组。
1.2.递归归并排序过程

  1. 分解：

    • 将待排序的数组a[begin...end]分解成两个子数组a[begin...mid]和a[mid+1...end]，其中mid是begin和end的中间位置（mid = (begin + end) / 2）。
    • 递归地对这两个子数组进行分解，直到子数组的大小为1。

  2. 递归排序并合并：

    • 对分解得到的子数组进行递归排序。
    • 合并两个有序的子数组为一个有序数组。合并过程中，通过比较两个子数组的元素，将较小的元素依次放入一个新的临时数组tmp中，直到所有元素都被合并。

  3. 合并：

    • 合并过程中，使用两个指针begin1,begin2分别指向两个子数组的起始位置，比较两个指针所指的元素，将较小的元素放入临时数组中，并移动该指针。
    • 当其中一个子数组的所有元素都被合并后，将另一个子数组中剩余的元素依次复制到临时数组的末尾。
    • 最后，将临时数组中的元素复制回原数组中的相应位置，完成合并。

  4. 递归终止条件：

    • 当子数组的大小为1时，递归终止，因为单个元素的数组自然是有序的。

  5. 排序完成：

    • 当整个数组被分解为单个元素的子数组，并通过递归合并成有序的大数组时，排序完成。

在这里插入图片描述

在这里插入图片描述

1.3.代码实现
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,end1=mid;int begin2=mid+1,end2=end;//循环比较，依次存放到tmp数组中//注意：这里tmp数组的下标一定要从begin开始，而不是从0开始int i=begin;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++];}//将tmp数组中排序好的拷贝到原数组中,复制范围是每次函数调用的左右区间memcpy(a+begin,tmp+begin,sizeof(int)*(end-begin+1));
}void MergeSort(int*a,int n){//创建一个临时数组用来存放排好序的序列int*tmp=(int*)malloc(sizeof(int)*n);if(tmp==NULL){perror("malloc false");return;}_MergeSort(a,0,n-1,tmp);
}

2.非递归归并排序

2.1.非递归归并排序原理

==非递归归并排序（也称为迭代归并排序）==与递归归并排序在原理上相同，都是基于分治法的排序算法。不过，在实现方式上，非递归归并排序通过循环而不是递归调用来控制排序过程。非递归归并排序也是将数组分解成若干个子数组，直到子数组的大小为1（即只有一个元素，此时认为它是有序的）。然后，通过迭代的方式，逐步合并相邻的有序子数组，直到合并成一个完整的有序数组。

2.2.非递归归并排序过程
  1. 初始化：
    • 定义一个变量gap，用于表示当前归并的子数组的大小（即每次合并时考虑的元素个数）。初始时，gap通常设置为1，表示每个子数组只包含一个元素。
  2. 迭代合并：
    • 使用一个外层循环，不断增大gap的值，直到gap大于等于数组的长度。这个循环控制归并的轮数。
    • 在每一轮归并中，使用一个内层循环来遍历数组，并合并相邻的、大小为gap的有序子数组。合并过程中，需要使用一个临时数组tmp来存放合并后的结果。
  3. 合并相邻子数组：
    • 在内层循环中，对于每一对相邻的子数组（它们的起始位置相差gap），使用类似于递归归并排序中合并函数的方法将它们合并成一个有序的子数组。
    • 合并过程中，使用两个指针begin1,begin2分别指向两个子数组的起始位置，比较两个指针所指的元素，将较小的元素放入临时数组中，并移动该指针。
    • 当其中一个子数组的所有元素都被合并后，将另一个子数组中剩余的元素依次复制到临时数组的末尾。
    • 最后，将临时数组中的元素复制回原数组中的相应位置，完成合并。
  4. 更新gap：
    • 在外层循环的每次迭代结束时，将gap的值加倍（即gap *= 2），以便在下一轮归并中合并更大范围的子数组。
  5. 排序完成：
    • 当gap大于等于数组的长度时，排序完成。此时，整个数组被合并成一个有序的大数组。

在这里插入图片描述

2.3.代码实现
void MergeSortNoNR(int*a,int n){//创建一个临时数组用来存放排好序的序列int* tmp=(int*)malloc(sizeof(int)*n);if(tmp==NULL){perror("malloc false");return;}//初始化：设置分区间隔值gap，从1开始int gap=1;//迭代合并：while(gap<n){//合并相邻子数组：for(int i=0;i<n;i+=gap*2){//分区int begin1=i,end1=i+gap-1;int begin2=i+gap,end2=i+gap*2-1;int j=i;//处理临界情况if(begin2>=n){break;}if(end2>=n){end2=n-1;}//循环比较，依次存放到tmp数组中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];}//将tmp数组中排序好的拷贝到原数组中//注意：这里用i，不用begin1,是因为begin1++值已经改变memcpy(a+i,tmp+i,sizeof(int)*(end2-i+1));}//更新gap:gap*=2;}
}

3.复杂度和稳定性

  • 时间复杂度：归并排序的时间复杂的为O(n*log n)。
  • 空间复杂度：归并排序的空间复杂度为O(n),因为借助了一个临时数组tmp，数组长度为n。
  • 稳定性：归并排序是一种稳定的排序算法。

三.非比较排序算法

Cout Sort计数排序

计数排序原理

计数排序（Counting Sort）是通过统计待排序元素的出现次数来确定元素的相对位置，从而实现排序。这种算法不是基于比较的排序算法，而是通过统计每个元素的出现次数，并利用这些信息来重新排列元素。

计数排序过程

  1. 找出待排序数组的最大值和最小值：

    • 遍历待排序数组，找出数组中的最大值max和最小值min。

  2. 创建计数数组并初始化：

    • 根据最大值和最小值创建一个计数数组countA，其长度range为max - min + 1（如果数组中存在负数，则需要对所有元素进行偏移，使得所有元素都是非负的）。
    • 将计数数组的所有元素初始化为0。

  3. 统计每个元素的出现次数：

    • 再次遍历待排序数组，对于数组中的每个元素x，将countA[x - min]（如果元素是负数或需要特殊偏移，则相应调整）的值增加1。这样，计数数组就记录了每个元素的出现次数。

  4. 对计数数组进行累加（也称为前缀和）：

    • 遍历计数数组，将每个元素的值更新为从计数数组开始到当前元素位置（包括当前元素）的所有元素之和。这一步完成后，计数数组中的每个元素都表示小于等于该索引对应元素值的元素个数。

  5. 根据计数数组将元素放回原数组的正确位置：

    • 创建一个临时数组temp，其长度与待排序数组相同。
    • 从后往前遍历待排序数组（这是为了确保排序的稳定性），对于每个元素x，通过count[x - min] - 1（如果元素是负数或需要特殊偏移，则相应调整）找到其在临时数组中的正确位置，并将x放入该位置。然后，将count[x - min]的值减1，以便下一个相同值的元素能够找到其正确的位置。

  6. 将排序后的元素复制回原数组（如果需要）：

    • 如果原数组需要被直接修改以反映排序后的结果，则将临时数组temp中的元素复制回原数组。否则，可以直接使用临时数组作为排序后的数组。

在这里插入图片描述

代码实现

void CountSort(int*a,int n){//找出待排序数组的最大值和最小值int max=a[0],min=a[0];for(int i=0;i<n;i++){if(a[i]>max){max=a[i];}if(a[i]<min){min=a[i];}}//创建计数数组并初始化int range=max-min+1;int*countA=(int*)malloc(sizeof(int)*range);if(countA==NULL){perror("malloc false");return;}//将计数数组的所有元素初始化为0memset(countA,0,sizeof(int)*range);//统计每个元素的出现次数for(int i=0;i<n;i++){countA[a[i]-min]++;}//将原数组的元素按照计数数组的个数复制到原数组中int j=0;for(int i=0;i<n;i++){while(countA[i]--){a[j++]=i+min;}}
}

复杂度和稳定性

  • 时间复杂度：计数排序的的时间复杂度为O(n+k)，n是待排序数组的长度，k是元素范围，最大值-最小值加一。
  • 空间复杂度：空间复杂度为O(n+k)，需要创建计数数组。
  • 稳定性：计数排序是一种稳定的排序算法，适用于整数或有限范围内的非负整数排序。

四.代码文件

这里附上整个代码文件：

  • 头文件Sort.h
  • 测试文件test.c
  • 接口函数实现文件Sort.c(文件内容就是每个代码实现)

1.头文件Sort.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<string.h>
//递归快速排序
void QuickSort(int* a, int left, int right);
//三数取中
int Getmid(int* a, int left, int right);
//霍尔版本快速排序
int keysort1(int* a, int left, int right);
//挖坑法快速排序
int keysort2(int* a, int left, int right);
//前后指针法快速排序
int keysort3(int* a, int left, int right);
//非递归快速排序
void QuickSortNoNR(int* a, int left, int right);
//递归归并排序
void MergeSort(int* a, int n);
void _MergeSort(int* a, int left, int right, int* tmp);
//非递归归并排序1
void MergeSortNoNR1(int* a, int n);
//非递归归并排序2
void MergeSortNoNR2(int* a, int n);
//计数排序
void CountSort(int* a, int n);

2.测试文件test.c

//冒泡排序测试
void Bubbletest() {int a[10] = { 3,6,7,2,1,5,4,9,8,10 };int n = (sizeof(a) / sizeof(int));BubbleSort(a, n);printf("冒泡排序：\n");PrintArray(a, n);
}
//快速排序测试
void Quicktest() {int a[20] = { 3,6,7,2,1,5,4,9,8,10,-2,7,-4,23,-1,-5,65,4,16,-3 };int n = (sizeof(a) / sizeof(int));QuickSortNoNR(a, 0, sizeof(a) / sizeof(int) - 1);printf("快速排序：\n");PrintArray(a, n);
}
//归并排序测试
void Mergetest() {int a[9] = { 2,1,7,5,4,9,3,8,6 };int n = (sizeof(a) / sizeof(int));MergeSortNoNR2(a, n);printf("归并排序：\n");PrintArray(a, n);
}
//计数排序测试
void Counttest() {int a[9] = { 2,1,7,2,4,1,3,8,6 };int n = (sizeof(a) / sizeof(int));CountSort(a, n);printf("计数排序：\n");PrintArray(a, n);
}
int main(){Bubbletest();Quicktest();Mergetest();Counttest();return 0;
}
}

3.测试结果

在这里插入图片描述

以上就是关于排序部分冒泡排序，快速排序，归并排序和计数排序的讲解，如果哪里有错的话，可以在评论区指正，也欢迎大家一起讨论学习，如果对你的学习有帮助的话，点点赞关注支持一下吧！！！
在这里插入图片描述

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

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

相关文章

MATLAB智能优化算法-学习笔记（5）——蚁群算法求解容量受限的车辆路径问题

MATLAB智能优化算法-学习笔记（5）——蚁群算法求解容量受限的车辆路径问题

蚁群算法在求解容量受限的车辆路径问题（Capacitated Vehicle Routing Problem, CVRP）中具有广泛应用。这类问题属于组合优化问题，涉及将若干辆具有容量限制的车辆，从配送中心出发为多个客户点提供服务，要求每辆车满足各客户的需求且总运载量不超过车辆容量，最终需要找到一…
阅读更多...
python深浅拷贝，可变变量与不可变变量

python深浅拷贝，可变变量与不可变变量

赋值 在 python 中&#xff0c;赋值是将一个值或对象分配给一个变量的过程。赋值操作符是 &#xff0c;用于将右侧的值或对象赋给左侧的变量。 赋值&#xff1a;l2的值会随着原对象l1的值一同改变 l1 [1, 2, 3, 4] print(l1:, l1) l2 l1 print(l2:, l2) 给li列表新增元素 …
阅读更多...
检测头篇 | 手把手教你如何去更换YOLOv8的检测头为ASFF_Detect

检测头篇 | 手把手教你如何去更换YOLOv8的检测头为ASFF_Detect

前言：Hello大家好，我是小哥谈。自适应空间特征融合（ASFF）的主要原理旨在解决单次检测器中不同尺度特征的不一致性问题。具体来说，ASFF通过动态调整来自不同尺度特征金字塔层的特征贡献，确保每个检测对象的特征表示是一致且最优的。本文所做出的改进是将YOLOv8的检测头更换…
阅读更多...
使用 Spring 框架构建 MVC 应用程序：初学者教程

使用 Spring 框架构建 MVC 应用程序：初学者教程

Spring Framework 是一个功能强大、功能丰富且设计精良的 Java 平台框架。它提供了一系列编程和配置模型&#xff0c;旨在简化和精简 Java 中健壮且可测试的应用程序的开发过程。 人们常说 Java 太复杂了&#xff0c;构建简单的应用程序需要很长时间。尽管如此&#xff0c;Jav…
阅读更多...
论文翻译 | OpenICL: An Open-Source Framework for In-context Learning

论文翻译 | OpenICL: An Open-Source Framework for In-context Learning

摘要 近年来&#xff0c;上下文学习&#xff08;In-context Learning&#xff0c;ICL&#xff09;越来越受到关注&#xff0c;并已成为大型语言模型&#xff08;Large Language Model&#xff0c;LLM&#xff09;评估的新范式。与传统微调方法不同&#xff0c;ICL无需更新任何参…
阅读更多...
龙信科技：引领电子物证技术，助力司法公正

龙信科技：引领电子物证技术，助力司法公正

文章关键词&#xff1a;电子数据取证、电子物证、手机取证、计算机取证、云取证、介质取证 在信息技术飞速发展的今天&#xff0c;电子物证在司法领域扮演着越来越重要的角色。苏州龙信信息科技有限公司&#xff08;以下简称“龙信科技”&#xff09;作为电子数据取证领域的先…
阅读更多...
bat(批处理脚本学习)

bat(批处理脚本学习)

输出banner echo off echo () echo JL echo ^|^| echo LJ echo _,--"""""""---. echo , …
阅读更多...
从零实现高并发内存池

从零实现高并发内存池

目录 1. 项目介绍1.1 这个项目具体功能是什么&#xff1f;1.2 本项目的知识储备 2. 什么是内存池2.1 池化技术2.2 内存池主要解决的问题2.3 malloc 3. 定长内存池设计4. 高并发内存池整体框架设计4.1 Thread Cache的设计思路4.2 Central Cache的设计思路4.3 Page Cache的设计思…
阅读更多...
【C语言】分支结构switch

【C语言】分支结构switch

switch分支语句 多适用于明确表达式结果的情况&#xff0c;多个分支&#xff0c;用if过于繁琐。 case后跟具体的表达式值&#xff0c;break&#xff1b;跳出分支语句。 #include <stdio.h> #include <math.h> /* 功能&#xff1a;选择结构&#xff08;switch&…
阅读更多...
Qt初识_项目文件解析

Qt初识_项目文件解析

个人主页&#xff1a;C忠实粉丝 欢迎 点赞&#x1f44d; 收藏✨ 留言✉ 加关注&#x1f493;本文由 C忠实粉丝 原创 Qt初识_项目文件解析 收录于专栏【Qt开发】 本专栏旨在分享学习Qt的一点学习笔记&#xff0c;欢迎大家在评论区交流讨论&#x1f48c; 目录 1. pro文件解析 2.…
阅读更多...
java异步多线程Async学习记录

java异步多线程Async学习记录

java异步多线程Async学习记录 第1步：声明线程池AsyncConfiguration import org.springframework.context.annotation.Bean; import org.springframework
阅读更多...
vue+element的confirm提示消息文字变色和换行

vue+element的confirm提示消息文字变色和换行

效果: 思路: 可以考虑采用模板字符串的思路实现 代码: this.confirm(您确定要<b style"Color: red">${text}</b>的数据项&#xff1f;<br/>单位名称: ${row.companyName} <br/>属性: ${row.attributeName}).then(() > {console.log(确定…
阅读更多...
SCM供应商管理怎么做？

SCM供应商管理怎么做？

在企业的供应链管理中&#xff0c;供应商管理是至关重要的一环。然而&#xff0c;传统的供应商管理方式常常面临诸多痛点&#xff0c;导致管理效率低下、成本增加、风险增大。不注重供应商管理的企业&#xff0c;常常会面临以下问题&#xff1a; 供应商档案管理难&#xff1a;…
阅读更多...
Redis 五种数据类型的操作命令

Redis 五种数据类型的操作命令

一、五种数据类型的介绍 五种数据类型如图所示&#xff1a; Redis 是一个开源的键值存储系统&#xff0c;它支持多种数据结构&#xff0c;每种数据结构都有其特定的用例和底层实现。以下是 Redis 的五种主要数据类型&#xff0c;以及它们适合存储的数据类型和底层实现&#xf…
阅读更多...
健康生活的重要性

健康生活的重要性

在当今快节奏的生活中&#xff0c;养生保健已成为人们日益关注的话题&#xff0c;而健身作为其中的重要一环&#xff0c;更是被赋予了前所未有的重视。谈及养生保健与健身&#xff0c;我们不得不深入思考&#xff1a;如何在繁忙的日常中&#xff0c;找到那条通往健康与活力的道…
阅读更多...
MAC地址漂移实验

MAC地址漂移实验

MAC地址漂移实验的概述&#xff1a; MAC地址漂移实验的概述主要围绕网络设备中的MAC地址动态变化及其检测与防护措施。以下是对MAC地址漂移实验的具体介绍&#xff1a; MAC地址漂移的定义&#xff1a;MAC地址漂移是指在同一个VLAN内&#xff0c;一个MAC地址被交换机的两个不同…
阅读更多...
【哈希】1. leetcode 1. 两数之和

【哈希】1. leetcode 1. 两数之和

1 题目描述 题目链接&#xff1a;两数之和 2 题目解析 一般的思维&#xff1a;找到两个数A和B&#xff0c;判断A和B相加是否为target。 我们可以采用逆向思维&#xff1a;找到一个数A&#xff0c;在nums数组中找是否有值等于target - A&#xff0c;因为题目要求只返回一个…
阅读更多...
QT实现改变窗口大小其子控件也自动调节大小

QT实现改变窗口大小其子控件也自动调节大小

创建一个顶层布局即可&#xff0c;一定要在MainWindows或者Widget的下面&#xff01; 观察图标变化 带有禁止的意思是分拆布局&#xff08;当前无布局&#xff09; 现在是添加布局后了 注意&#xff1a;一定是在MainWindows或Widget才可以添加顶层布局&#xff0c;才可以实现…
阅读更多...
Flutter技术学习

Flutter技术学习

以下内容更适用于 不拘泥于教程学习&#xff0c;而是从简单项目入手的初学者。 在开始第一个项目之前&#xff0c;我们先要了解 两个概念。 Widget 和 属性 Widget 是用户界面的基本构建块&#xff0c;可以是任何 UI 元素。属性 是 widget 类中定义的变量&#xff0c;用于配…
阅读更多...
linux 效率化 - zsh + tmux

linux 效率化 - zsh + tmux

文章目录 简介涉及的资料/代码仓库让我们开始吧1. Oh my Zsh!2. 终端主题 - powerlevel10k &#xff08;赋能优雅终端界面&#xff09;3. Oh my Tmux!安装完成&#xff0c;再加点料1. tmux2. zsh 结语进阶配置&#xff08;发烧友关注&#xff09;zsh-vim-mode&#xff08;终端支…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023