常见排序算法详解

目录

排序的相关概念

排序:

稳定性:

内部排序:                                                                        

外部排序:

常见的排序:

常见排序算法的实现

插入排序:

基本思想:

直接插入排序:

希尔排序(缩小增量排序):

选择排序:

基本思想:

直接选择排序:

堆排序:

交换排序:

基本思想:

冒泡排序:

快速排序:

Hoare版本:

挖坑法:

前后指针法:

快排递归优化:

Hoare版本(优化):

挖坑法(优化):

前后指针(优化):

非递归快排:

归并排序:

基本思想:

递归版本:

非递归版本:

计数排序:

基本思想:

总结

排序的相关概念

排序:

所谓排序,就是使用一定的方法使一段可排序的序列变得有一定的顺序(递增或递减)。

稳定性:

假定在待排序的序列中,存在多个具有相同的关键字的元素,若经过排序,这些元素的相对次
序保持不变
,即在原序列中,r[i]=r[j],且r[i]在r[j]之前,而在排序后的序列中,r[i]仍在r[j]之前,则称这种排序算法是稳定的;否则称为不稳定的。   

内部排序:                                                                        

数据元素全部放在内存中进行排序

外部排序:

数据元素太多无法同时全部放进内存中进行排序。因此,需要将待排序的数据存储在外存(磁盘)上,排序时再把数据一部分一部分地调入内存中进行排序,在排序过程中需要多次进行内存和外存之间地交换。这种排序方法就称作外部排序。

常见的排序:

常见排序算法的实现

插入排序:

基本思想:

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中,直到所有的记录插入完为止,得到一个新的有序序列 。

日常生活中玩扑克牌拼牌时就用到了插入排序。

直接插入排序:

当插入第i(i>=1)个元素时,前面的i-1个元素已经排好序,此时用a[i]的值依次与a[i-1],a[i-2],…,a[0]的值进行比较,找到插入位置即将a[i]插入,原来位置上的元素顺序后移。

排序过程如下图所示:

代码如下:

void InsertSort(int* a, int n)
{assert(a);int i = 0, j = 0;for (i = 1; i < n; i++)//从第二个元素开始,依次与前边的元素比较{int tem = a[i];j = i - 1;while (j >= 0){if (a[j] > tem){a[j + 1] = a[j];}else{break;}j--;}a[j + 1] = tem;}
}

特性总结:

1. 元素集合越接近有序,直接插入排序算法的时间效率越高
2. 时间复杂度:O(N^2)
3. 空间复杂度:O(1)
4. 稳定性:稳定

希尔排序(缩小增量排序):

先选定一个整数gap,把待排序数据分成gap个组,所有距离为gap的数据分在同一组内,并对每一组内的记录进行排序。然后,缩小gap重复上述分组和排序的工作。当到达gap=1时,所有数据在同一组内排好序。

排序过程如下:

代码如下:

