常见八大排序(纯C语言版)

目录

基本排序

一.冒泡排序

二.选择排序

三.插入排序

进阶排序（递归实现）

一.快排hoare排序

1.单趟排序

快排步凑

快排的优化

（1）三数取中

（2）小区间优化

二.前后指针法(递归实现)

三.快排的非递归实现(前后指针法的非递归)

快排的挖坑法的实现

二.堆排序

1.建堆的选择

2.堆排序的实现

二希尔排序

三.归并排序(递归实现与非递归的实现)

归并排序（非递归实现）

四.非比较排序(计数排序)

计数排序的缺陷

五.排序总结

稳定性的概念

六,排序的选择题练习与巩固

欢迎各位大佬的关顾，能给个赞就好了QWQ，由于篇幅很大，可以根据目录跳转你想看的排序哦！！

基本排序

一.冒泡排序

冒泡排序即，每次相邻比较排序，每次将最小或最大固定在数组最后

void BubbleSort(int* arr, int len)
{for (int i = 0; i < len; i++){int flag = 1;for (int j = 0; j < len - i-1; j++){if (arr[j] > arr[j+1]){flag = 0;Swap(&arr[j + 1],&arr[j]);}}if (flag)break;}
}

二.选择排序

很明显选择排序就是去找最小或者最大的下标然后赋值给原始位置,代码实现如下

void SelectSort(int* arr, int len)
{for (int i = 0; i < len-1; i++){int min = i;for (int j = i + 1; j < len; j++){if (arr[j] < arr[min])min = j;}Swap(&arr[min], &arr[i]);}
}

但是这种选择排序也太low了让我们来实现一个Plus版本，一次循环找到最大与最小