void ShellSort(int* a, int n)
{assert(a);int gap = n;while (gap > 1){gap /= 2;//一组一组排序/*int i = 0;for (i = 0; i < gap; i++){int j = 0;for (j = i; j < n - gap; j += gap)//排一组{int front = j;int back = j + gap;int tem = a[back];//记录back位置原始数据while (front >= 0){if (tem < a[front]){a[back] = a[front];front -= gap;back -= gap;}else{break;}}a[front + gap] = tem;}}*///多组同时排序int j = 0;for (j = 0; j < n - gap; j ++)//多组同时排{int front = j;int back = j + gap;int tem = a[back];//记录back位置原始数据while (front >= 0){if (tem < a[front]){a[back] = a[front];front -= gap;back -= gap;}else{break;}}a[front + gap] = tem;}}}

特性总结:

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序,目的是让数组更接近于有序。当gap = 1时,数组已经接近有序的了,这样就会很快。这样整体而言,可以达到优化的效果。
3. 时间复杂度:希尔排序的时间复杂度不好计算,因为gap的取值方法很多,导致很难去计算,但有一个大致的范围O(N^1.3)~O(N^2)

4.空间复杂度:O(1)

选择排序:

基本思想:

每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置(或末尾位置),直到全部待排序的数据元素排完。

直接选择排序:

在元素集合a[i]--a[n-1]中选择最大(小)的数据元素,若它不是这组元素中的最后一个(第一个)元素,则将它与这组元素中的最后一个(第一个)元素交换,在剩余的a[i]--a[n-2](a[i+1]--a[n-1])集合中,重复上述步骤,直到集合剩余1个元素。

排序过程如下:

代码如下:

void swap(int* p1, int* p2)//交换函数
{int k = *p1;*p1 = *p2;*p2 = k;
}void SelectSort(int* a, int n)
{assert(a);//每次选最小的放前边//int i = 0, j = 0;//int mini = 0;//最小数的下标//for (j = 0; j < n; j++)//{//	mini = j;//	for (i = j + 1; i < n; i++)//	{//		if (a[i] < a[mini])//		{//			mini = i;//		}//	}//	swap(&a[mini], &a[j]);//}//优化--一次选出区间中最大的和最小的,分别插入头部和尾部int begin = 0, end = n - 1;while (begin < end){int maxi = end, mini = begin;//最大最小值的下标int i = begin;for (; i <= end; i++){if (a[i] < a[mini]){mini = i;}if (a[i] > a[maxi]){maxi = i;}}swap(&a[begin], &a[mini]);if (maxi == begin)//防止原begin位置是最大值,被换到mini位置{maxi = mini;}swap(&a[end], &a[maxi]);begin++;end--;}
}

特性总结:

1. 直接选择排序思考非常好理解,但是效率不是很好,实际中很少使用
2. 时间复杂度:O(N^2)
3. 空间复杂度:O(1)
4. 稳定性:不稳定

堆排序:

堆排序即利用堆的思想来进行排序,思路如下:
1. 建堆
升序:建大堆
降序:建小堆
2. 利用堆删除思想来进行排序
因为堆顶元素一定是最大值(或最小值)每次把堆顶元素与最后一个元素交换,然后把数组尾指针向前移动1,再对新的堆顶元素进行向下调整,重复上述操作,直至数组尾指针指向第一个元素,此时的数组中的数据就是一个有序的序列。

代码如下:

void swap(int* p1, int* p2)//交换函数
{int k = *p1;*p1 = *p2;*p2 = k;
}//向下调整(建大堆)
void HeapDown(int* a, int parent, int n)
{assert(a);int child = parent * 2 + 1;//左孩子while (child < n){if (child+1 < n && a[child] < a[child + 1])//找到大的{child += 1;}if (a[child] > a[parent])//大的孩子取代父亲{swap(&a[child], &a[parent]);parent = child;child = parent * 2 + 1;}else{break;}}
}//堆排序
void HeapSort(int* a, int n)
{assert(a);int parent = (n - 1 - 1) / 2;//建大堆for (parent; parent >= 0; parent--){HeapDown(a, parent, n);}//排序int end = n - 1;while (end >= 0){swap(&a[0], &a[end]);//把最大的放最后,从根向下调整HeapDown(a, 0, end);//从根向下调整end--;}}

特性总结:

1. 堆排序使用堆来选数,效率就高了很多。
2. 时间复杂度:O(N*logN)
3. 空间复杂度:O(1)
4. 稳定性:不稳定

交换排序:

基本思想:

根据序列中两个元素值的比较结果来决定是否交换这两个元素在序列中的位置,进而达到将值较大的元素向序列的尾部移动,值较小的元素向序列的前部移动的目的。

冒泡排序:

两两元素相比,前一个比后一个大就交换,直到将最大的元素交换到末尾位置,这是第一趟排序,第二趟找出第二大的语速放在倒数第二个位置……进行n-1趟排序后,全部数据就是有序的了。

排序动图如下:

代码如下:

void swap(int* p1, int* p2)//交换函数
{int k = *p1;*p1 = *p2;*p2 = k;
}//冒泡排序
void BubbleSort(int* a, int n)
{assert(a);int i = 0, j = 0;for (i = 0; i < n - 1; i++){int flag = 0;//标记是否进行过交换for (j = 1; j < n - i; j++){if (a[j-1] > a[j])//每次相邻两个交换{/*int k = a[i];a[i] = a[j];a[j] = k;*/swap(&a[j-1], &a[j]);flag++;}}if (flag == 0){break;}}
}

特性总结:

1. 冒泡排序是一种非常容易理解的排序
2. 时间复杂度:O(N^2)
3. 空间复杂度:O(1)
4. 稳定性:稳定

快速排序:

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法,其基本思想为:任取待排序元素序列中的某元素作为基准值,将待排序集合分割成两子序列,左子序列中所有元素均小于基准值,右子序列中所有元素均大于基准值,然后最左右子序列重复该过程,直到所有元素都排列在相应位置上为止。

Hoare版本:

1、选最左边作key,右边先走找到比key小的值

2、左边后走找到大于key的值

3、然后交换left和right的值

4、一直循环重复上述1 2 3步

5、两者相遇时的位置,与最左边选定的key值交换(因为是让右边先走,保证了最后相遇时,该位置的值一定是小于key的)

排序过程如下:

代码如下:

void swap(int* p1, int* p2)//交换函数
{int k = *p1;*p1 = *p2;*p2 = k;
}//Hoare
int PartSort1(int* a, int left, int right)
{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]);//因为是右边先开始循环,则当left=right时,a[left]一定小于a[keyi]return left;
}void QuickSort(int* a, int begin, int end)
{if (begin >= end){return;}int keyi = PartSort1(a, begin, end);QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);}
挖坑法:

创建变量key储存最左边值,以最左边为第一个坑位,不断填充坑位,并不断改变坑位的位置,直至左右指针相遇,此时为最后一个坑位,再把key填入。

代码入下:

//挖坑法
int PartSort2(int* a, int left, int right)
{int key = a[left];int hold = left;//坑位while (left < right){while (left < right && a[right] >= key){right--;}a[hold] = a[right];hold = right;//更新坑位while (left < right && a[left] <= key){left++;}a[hold] = a[left];hold = left;//更新坑位}a[left] = key;return left;
}void QuickSort(int* a, int begin, int end)
{if (begin >= end){return;}int keyi = PartSort2(a, begin, end);QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);
}
前后指针法:

代码入下:

void swap(int* p1, int* p2)//交换函数
{int k = *p1;*p1 = *p2;*p2 = k;
}//前后指针
int PartSort3(int* a, int left, int right)
{int keyi = left;int prev = left;int cur = left + 1;//cur找比a[keti]小的就和prev后一个交换位置while (cur <= right){if (a[cur] < a[keyi]){swap(&a[++prev], &a[cur]);}cur++;}swap(&a[prev], &a[keyi]);return prev;
}void QuickSort(int* a, int begin, int end)
{if (begin >= end){return;}int keyi = PartSort3(a, begin, end);QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);
}
快排递归优化:

1.三数取中:

快速排序对于数据是敏感的,如果这个序列是非常无序,杂乱无章的,那么快速排序的效率是非常高的,可是如果数列有序,时间复杂度就会从O(N*logN)变为O(N^2),相当于冒泡排序了。若每趟排序所选的key都正好是该序列的中间值,即单趟排序结束后key位于序列正中间,那么快速排序的时间复杂度就是O(NlogN),但是这是理想情况,当我们面对一组极端情况下的序列,就是有序的数组,选择左边作为key值的话,那么就会退化为O(N^2)的复杂度,所以此时我们选择首位置,尾位置,中间位置的数分别作为三数,选出值大小在中间的数,放到最左边,这样选key还是从左边开始,这样优化后,就不会出现选到最大值或最小值的极端情况了。

2.小区间优化:

随着递归深度的增加,递归次数以每层2倍的速度增加,这对效率有着很大的影响,当待排序序列的长度分割到一定大小后,继续分割的效率比插入排序要差,此时可以使用插排而不是快排。

我们可以当划分区间长度小于10的时候,用插入排序对剩下的数进行排序