int SelectSortPlus(int* arr, int len)
{int begin = 0;int end = len - 1;for (int i = begin; i <=end-1; i++){int min = begin;int max = begin;for (int j = i+1; j <= end; j++){if (arr[j] < arr[min])min = j;if (arr[j] > arr[max])max = j;}Swap(&arr[begin], &arr[min]);if (begin == max)//注意这里当begin与max的下标一样的时候，会被先换导致bugmax = min;Swap(&arr[end], &arr[max]);begin++;end--;}
}

三.插入排序

看动图可以很容易的理解插入排序就是将已排好的序的后一个与前面的进行比较，比它大或小的往后移动

void InsertSort(int* a, int len)
{for (int i = 0; i < len - 1; i++){int end = i;int temp = a[end + 1];while (end >= 0){if (temp < a[end]){a[end + 1] = a[end];end--;}else{break;}a[end + 1] = temp;}}
}

进阶排序（递归实现）

一.快排hoare排序

快排有着多种实现方式我们下面这个是hoare（创始人）的排序方式

快速排序是一种高效的排序现在来让我们来实现一下

1.单趟排序

想要写出一个排序首先我们要去理解这个排序的单趟 单趟如图所示

如图我们可以发现它的步骤如下

快排步凑

(1)选出基准值key 为 left

（2）右边r先走找到比key小的停止

(3)右边r找到的情况下,左边L再开始找比key大的值

（3）左边L找到的情况下停止，将这两个值进行交换

循环上面的操作

直到他们相遇，将相遇的位置的值与key值交换

这就是快排的单趟排序，接下来让我们来实现一下

void QuickSort2(int* arr, int left, int right)
{int key = left;int begin = left;int end = right;while (begin < end){//先从右边开始找小 //注意结束条件 begin一定<endwhile (begin < end && arr[end] >= arr[key]){--end;}//再从左边找大while (begin < end && arr[begin] <= arr[key]){++begin;}//两边都找到了之后进行交换Swap(&arr[begin], &arr[end]);}//最后相遇再与key交换Swap(&arr[begin], &arr[key]);}
}

想必这里大家会有一些疑问，为什么

1.为什么要右边先走，左边先走可以吗

2.为什么最后交换key的位置就固定了

3.要怎么样才能实现排序的效果

循环的实现，既然单趟可以固定住key值在整个数里面的想要排序的位置，那我们可不可以将这个数组进行分割[left~key-1]key[key+1~right]

运用递归来实现呢

答案是肯定的

只需要每次递归进行分割，固定n的值的位置，如下图所示

如图所示很明显当我们进行递归的时候每次的位置都将被固定,从而实现了排序

代码如下

void QuickSort2(int* arr, int left, int right)
{//返回条件if (left >= right)return;int key = left;int begin = left;int end = right;while (begin < end){//先从右边开始找小 //注意结束条件 begin一定<endwhile (begin < end && arr[end] >= arr[key]){--end;}//再从左边找大while (begin < end && arr[begin] <= arr[key]){++begin;}//两边都找到了之后进行交换Swap(&arr[begin], &arr[end]);}//最后相遇再与key交换Swap(&arr[begin], &arr[key]);//递归排序分割成两份//[left~key-1] key [key+1~right]最后相遇的指针也是一样的QuickSort2(arr, left, end - 1);QuickSort2(arr, end + 1, right);
}

到这里我们也就完成了阉割版的快排，但是距离真正的快排还是有些距离

现在的这个排序有着致命的缺陷如果说在数组已经是有些的情况下，快排的将会退化，就像是二叉树退化为单叉树一样，如果我们这时还去递归那就会有爆栈（栈溢出）的风险，原因很简单

如下图所示

如果是有序的情况下，那么递归的深度将会变成n如果数据量太大将会爆栈

所以接下来要去实现一下三数取中，小区间优化来对递归快排进行优化

快排的优化

（1）三数取中

选择key值进行,key值的选择就是为了避免这种有序情况的出现，因为选key固定key的位值，我们只需要找到中间的那个数进行固定区间递归的高度将会变为\log n解决了爆栈的风险

int GetMid2(int* arr, int left, int right)
{//三个数进行比较 分类讨论int mid = (left + right) / 2;if (arr[left] < arr[mid]){if (arr[mid] < arr[right]){return mid;}//arr[mid]>arr[right]else if (arr[right] < arr[left]){return left;}else{return right;}}else//arr[left]> arr[mid]{if (arr[mid] > arr[right]){return mid;}//arr[righ]>arr[mid]else if (arr[right]>arr[left]){return left;}else{return right;}}
}
（2）小区间优化

什么是小区间优化？在我们进行快排的时候，如果每次的区间都能二分的化，这个递归的过程是可以看出一颗二叉树，而在满二叉树的叶子节点个数为整棵树的一半，对于快排来说它的最后一层和倒数第二层，是不用去排和只排一个数的，但是却还要开辟栈帧，所以我们这里使用小区间优化带代码如下直接使用当区间小于10时进行插入排序

//小区间优化 提升效率节省空间
if ((right - left + 1) < 10)//减少递归次数
{//加上偏移量leftInsertSort(arr+left, right - left + 1);
}
else
{//进行递归
}

注意事项

二.前后指针法(递归实现)

由于hoare版本的有些复杂要去考虑什么右边先走之类的，所以又有人想出了更加简单跟容易理解的办法，前后指针法，过程如图所示

可以发现与hoare版本大体一致都是去选择key与key比较,不同点在于,只有是cur去找比key小的值，当找到比key小的值的时候++prev然后与cur位置的值进行交换，最后当cur走到最后，prev的值再与key位置的值进行交换，比起hoare版本简单了许多，接下来我们来尝试实现一下

void QuickSortByPointer(int* arr, int left, int right)
{if (left >= right)return;//三数取中int mid = GitMid(arr,left,right);Swap(&arr[mid], &arr[left]);int key = left;int prev = left;int cur = prev+1;//三数取中if ((right - left + 1) < 10){InsertSort(arr+left, right - left + 1);//加上left}else{while (cur <= right){if (arr[key] > arr[cur]&&++prev != cur)//为什么要写成这样？Swap(&arr[prev], &arr[cur]);cur++;}Swap(&arr[prev], &arr[key]);//区间变为[0,prev-1]prev[prev+1,right]QuickSortByPointer(arr, left, prev - 1);//值给错了应该是leftQuickSortByPointer(arr, prev + 1, right);}
}

你以为到这里快排就结束了嘛其实还是马达马达得是(远远没有结束),虽然我们加上三数取中，与小区间的优化但是如果数据量过大还是会有爆栈的风险（栈的空间比较小），所以我们可以使用数据结构的栈来模拟实现程序中的压栈与出栈，（由于是在堆中建立，内存巨大,8G的内存不可能溢出把！）

三.快排的非递归实现(前后指针法的非递归)

可以看见我们先是将每次的单次排序进行封装的

我们可以想象一下在程序中栈帧的建立与销毁的过程，然后我们也可以自己使用数据结构的栈来实现

快排其实是可以看作二叉树的前序遍历的，但是栈又是后进先出，想要先得到左边界的值就需要先进右边，想要得到右边界的值就需要先进左边

void QuickSortNoR(int* arr, int begin, int end)
{Stack st;CreatStack(&st);StackPush(&st, end);StackPush(&st, begin);while (StackGetSize(&st)!=0){int left = StackPop(&st);//我的Pop是即出又返回栈顶元素的因为后进先出想要先得到left进右int right = StackPop(&st);//小区间优化if ((right - left + 1) / 2 < 10)InsertSort(arr + left, right - left + 1);else{//开始模拟递归int key = PartPointer(arr, left, right);//这个函数是每一次的单趟排序if (key + 1 < right)//进行递归由于后进先出 先进右区间{StackPush(&st, right);//后进先出由于我们的右区间是后出 所以先进StackPush(&st, key + 1);}if (left < key - 1)//注意错误之处区间不要写错了{StackPush(&st, key - 1);StackPush(&st, left);}}}
}
int PartPointer(int* arr, int left, int right)
{//三数取中int mid = GitMid(arr, left, right);Swap(&arr[mid], &arr[left]);int key = left;int prev = left;int cur = prev + 1;while (cur <= right){if (arr[key] > arr[cur])Swap(&arr[++prev], &arr[cur]);cur++;}Swap(&arr[prev], &arr[key]);return prev;//返回key的位置 prev就是key中间值 然后进行区间的分割同上
}

快排的挖坑法的实现

（由于篇幅有限这里不在过多讲解）

int PartSort2(int* a, int begin, int end)
{//begin是坑int key = a[begin];while (begin < end){while (begin < end && a[end] >= key)--end;// end给begin这个坑，end就变成了新的坑。a[begin] = a[end];while (begin < end && a[begin] <= key)++begin;// end给begin这个坑，begin就变成了新的坑。a[end] = a[begin];}a[begin] = key;return begin;
}

二.堆排序

学习完了快排，接下来学习堆，首先我们要知道堆的概念，

堆在逻辑结构上是一个完全二叉树，在物理结构上是一个数组，

想要找到儿子节点就是(parent-1)/2

想要找到父亲节点就是child*2+1

如果想要深入理解堆可以看我的这一篇博客堆的实现与堆排序（纯C语言版）-CSDN博客

1.建堆的选择


当我们想要进行排序的时候首先要模拟堆的插入过程进行建堆，这里有个问题如果想要降序排列那么应该建小堆还是大堆呢，在我刚开学学习的时候想的是肯定是建大堆啊因为这样根节点就是最大的然后再出堆,其实这样想就错了，这样只是出堆降序，不是数组本身进行了降序排列，所以降序是其实是建小堆，升序其实是建大堆.那又是怎么实现的呢

2.堆排序的实现

在进行建堆之后（小堆降序来举例），我们就只需要模拟出堆，这时每次最小的数就被放在了最后的位置,最后完成排序后，整个数据就有序,如图当我们想要升序排列的时候建大堆

下面是完整的代码

void HeapSort(int* a, int max)//max为最大个数
{//建队for (int i = 0; i <max; i++){AdjustUp(a, i);//模拟插入建小堆}//排序int end = max - 1;//找到最后一个元素的下标进行交换while (end>0){Swap(&a[0], &a[end]);AdjustDown(a, 0, end);--end;//最后的有序不在排序}
}

其实第一步建堆算法还没有做到极致,还可以倒着向下调整,这样的时间复杂度更低

//建堆法2
for (int i = (max - 1 - 1) / 2; i >= 0; i--)//找到第一个非叶子结点 倒着进行想下调整
{AdjustDown(a, i, max-1);
}

二希尔排序

希尔排序是一个时间复杂度大约为O(N^{1.3})的排序算法，

它其实就是运用的插入排序

它的排序可以分为2步

1.预排序分为gap组进行

2.当gap=1时即为选择排序

希尔排序的实质就是如果在排一个升序的数组，如果大的在很前面，每次就是一步一步的移动，而当有了gap之后，移动的步长将会变大，大的数将会以更快的速度移到后面

我们将插入排序来进行一下比较

void InsertSort(int* a, int len)
{for (int i = 0; i < len - 1; i++){int end = i;int temp = a[end + 1];while (end >= 0){if (temp < a[end]){a[end + 1] = a[end];end--;}else{break;}a[end + 1] = temp;}}
}

可以看见在进行插入排序的时候，此时的步长gap为1，每次只会往后面进行一步，所以我们这里只需去改变想要排序的步长即可

下面是代码的实现

void ShellSort(int* a, int n)
{int gap = n;while (gap > 1){// +1保证最后一个gap一定是1// gap > 1时是预排序// gap == 1时是插入排序gap = gap / 3 + 1;for (size_t i = 0; i < n - gap; ++i){int end = i;int tmp = a[end + gap];while (end >= 0){if (tmp < a[end]){a[end + gap] = a[end];end -= gap;}else{break;}}a[end + gap] = tmp;}}
}

我们可以发现，我们上面是一组一组来排序

也可以多组并走都是一样的

三.归并排序(递归实现与非递归的实现)

归并排序的思想就是分治法(分而治之),如图所示

首先我们要创建一个临时的数组

运用了二叉树的后序遍历的思维，先将数组拆分，拆分后的数组又来进行合并，在进行合并的两个数组分别有序，只需要比较一次将小的放入到临时的数组当中，放完成后再拷贝回去完成排序

重点就是在进行合并的时候两个数组是有序的！

让我们来实现一下

l

999000lkklkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkklkkkkkkkkkkkkkkkkkkkkkkkk                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          222

代码如下

void MergeSort(int* arr, int len)
{int* temp = (int*)malloc(sizeof(int) * len);_MergeSort(arr,temp,0,len-1);free(temp);temp = NULL;
}
void _MergeSort(int* arr, int* temp, int left, int right)
{//返回条件if (left >= right)return;//进行递归//分成[left mid][mid+1,right]不能写成[left mid-1][mid,right]分区间的时候将会出现问题//单趟排序 将左右区间看作有序数组 进行比较放入temp数组中int mid = (left + right) / 2;//[left mid][mid+1,right]int begin1 = left;int begin2 = mid + 1;int end1 = mid;int end2 = right;_MergeSort(arr, temp, begin1, end1);//左区间_MergeSort(arr, temp, begin2, end2);//右区间int i = 0;while (begin1 <= end1 && begin2 <= end2){if (arr[begin1] < arr[begin2]){temp[i++] = arr[begin1++];}else//直接else{temp[i++] = arr[begin2++];}}//循环结束后还有元素全部放后面while (begin1 <= end1){temp[i++] = arr[begin1++];}//循环结束后还有元素全部放后面while (begin2 <= end2){temp[i++] = arr[begin2++];}//进行拷贝回去memcpy(arr+left, temp, i*sizeof(int));
}

归并排序（非递归实现）

想要实现归并的非递归，我们是否还需要像快排一样去模拟栈呢，当我们取模拟栈的时候由于归并的递归是一个后序遍历，而栈无法去记录值，所以使用栈就要用两个，较为麻烦，使用我们直接用下面这种思想

由上面递归实现的归并排序很容易想，其中的gap为每个小组的个数

但是好像还有一个问题，数组越界的问题

当我们使用了上面的数据进行分组的时候，所以我们要进行区间的判断

加入

if (begin2 > len - 1)//begin2已经越界,说明只有一组了没必要再排
{break;
}
if (end2 > len - 1)//end2越界了进行修正即可
{end2 = len - 1;
}

完整的代码如下

void MergeSortNonR(int* a, int n)
{int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc fail");return;}// gap每组归并数据的数据个数int gap = 1;while (gap < n){for (int i = 0; i < n; i += 2 * gap){// [begin1, end1][begin2, end2]int begin1 = i, end1 = i + gap - 1;int begin2 = i + gap, end2 = i + 2 * gap - 1;//printf("[%d,%d][%d,%d] ", begin1, end1, begin2, end2);// 第二组都越界不存在，这一组就不需要归并if (begin2 >= n)break;// 第二的组begin2没越界，end2越界了，需要修正一下，继续归并if (end2 >= n)end2 = n - 1;int j = i;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));}//memcpy(a , tmp , sizeof(int) *n );//printf("\n");gap *= 2;}free(tmp);tmp = NULL;
}

四.非比较排序(计数排序)

接下来让我们来学习最后一个排序，这个排序的特点是非比较的排序，通过建立一个数组来存放数组中每个数出现的次数，来实现排序

首先来思考我们想要开辟的数组的大小，那是否就是原数组的长度大小呢，因为要存储每个元素出现的次数，那么我们开辟数组必须是连续的，在开辟数组长度大小的时候有个细节，如果每次都从0开始建立计数数组，那如果遇到一个最小值为99，最大值为110的数组，那我们还是需要从0开始建立数组，前面明明一个数都没有出现但是我们却还是去开辟的数组，浪费了很多的空间，所以我们只需要去找到最大与最小的那个值，计算出rang=最大值-最小值+1（注意要加一），所以计数数数组的大小为rang，那我们在进行计数的时候就只需要进行-min就可以了

然后是进行排序，当计数数组里不为0说明当前位置有映射值进行自减1.加上min赋值给原数组实现排序效果

代码如下

void CountSort2(int* arr, int len)
{//找到原数组的最大与最小值int min = arr[0];int max = arr[len - 1];for (int i = 0; i < len; i++){if (arr[i] < min){min = arr[i];}if (arr[i] > max){max = arr[i];}}int rang = max - min + 1;//开辟计数数组 注意这里要初始化开辟的计数数组 这样奇计数数组才全是0int* count = (int*)calloc(rang,sizeof(int) * rang);//进行计数for (int i = 0; i < len; i++){count[arr[i] - min]++;}//进行排序int j = 0;for (int i = 0; i < rang; i++){while (count[i]--)//当count[i]的元素不为0的时候说明当前映射有值{arr[j++] = i + min;}}}

计数排序的缺陷

既然计数排序是一种映射的方法，所以是只能对整数进行排列的

五.排序总结

学习完了上面的排序现在我们来进行一下总结，

排序         平局时间复杂度    最坏时间复杂度 最好时间复杂度 稳定性

冒泡排序                O(N^{2})                  O(N^{2})       O(N^{})                稳定 

选择排序                O(N^{2})                 O(N^{2})        O(N^{2})               不稳定

插入排序                O(N^{2})                 O(N^{2})        O(N^{})                稳定

希尔排序                O(N^{1.3})              O(N^{2})        O(N^{1.3})             不稳定

堆排序                    O(N*\log N)  O(N*\log N)O(N*\log N) 不稳定

快速排序                O(N*\log N)   O(N^{2})         O(N*\log N)       不稳定

归并排序                 O(N*\log N)    O(N*\log N)   O(N*\log N) 稳定

 

稳定性的概念

上表的稳定性是什么意思？其实就是相同数据的前后位置是否发生改变，如下面红色5与蓝色5当排序完成后红色5还在蓝色5前面就是稳定的

六,排序的选择题练习与巩固

学完上面的知识，不来两道题检测一下是不知道自己真正掌握了没有的下面让我们来做几道题加深一下印象。

1.用某种排序方法对关键字序列 25 84 21 47 15 27 68 35 20 进行排序，序列的变化情况采样如下：

20 15 21 25 47 27 68 35 84

15 20 21 25 35 27 47 68 84

15 20 21 25 27 35 47 68 84

请问采用的是以下哪种排序算法（ ）

A.选择排序

B.希尔排序

C.归并排序

D.快速排序

答案：D

解析：

此题中的排序是快排二分排序的思想，第一趟的基准值是25，第二趟的基准值分别是20，47，第三趟的基准值分别是15，21，35，68

 

2.下面的排序算法中，初始数据集的排列顺序对算法的性能无影响的有（ ）

① 快速排序

② 希尔排序

③ 插入排序

④ 堆排序

⑤ 归并排序

⑥ 选择排序

A.①④⑤

B.④⑤⑥

C.②③⑥

D.②③⑤⑥

答案：B

解析：

快排： 初始顺序影响较大，有序是，性能最差

插入: 接近有序，性能最好

希尔：希尔是对插入排序的优化，这种优化是在无序的序列中才有明显的效果，如果序列接近有序，反而是插入最优。

堆排，归并，选择对初始顺序不敏感

3.下列排序方法中，每一趟排序结束时都至少能够确定一个元素最终位置的方法是（ ）

① 选择排序

② 归并排序

③ 快速排序

④ 堆排序

A.①④

B.①②④

C.①③④

D.①②③④

 

答案：C

解析：

选择排序每次选一个最值，放在最终的位置

快速排序每次基准值的位置也可以确定

堆排序每次堆顶元素的位置也可以确定

所以这三种方法都可以每次至少确定一个元素的位置

而归并排序每次都需要对n个元素重新确定位置，所以不能保证每次都能确定一个元素位置，有可能每次排序所有元素的位置都为发生变化。

 

4.现有数字序列 5 11 7 2 3 17，目前要通过堆排序进行降序排序，那么由该序列建立的初始堆应为（ ）

A.2 3 7 11 5 17

B.17 11 7 2 3 5

C.17 11 7 5 3 2

D.2 3 5 7 11 17

答案：A

解析：

要降序排列，所以要建小堆，每次把堆顶元素放在当前堆的最后一个位置

建堆要进行向下调整算法（从最后一个非叶子节点开始进行向下调整算法，直到根元素）

5

11 7

2 3 17

5

2 7

11 3 17

2

3 7

11 5 17

所以初始堆序列为： 2 3 7 11 5 17

5.下列选项中，不可能是快速排序第2趟排序后的结果的是（ ）

A.2 3 5 4 6 7 9

B.2 7 5 6 4 3 9

C.3 2 5 4 7 6 9

D.4 2 3 5 7 6 9

 

答案：C

解析：

这里说的是快排的第二趟，即在第一趟快排的结果的基础上进行的，如果已经经过了一趟排序，则会通过第一趟选择的基准值划分两个子区间，每个子区间也会以区间内选择的基准值划分成两部分。

A: 第一趟的基准值可以为2， 第二趟的基准值可以为3

B: 第一趟的基准值可以为2， 第二趟的基准值可以为9

C: 第一趟的基准值只能是9，但是第二趟的基准值就找不出来，没有符合要求的值作为基准值，所以不可能是一个中间结果。

D: 第一趟的基准值可以为9， 第二趟的基准值可以为5

由于个人精力有限，如有错误欢迎指出！！！

小bit！！！

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

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

相关文章

机器学习与数据挖掘知识点总结（一）

机器学习与数据挖掘知识点总结（一）

简介&#xff1a;随着人工智能&#xff08;AI&#xff09;蓬勃发展&#xff0c;也有越来越多的人涌入到这一行业。下面简单介绍一下机器学习的各大领域&#xff0c;机器学习包含深度学习以及强化学习&#xff0c;在本节的机器学习中主要阐述一下机器学习的线性回归逻辑回归&…
阅读更多...
Python | Leetcode Python题解之第138题随机链表的复制

Python | Leetcode Python题解之第138题随机链表的复制

题目&#xff1a; 题解&#xff1a; class Solution:def copyRandomList(self, head: Optional[Node]) -> Optional[Node]:allNode[] # 用一个数组存储所有结点cur1headwhile cur1:allNode.append(cur1)cur1cur1.nextnlen(allNode)allRandom[-1]*n # 用一个数组存储所有节点…
阅读更多...
超详解——识别None——小白篇

超详解——识别None——小白篇

目录 1. 内建类型的布尔值 2. 对象身份的比较 3. 对象类型比较 4. 类型工厂函数 5. Python不支持的类型 总结&#xff1a; 1. 内建类型的布尔值 在Python中&#xff0c;布尔值的计算遵循如下规则&#xff1a; None、False、空序列&#xff08;如空列表 []&#xff0c;空…
阅读更多...
算法学习笔记（7.7）-贪心算法（Dijkstra算法-最短路径问题）

算法学习笔记（7.7）-贪心算法（Dijkstra算法-最短路径问题）

目录 1.最短路径问题 2.Dijkstra算法介绍 3.Dijkstra算法演示 4.Dijkstra算法的代码示例 1.最短路径问题 图论中的一个经典问题&#xff0c;通常是指在一个加权图中找到从一个起始顶点到目标顶点的最短路径。 单源最短路径问题&#xff1a;给定一个加权图和一个起始顶点&…
阅读更多...
【传知代码】Noise2Noise图像去噪（论文复现）

【传知代码】Noise2Noise图像去噪（论文复现）

前言&#xff1a;在数字时代&#xff0c;图像已成为我们记录生活、传达信息、探索世界的重要媒介。然而&#xff0c;随着摄影技术的飞速发展&#xff0c;图像噪声——这一影响图像质量的顽疾&#xff0c;始终困扰着我们。Noise2Noise图像去噪技术为我们提供了一种全新的解决方案…
阅读更多...
第二十七章HTML.CSS综合案例

第二十七章HTML.CSS综合案例

1.产品介绍 效果图如下&#xff1a; 代码部分如下&#xff1a; <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0">…
阅读更多...
Elastic Search （ES）Java 入门实操（1）下载安装、概念

Elastic Search （ES）Java 入门实操（1）下载安装、概念

实现数据查询代码&#xff1a;Elastic Search&#xff08;ES&#xff09;Java 入门实操&#xff08;2&#xff09;搜索代码-CSDN博客 Elastic Search&#xff08;ES&#xff09;Java 入门实操&#xff08;3&#xff09;数据同步-CSDN博客 Elastic Search 官方描述&#xff0c…
阅读更多...
Python下载库

Python下载库

注&#xff1a;本文一律使用windows讲解。 一、使用cmd下载 先用快捷键win R打开"运行"窗口&#xff0c;如下图。 在输入框中输入cmd并按回车Enter或点确定键&#xff0c;随后会出现这个画面&#xff1a; 输入pip install 你想下载的库名&#xff0c;并按回车&…
阅读更多...
贰[2]，VisionMaster/.NetCore的WPF应用程序调用控件

贰[2]，VisionMaster/.NetCore的WPF应用程序调用控件

1&#xff0c;环境 VisionMaster4.2 VisualStudio2022 WPF/.Net6.0 2&#xff0c;记录原因 .NetFrameWork的WPF应用程序调用添加例程.NetFrameWork的Winform应用程序相应的库&#xff0c;不会出现报错&#xff0c;界面也能正常显示操作&#xff0c;但是.NetCore的程序却总是…
阅读更多...
JavaScript入门宝典：核心知识全攻略（下）

JavaScript入门宝典：核心知识全攻略（下）

文章目录 前言一、获取标签元素二、操作标签元素属性1. 属性的操作2. innerHTML 三、数组及操作方法1. 数组的定义2. 数组的操作 四、循环语句五、字符串拼接六、定时器1. 定时器的使用3. 清除定时器 七、ajax1. ajax的介绍2. ajax的使用 前言 JavaScript是前端开发不可或缺的技…
阅读更多...
Typescript 中 tsconfig.json 无法写入文件，因为它会覆盖输入文件

Typescript 中 tsconfig.json 无法写入文件，因为它会覆盖输入文件

先来看看问题 在开发ts项目的时候&#xff0c;包错提示无法写入文件 tsconfig.json无法写入文件"url"因为它会覆盖输入文件 这是tsconfig.json文件配置问题&#xff0c;需要加入下面的配置就好了&#xff1a; {"compilerOptions": {"outDir": …
阅读更多...
【MySQL数据库】：MySQL索引特性

【MySQL数据库】：MySQL索引特性

目录 索引的概念 磁盘 磁盘的基本特征 MySQL与磁盘交互的基本单位 索引的理解 建立测试表 理解单个Page 理解多个Page 页目录 单页情况 多页情况 索引的数据结构 聚簇索引 VS 非聚簇索引 索引操作 创建主键索引 创建唯一索引 创建普通索引 创建全文索引 查询…
阅读更多...
海宁代理记账公司-专业的会计服务

海宁代理记账公司-专业的会计服务

随着中国经济的飞速发展&#xff0c;企业的规模和数量日益扩大&#xff0c;在这个过程中&#xff0c;如何保证企业的财务活动合规、准确无误地进行&#xff0c;成为了每个企业面临的重要问题&#xff0c;专业、可靠的代理记账公司应运而生。 海宁代理记账公司的主要职责就是为各…
阅读更多...
Prism 入门06，发布订阅(入门完结)

Prism 入门06，发布订阅(入门完结)

本章节介绍使用 Prism 框架的消息聚合器 IEventAggregator ，实现如何进行消息发布,订阅,取消订阅的功能 继续使用上一章节使用的 Prism WPF 空模板项目 BlankApp1 1.首先，在使用 Prism 框架当中，进行事件消息的发布和订阅之前，需要定义发布事件的事件消息模型。如下所示：…
阅读更多...
端午节景区视频监控方案：智慧景区EasyCVR视频监控系统构建与运用

端午节景区视频监控方案：智慧景区EasyCVR视频监控系统构建与运用

端午节&#xff0c;作为中国传统节日之一&#xff0c;每年吸引着大量游客前往各地景区参观游览&#xff0c;感受浓厚的文化氛围。然而&#xff0c;随着游客数量的增多&#xff0c;景区管理也面临着越来越多的挑战&#xff0c;其中安全问题尤为突出。因此&#xff0c;实施端午节…
阅读更多...
使用 ESPCN 模型进行超分辨率图像处理

使用 ESPCN 模型进行超分辨率图像处理

前言 使用 ESPCN (Efficient Sub-Pixel CNN) 模型对低分辨率的图像&#xff0c;进行超分辨率处理。 效果展示 lowres 表示低分辨率图像&#xff0c;highres 表示高分辨率图像&#xff0c;prediction 表示模型预测的高分辨率图像&#xff0c;可以看出模型在生成高分辨率图像过…
阅读更多...
力扣hot100：155. 最小栈（栈，辅助栈存储相关信息）

力扣hot100：155. 最小栈（栈，辅助栈存储相关信息）

LeetCode&#xff1a;155. 最小栈 1、尝试单调栈 看到这题说&#xff0c;要常数时间内检索最小元素的栈&#xff0c;想到了单调栈&#xff0c;递增单调栈确实能维护最小值&#xff0c;但是这个最小值是存在一定意义的&#xff0c;即如果后面出现了最小值&#xff0c;那么前面…
阅读更多...
光电管道液位传感器与电容式液位开关相比

光电管道液位传感器与电容式液位开关相比

如今&#xff0c;随着检测液位技术的不断发展&#xff0c;检测液位的方法也越来越多&#xff0c;比如浮球开关、电容式液位传感器、管道式液位传感器等等&#xff0c;那么光电管道液位传感器与电容式液位开关相比&#xff0c;有哪些优势&#xff1f; 光电管道液位传感器采用先…
阅读更多...
论文高级图表绘制（Python语言，局部放大图）

论文高级图表绘制（Python语言，局部放大图）

本文将通过一个具体的示例，展示如何使用Python语言和Matplotlib库来绘制高级图表，包括局部放大图的制作。适用于多条曲线绘制在同一个图表中，但由于数据量过大，导致曲线的细节看不清，需要对细节进行局部放大。如下图： 环境准备 首先，确保你的Python环境中已经安装了以…
阅读更多...
基于SSM+Jsp的高校信息资源共享平台

基于SSM+Jsp的高校信息资源共享平台

开发语言&#xff1a;Java框架&#xff1a;ssm技术&#xff1a;JSPJDK版本&#xff1a;JDK1.8服务器&#xff1a;tomcat7数据库&#xff1a;mysql 5.7&#xff08;一定要5.7版本&#xff09;数据库工具&#xff1a;Navicat11开发软件&#xff1a;eclipse/myeclipse/ideaMaven包…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023