Hoare版本(优化):
void swap(int* p1, int* p2)//交换函数
{int k = *p1;*p1 = *p2;*p2 = k;
}//三数取中
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//a[mid]<a[right]{if (a[left] > a[right]){return right;}else{return left;}}}else//a[left]<a[mid] {if (a[left] > a[right]){return left;}else//a[left]<a[right]{if (a[mid] > a[right]){return right;}else{return mid;}}}
}int PartSort1(int* a, int left, int right)
{int mid = GetMid(a, left, right);//三数取中swap(&a[mid], &a[left]);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]);//因为是右边先开始循环,则当left=right时,a[left]一定小于a[keyi]return left;
}void QuickSort(int* a, int begin, int end)
{if (begin >= end){return;}if (end - begin + 1 > 10)//小区间优化{int keyi = PartSort1(a, begin, end);QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);}else{InsertSort(a + begin, end - begin + 1);//调用直接插入排序}}
挖坑法(优化):
void swap(int* p1, int* p2)//交换函数
{int k = *p1;*p1 = *p2;*p2 = k;
}//三数取中
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//a[mid]<a[right]{if (a[left] > a[right]){return right;}else{return left;}}}else//a[left]<a[mid] {if (a[left] > a[right]){return left;}else//a[left]<a[right]{if (a[mid] > a[right]){return right;}else{return mid;}}}
}//挖坑法
int PartSort2(int* a, int left, int right)
{int mid = GetMid(a, left, right);swap(&a[mid], &a[left]);int key = a[left];int hold = left;//坑位while (left < right){while (left < right && a[right] >= key){right--;}a[hold] = a[right];hold = right;//更新坑位while (left < right && a[left] <= key){left++;}a[hold] = a[left];hold = left;//更新坑位}a[left] = key;return left;
}void QuickSort(int* a, int begin, int end)
{if (begin >= end){return;}if (end - begin + 1 > 10)//小区间优化{int keyi = PartSort2(a, begin, end);QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);}else{InsertSort(a + begin, end - begin + 1);//调用直接插入排序}}
前后指针(优化):
void swap(int* p1, int* p2)//交换函数
{int k = *p1;*p1 = *p2;*p2 = k;
}int PartSort3(int* a, int left, int right)
{int keyi = left;int prev = left;int cur = left + 1;//cur找比a[keti]小的就和prev后一个交换位置while (cur <= right){if (a[cur] < a[keyi]){swap(&a[++prev], &a[cur]);}cur++;}swap(&a[prev], &a[keyi]);return prev;
}void QuickSort(int* a, int begin, int end)
{if (begin >= end){return;}if (end - begin + 1 > 10)//小区间优化{int keyi = PartSort3(a, begin, end);QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);}else{InsertSort(a + begin, end - begin + 1);//直接调用插入排序}}
非递归快排:

当数据量较大时,一直递归调用就会一直开辟栈帧,增加栈的消耗,因此我们可以人工创建一个栈结构,代替递归调用开辟新的栈帧。

关于栈我在栈和队列详解中有详细介绍,在这里就不再过多介绍。

具体思路如下:

1. 申请一个栈,将整个数组的起始位置和终点位置入栈,起始位置先进栈。

2. 利用栈的特性(后进先出),末位置后进栈,所以末位置先出栈。 定义right、left接收的靠近栈顶的两个元素,作为排序序列的始末位置。

3. 对数组进行一次单趟排序,返回一个下标keyi。

4. 此时待排序列被分为[left,keyi-1],keyi,[keyi+1,right]三段,再把左右两边区间的始末位置入栈(若该区间合法),要求区间起始位置先进栈。

5. 重复2、3、4操作直至栈内为空。

代码如下:

//快速排序(非递归)
void QuickSortNonr(int* a, int n)
{ST st;STInit(&st);//栈储存[0,n-1]区间左右下标,先入右下标,后入左下标STPush(&st, n - 1);STPush(&st, 0);while (!STEmpty(&st)){int left = STTop(&st);STPop(&st);int right = STTop(&st);STPop(&st);int keyi = PartSort3(a, left, right);//[left,right]区间分为[left,keyi-1],keyi,[keyi+1,right]if (keyi + 1 < right)//入[keyi+1,right]区间下标{STPush(&st, right);STPush(&st, keyi + 1);}if (keyi - 1 > left)//入[left,keyi-1]区间下标{STPush(&st, keyi - 1);STPush(&st, left);}}STDestroy(&st);
}

特性总结:

1. 快速排序整体的综合性能和使用场景都是比较好的,所以才敢叫快速排序
2. 时间复杂度:O(N*logN)
3. 空间复杂度:O(logN)
4. 稳定性:不稳定

归并排序:

基本思想:

归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide andConquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列,先使每个子序列有序,再合并子序列并保证其有序。若将两个有序表合并成一个有序表,称为二路归并。 归并排序核心步骤:

递归版本:

void MerSort(int* a, int* tem, int left, int right)
{if (left >= right){return;}//递归划分区间int mid = (left + right) / 2;MerSort(a, tem, left, mid);MerSort(a, tem, mid + 1, right);//归并到tem数组int begin1 = left, end1 = mid;int begin2 = mid + 1, end2 = right;int index = begin1;while (begin1 <= end1 && begin2 <= end2){if (a[begin1] < a[begin2]){tem[index++] = a[begin1++];}else{tem[index++] = a[begin2++];}}while (begin1 <= end1){tem[index++] = a[begin1++];}while (begin2 <= end2){tem[index++] = a[begin2++];}//拷贝回原数组---因为每次都要从原数组中归并到tem数组中,因此每次归并完后都要拷贝回原数组memcpy(a + left, tem + left, sizeof(int) * (right - left + 1));
}
//归并排序
void MergeSort(int* a, int n)
{int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc fail");exit(-1);}MerSort(a, tmp, 0, n - 1);free(tmp);
}

非递归版本:

与快排类似,当数据量较大时,一直递归调用会增加栈的消耗,因此我们可以考虑改非递归的方法实现。

归并改非递归时,可以定义一个gap作为每次归并的区间长度,一趟归并后再把gap乘以2,作为新的归并区间长度,继续归并,直至全部归并完成。其关键在于对边界的控制:

代码如下:

//归并排序(非递归)
void MergeSortNonr(int* a, int n)
{int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc fail");exit(-1);}int gap = 1;//每次归并的长度while (gap < n){int i = 0;for (i = 0; i < n; i += gap * 2){int begin1 = i, end1 = i + gap - 1;int begin2 = i + gap, end2 = i + gap + gap - 1;if (begin2 >= n || end1 >= n)//要归并的第二个区间不存在,直接退出{//memcpy(tmp + i, a + i, sizeof(int) * (n - i));//把不归并的数据提前拷贝进tmp数组,防止因为a数组没有全部进行归并,tmp数组中存在随机值,//进而导致后续把tmp数组数据拷贝进a数组时,拷贝随机数据进a数组break;}if (end2 >= n)//要归并的第二个区间,右边越界,重置右区间{end2 = n - 1;}//printf("[%d,%d][%d,%d]", begin1, end1, begin2, end2);//打印每次归并区间int index = begin1;while (begin1 <= end1 && begin2 <= end2){if (a[begin1] < a[begin2]){tmp[index++] = a[begin1++];}else{tmp[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));//每次归并完成后,把tmp中数据拷贝进a数组,防止丢失数据}//memcpy(a, tmp, sizeof(int) * n);//一趟归并后再把tmp数组的数据拷贝进a数gap *= 2;}free(tmp);
}

特性总结:

1. 归并的缺点在于需要O(N)的空间复杂度,归并排序的思考更多的是解决在磁盘中的外排序问题。
2. 时间复杂度:O(N*logN)
3. 空间复杂度:O(N)
4. 稳定性:稳定

计数排序:

基本思想:

遍历数组,统计数组中每个元素的出现频率,再按顺序放回原数组。

需要注意的是,由于待排序列不一定是从0开始的且不知道要创建多大的数组进行计数,因此在遍历数组统计频率时,要同时找出最大最小值,每次计数时,用该位置数值减去最小值即为该数对应的下标,用最大值减去最小值再加1就是要创建的计数数组的大小

代码如下:

// 计数排序
void CountSort(int* a, int n)
{int min = a[0];int max = 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* count = (int*)malloc(sizeof(int) * range);if (count == NULL){perror("malloc fail");exit(-1);}memset(count, 0, sizeof(int) * range);//每个数减去min就是对应的下标for (int i = 0; i < n; i++){count[a[i] - min]++;}//重新写入原数组,下标+min就是原始值int i = 0;for (int j = 0; j < range; j++){while (count[j]--){a[i++] = j + min;}}free(count);
}

特性总结:

1. 计数排序在数据范围集中时,效率很高,但是适用范围及场景有限。
2. 时间复杂度:O(MAX(N,范围))
3. 空间复杂度:O(范围)

4. 稳定性:稳定

总结

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

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

相关文章

自学接口测试系列 —— 自动化测试用例设计基础!

一、接口测试思路总结 ❓首先我们在进行接口测试设计前思考一个问题&#xff1a;接口测试&#xff0c;测试的是什么&#xff1f; ❗我们必须要知道&#xff0c;接口测试的本质&#xff1a;是根据接口的参数&#xff0c;设计输入数据&#xff0c;验证接口的返回值。 那么接口…

day24-JS进阶(构造函数,new实例化,原型对象,对象原型,原型继承,原型链)

目录 构造函数 深入对象 创建对象三种方式 构造函数 new实例化执行过程(important!) 实例成员&静态成员 实例对象&实例成员 静态成员 内置构造函数 基本包装类型 Object Object.keys(obj)返回所有键组成的字符串数组 Object.values(obj)返回所有值组成的字…

Nginx支持SNI证书,已经ssl_server_name的使用

整理了一些网上的资料&#xff0c;这里记录一下&#xff0c;供大家参考 什么是SNI&#xff1f; 传统的应用场景中&#xff0c;一台服务器对应一个IP地址&#xff0c;一个域名&#xff0c;使用一张包含了域名信息的证书。随着云计算技术的普及&#xff0c;在云中的虚拟机有了一…

RPC分布式网络通信框架项目

文章目录 对比单机聊天服务器、集群聊天服务器以及分布式聊天服务器RPC通信原理使用Protobuf做数据的序列化&#xff0c;相比较于json&#xff0c;有哪些优点&#xff1f;环境配置使用项目代码工程目录vscode远程开发Linux项目muduo网络库编程示例CMake构建项目集成编译环境Lin…

在Android中实现动态应用图标

在Android中实现动态应用图标 你可能已经遇到过那些能够完成一个神奇的技巧的应用程序——在你的生日时改变他们的应用图标&#xff0c;然后无缝切换回常规图标。这是一种引发你好奇心的功能&#xff0c;让你想知道&#xff0c;“他们到底是如何做到的&#xff1f;”。嗯&…

HTML 笔记 表格

1 表格基本语法 tr&#xff1a;table row th&#xff1a;table head 2 表格属性 2.1 基本属性 表格的基本属性是指表格的行、列和单元格但并不是每个表格的单元格大小都是统一的&#xff0c;所以需要设计者通过一些属性参数来修改表格的样子&#xff0c;让它们可以更更多样…

VR全景展示带来旅游新体验,助力旅游业发展!

引言&#xff1a; VR&#xff08;虚拟现实&#xff09;技术正以惊人的速度改变着各行各业&#xff0c;在旅游业中&#xff0c;VR全景展示也展现了其惊人的影响力&#xff0c;为景区带来了全新的宣传机会和游客体验。 一&#xff0e;什么是VR全景展示&#xff1f; VR全景展示是…

华硕平板k013me176cx线刷方法

1.下载adb刷机工具, 或者刷机精灵 2.下载刷机rom包 华硕asus k013 me176cx rom固件刷机包-CSDN博客 3.平板进入刷机界面 进入方法参考&#xff1a; ASUS (k013) ME176CX不进入系统恢复出厂设置的方法-CSDN博客 4.解压ME176C-CN-3_2_23_182.zip&#xff0c;把UL-K013-CN-3.2.…

软件测试面试之问——角色扮演

作为软件测试工程师&#xff0c;在求职面试中经常会被问到这样一个问题&#xff1a;你认为测试工程师在企业中扮演着什么样的角色呢&#xff1f; 某度百科是这样概括的&#xff1a;“软件测试工程师在一家软件企业中担当的是‘质量管理’角色&#xff0c;及时发现软件问题并及…

2.5 数字传输系统

笔记&#xff1a; 针对这一节的内容&#xff0c;我为您提供一个笔记的整理方法。将内容按重要性、逻辑关系进行组织&#xff0c;再进行简化。 ## 2.5 数字传输系统 ### 背景介绍&#xff1a; 1. **早期电话网**&#xff1a;市话局到用户采用双绞线电缆&#xff0c;长途干线采…

css的gap设置元素之间的间隔

在felx布局中可以使用gap来设置元素之间的间隔&#xff1b; .box{width: 800px;height: auto;border: 1px solid green;display: flex;flex-wrap: wrap;gap: 100px; } .inner{width: 200px;height: 200px;background-color: skyblue; } <div class"box"><…

【Unity】RenderFeature笔记

【Unity】RenderFeature笔记 RenderFeature是在urp中添加的额外渲染pass&#xff0c;并可以将这个pass插入到渲染列队中的任意位置。内置渲染管线中Graphics 的功能需要在RenderFeature里实现,常见的如DrawMesh和Blit ​ 可以实现的效果包括但不限于 后处理&#xff0c;可以编写…

访问控制、RBAC和ABAC模型

访问控制、RBAC和ABAC模型 访问控制 访问控制的目的是保护对象&#xff08;数据、服务、可执行应用该程序、网络设备或其他类型的信息技术&#xff09;不受未经授权的操作的影响。操作包括&#xff1a;发现、读取、创建、编辑、删除和执行等。 为实现访问控制&#xff0c; 计…

JavaScript系列从入门到精通系列第十六篇:JavaScript使用函数作为属性以及枚举对象中的属性

文章目录 前言 1&#xff1a;对象属性可以是函数 2&#xff1a;对象属性函数被称为方法 一&#xff1a;枚举对象中的属性 1&#xff1a;for...in 枚举对象中的属性 前言 1&#xff1a;对象属性可以是函数 对象的属性值可以是任何的数据类型&#xff0c;也可以是函数。 v…

linux系统中常见注册函数的使用方法

大家好&#xff0c;今天给大家分享一下&#xff0c;linux系统中常见的注册函数register_chrdev_region()、register_chrdev()、 alloc_chrdev_region()的使用方法​。 一、函数包含的头文件&#xff1a; 分配设备编号&#xff0c;注册设备与注销设备的函数均在fs.h中申明&…

mac文件为什么不能拖进U盘?

对于Mac用户来说&#xff0c;可能会遭遇一些烦恼&#xff0c;比如在试图将文件从Mac电脑拖入U盘时&#xff0c;却发现文件无法成功传输。这无疑给用户带来了很大的不便。那么&#xff0c;mac文件为什么不能拖进U盘&#xff0c;看完这篇你就知道了。 一、U盘的读写权限问题 如果…

[Python入门教程]01 Python开发环境搭建

Python开发环境搭建 本文介绍python开发环境的安装&#xff0c;使用anaconda做环境管理&#xff0c;VS code写代码。搭建开发环境是学习的第一步&#xff0c;本文将详细介绍anaconda和vs code的安装过程&#xff0c;并测试安装结果。 视频教程链接&#xff1a;https://www.bil…

localhost和127.0.0.1都可以访问项目,但是本地的外网IP不能访问

使用localhost和127.0.0.1都可以访问接口&#xff0c;比如&#xff1a; http://localhost:8080/zhgl/login/login-fy-list或者 http://127.0.0.1:8080/zhgl/login/login-fy-list返回json {"_code":10000,"_msg":"Success","_data":…

毛玻璃用户卡交互

效果展示 页面结构组成 从效果展示可以看到&#xff0c;此效果都是比较常规的。主要的核心就是卡片的悬停效果。 CSS 知识点 backdrop-filter 回顾transitiontransform 页面基础布局实现 <section><div class"container"><div class"card&q…

基于虚拟阻抗的下垂控制——孤岛双机并联Simulink仿真

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…