数据结构之八大排序

𝙉𝙞𝙘𝙚!!👏🏻‧✧̣̥̇‧✦👏🏻‧✧̣̥̇‧✦ 👏🏻‧✧̣̥̇:Solitary_walk

      ⸝⋆   ━━━┓
     - 个性标签 - :来于“云”的“羽球人”。 Talk is cheap. Show me the code
┗━━━━━━━  ➴ ⷯ

本人座右铭 :   欲达高峰,必忍其痛;欲戴王冠,必承其重。

👑💎💎👑💎💎👑 
💎💎💎自💎💎💎
💎💎💎信💎💎💎
👑💎💎 💎💎👑    希望在看完我的此篇博客后可以对你有帮助哟

👑👑💎💎💎👑👑   此外,希望各位大佬们在看完后,可以互相支持,蟹蟹!
👑👑👑💎👑👑👑

 思维导图:

1直接插入排序
1.1插入排序的思想

把待排序的数据依次与当前已经有序的数据进行比较,直到待排的数据全部排完得到一组新的有序的数据

生活中的玩扑克牌就是插入排序的一种体现

动图的过程:

分析:

1.2代码的实现
void Insert_sort(int* a, int num)
{for (int i = 1; i < num; i++)  //i= 1默认只有一个数的时候有序{//升序排int end = i - 1;int key = a[i];while (end >= 0){if (key < a[end]){//后挪数据a[end + 1] = a[end];end--;}else //key >= a[end]break;}a[end + 1] = key;//break出来或者是end= -1都可以把key解决掉}}
1.3插入排序对应的时间复杂度以及空间复杂度的分析

时间复杂度

最好的情况下:原数组本身就是升序的,在对数组进行升序排列,(N-1)个数一共比较(N-1)次,此时不需要进行数据的挪动,所以时间复杂度是 O(N)

最坏情况:原数组本身就是逆序的,当你想进行升序排列的话,(N-1)个数一共需要进行O(N^2)级别次,每比较一次就进行一次数据挪动,所以对应时间复杂度 O(N^2) 

2希尔排序(缩小增量法)

希尔排序是对直接插入排序的优化

2.1希尔排序的思想

先选定一个整数,把待排序文件中所有记录分成多个组,所有距离为gap(取决于数组大小)分在同一组内,并对每一组内的记录进行排序,重复上述分组和排序的工作。当 gap=1时,所有记录在一组内已经是有序

总的来说就是先对原数组进行预排序,让数组接近有序,在进行一次直接排序即可有序

插入排序可以视为特殊的希尔排序。

分析:

接下来就是对数组进行预排序:注意是在原数组的空间进行排序的,预排序的关键就是如何确定 gap的值以及下标边界的范围

单趟排序用直接插入排序来进行。

进行第一趟的排序

不止一趟的排序:再来一个for循环搞定多趟的排序

 gap具体的取值由数组的东西而决定,一般对于gap的取值有2个方法可行,但是需要注意条件的判断以及必须保证 gap =  1的时候也能进行排序, gap = N / 2  或者是   gap =( N / 3) + 1,注意gap取不同的值对应结束的条件不同

2.2代码的实现
void Shell_sort(int* a, int num)
{/*1:预排序:让他内部接近有序2:整个直接排序*///int gap = 3;int gap = num;//for (int i = 0; i < gap; i++)//gap组的排序while (gap >= 1){gap /= 2; //一定可以保证gap = 1的时候进行排序for (int i = 0; i < gap; i++)  //多趟排序{//单趟排序//int end_i = i;for (int j = i + gap; j < num - i; j += gap) // j < num-i 这个结束条件必须不能越界{int end_i = j - gap;int tmp = a[j];//必须进行保存,要不然挪动数据造成覆盖while (end_i >= 0)//条件注意{if (tmp < a[end_i]){//挪动数据//a[end_i + gap] = tmp;// erra[end_i + gap] = a[end_i];// errend_i = end_i - gap;}elsebreak;}a[end_i + gap] = tmp;}}}//Insert_sort(a, num);
}
2.3希尔排序对应的时间复杂度以及空间复杂度的分析

空间复杂度是O(1)并不需要额外的空间

对于时间复杂度的分析其实是有争议的,并没有一个具体的,但在 O(N *logN)~O(N^2)

3选择排序
3.1选择排序的思想

如果有N个元素需要排序,默认第一个元素为有序的,那么首先从N-1个元素中找到最小的那个元素与第0位置上的元素交换(重复以上过程)然后再从剩下的N-2个元素中找到最小的元素与下标为的1元素交换,之后再从剩下的N-2个元素中找到最小的元素与倒数第2位置上的元素交换,.......直到所有元素都排序好。

分析:

3.2代码的实现
void Select_sort(int* a, int num)
{for (int j = 0; j < num; j++){int min_i = j;int i = j + 1;//单趟排序for (i; i < num; i++){//升序排if (a[i] < a[min_i])min_i = i;}Swap(&a[j], &a[min_i]);}
}

 这个代码很好理解,其实他还是有可以优化的空间

优化版本:每一趟排序把最大的数和最小的数同时选出

void Select_sort(int* a, int num)
{//进行优化 每一趟排序找出当前数组里最小和最大的数因为一个升序的数组最小的数一定在第一个位置(相对而言)最大的数一定在最后一个位置(相对而言)int begin = 0;int end = num - 1;while (begin < end){//假设每趟排序中第一个数最大,最小,注意第一个数不一定下标为0int min_i = begin;int max_i = begin;for (int i = begin+1; i <= end ; i++){if (a[i] > a[max_i])max_i = i;if (a[i] < a[min_i])min_i = i;}Swap(&a[min_i], &a[begin]);//注意可能begin对应的数为最大,当与最小的数交换后,最大的数来到min_i对应的位置if (begin == max_i) //注意是下标max_i = min_i;//if (max_i != end) //当end位置就是最大的数就不用交换Swap(&a[max_i], &a[end]);begin++;end--;}
}
3.3选择排序对应的时间复杂度以及空间复杂度的分析

时间复杂度:

空间复杂度:O(1)这个算法并没有开辟额外的空间 

4堆排序

对于堆排序而言,可以采用向上调整来进行排序,也可以采用向下调整来进行排序,只不过二者的效率是不同的

4.1堆排序的思想

排升序也好,降序也罢,让堆顶元素与堆尾元素进行交换,然后在对余下的的非堆尾的所有元素进行建堆,具体建大堆还是建小堆取决于,自己是想升序排还是降序排

4.1.1向上调整进行堆排序

预备知识介绍:

堆只有大堆和小堆之分:大堆:根节点大于或者等于所有的节点;小堆:根节点小于或者是等于所有节点的

堆是一棵完全二叉树

数组里面的数据可以视为一个完全二叉树

父节点与孩子节点之间的关系(下标)    左孩子的下标:child = 2* paren_i  +1  右孩子的下标:child_rignt =  左孩子下标+1 = 2* paren_i  +2 注:parent_i 双亲节点的下标

4.1.1.1堆排序之前建大堆还是建小堆
在进行堆排序之前(默认排升序),需要先建一个大堆:建大堆可以保证最大元素与堆尾元素交换后,当前最大元素一定是在堆尾的(只是相对而言),或者说建大堆后,堆顶与队尾元素交换后,可以视为把堆顶元素尾插到堆尾,这样就能保证数组是以升序排列。同理,若是降序排的话,需要建小堆
4.1.1.2 向上建堆分析

建大堆:

从最后一个节点开始向上建堆,要是当前位置 child大于双亲parent 所对应的值,就进行交换,接下来就是进行更新 child= parent: child 来到双亲所对应位置, parenrt  = (child -1) / 2

在执行这个逻辑: child大于双亲parent 所对应的值,就进行交换

 分析见下:

 堆顶元素与堆尾元素交换后,对除堆尾的所有元素进行上调重新建大堆,选出当前最大的元素以此头插到堆尾元素的前面

4.1.2向下调整进行堆排序

get 到了上调算法,那么咱也就轻松拿捏下调算法了,二者大同小异

还是老问题,先对当前数据进行下调建大堆,再利用堆顶与堆尾元素交换,依次进行下调

若是从4这个节点开始进行下调的话,他的左右子树都不符合堆的要求。很显然不能从4这个节点调整。只能倒着往前进行下调:从第一个非叶节点开始进行下调

分析见下:

 

4.2代码的实现

上调代码:

void Adjust_up(int*a,int child) //问题1;第二个参数传孩子节点位置而不是双亲节点下标
{int parent = (child - 1) / 2;while (child >= 0)  //问题2 : 结束条件必须是 chind >= 0而不能parent>= 0 最终parent的值永远是0 ,会出现死循环{if (a[child] > a[parent]){Swap(&a[child], &a[parent]);//依次上调进行更新child = parent;parent = (child - 1) / 2;}elsebreak;}
}
void Heap_sort(int* a, int num)
{int pos = num - 1;for (pos; pos > 0; pos--){Adjust_up(a, pos);}//排序:上调pos = num - 1;while (pos > 0) //不能取等{Swap(&a[0], &a[pos]);//堆顶元素依次放到堆尾//问题4   //对于下的n-1 (n-2)(n-3)重新建大堆 不是建一次就OK的for (int i = pos - 1; i > 0; i--){Adjust_up(a, i);}pos--;}}

下调代码

void Adjudt_down(int* a, int parent, int num)
{int child = 2 * parent + 1;//假设左孩最小while (child < num){if (child + 1 < num && a[child] < a[child + 1])  //可能右孩子最大,前提是右孩子必须存在{child += 1;}if (a[child] > a[parent]){Swap(&a[child], &a[parent]);parent = child;child = 2 * parent + 1;}elsebreak;}
}
void Heap_sort(int* a, int num)
{//升序:建大堆 => 排序:堆顶元素依次与堆尾元素交换  最终结果: 第一小,第二小,…… 倒数次次大,倒数第二大,最大//下调来进行的
//下调来进行的int pos = num;pos = (num - 1 - 1) / 2;//建大堆while (pos >= 0){Adjudt_down(a, pos, num);//pos-1 最后一个节点下标   (pos - 1 - 1) / 2 最后一个节点的双亲位置pos--;}//排序//if (num < 10)//{//	Insert_sort(a, num);//	return;//}pos = num -1;//最后一个数位置while (pos >=0) //一定要取等{Swap(&a[0], &a[pos]);/*	for (int i = pos - 1; i >= 0; i--){Adjudt_down(a, (i-1)/2,pos);}*/Adjudt_down(a,0,pos );pos--;}}
4.3堆排序对应的时间复杂度以及空间复杂度的分析

空间复杂度:O(1),并没有额外空间的消耗

利用向上调整来进行排序的时间复杂度: O(N * log N)

利用向下调整来进行排序的时间复杂 O(N)

5冒泡排序
5.1冒泡排序的思想

相邻两哥元素进行比较,若是满足条件,进行两两相邻元素进行交换

动图示范:

 单趟排序

5.2代码的实现
void Bubble_sort(int* a, int num)
{int flag = 0;//默认数组有序for (int i = 0; i < num; i++){for (int j = 0; j < num-1-i; j++){if (a[j] > a[j + 1])//升序排{Swap(&a[j], &a[j + 1]);flag = 1;}}if (flag == 0)break;//数组本身就有序}
}
5.3冒泡排序对应的时间复杂度以及空间复杂度的分析

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

空间复杂度:O(1)

6快排
6.1快排的思想

通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列

6.1.1Hoare法的快排实现

先选出一个元素作为基准,遍历原数组,把小于基准数的放到左边,大于基准数的放到右边

具体实现见下:默认一个数作为基准(只是相对而言,因为需要层层递归),定义2个变量 left ,right,其中left找大于基准数,right找小于基准数的,找到后 让left 与right 对应位置的数交换,再继续找知道left right相遇,此时与 基准数进行交换,并记录当前left的位置,作为下一次的查找范围

注意一些细节:在left找大,right找小,谁先走取决于基准数是在左边还是在右边

基准数(key_i)在左边,right先走进行找小,要是基准数(key_i)在右边,left先走进行找大

当key_i与left,right重合的时候也可以不进行交换

递归结束条件: begin >= end : begin = end 只有一个数,本身就是有序的不用进行排序, begin >end:说明区间不存在

6.1.2挖坑法的快排实现

挖坑法和Horea法思想一样,只不过是另一种写法,不用注意left ,right先后走的顺序问题

假设第一个数为基准,同时也为坑所在位置(只是相对而言),依然是left找比 key大的,right找比key小的,因为left所在位置为坑,right先找找到与坑所在位置交换,让hole来到right所在位置,此时left找大,找到与hole所在位置交换,hole来到left坐在位置,最终left,right相遇(同时也是hole所在位置)让key 赋给hole所在位置单趟排序完成,接下来重复进行即可。

分析见下:

6.1.3前后指针法的快排实现

6.2代码的实现
6.2.1Hoare法
int  Part_sort1(int*a,int begin,int end) //Hoare 法
{int key_i = begin;//默认第一个数所在位置为基准int left = begin;int right = end;while (left < right){while (left < right){if (a[right] < a[key_i]) //找小break;right--;}while (left < right){if (a[left] > a[key_i]) //找大break;left++;}Swap(&a[left], &a[right]);}//left right一定相遇if(left != key_i)Swap(&a[key_i], &a[left]);return left;
}void Quick_sort(int* a,int begin, int end)//下标
{if (begin >= end)return;int meet_i = Part_sort3(a,begin,end);//此时数组分为3个区间 [begin,meet_i-1] meet_i [meet_i+1,end]Quick_sort(a, begin, meet_i-1 );Quick_sort(a,  meet_i + 1,end);
}
6.2.2 挖坑法
int Part_sort2(int* a, int begin, int end)
{int left = begin;int right = end;int key = a[begin];int hole = begin;while (left < right){while (left < right){if (a[right] < key){a[hole] = a[right];hole = right;break;}right--;}while (left < right){if (a[left] > key){a[hole] = a[left];hole = left;break;}left++;}}a[hole] = key;return left;
}
void Quick_sort(int* a,int begin, int end)//下标
{if (begin >= end)return;int meet_i = Part_sort3(a,begin,end);//此时数组分为3个区间 [begin,meet_i-1] meet_i [meet_i+1,end]Quick_sort(a, begin, meet_i-1 );Quick_sort(a,  meet_i + 1,end);
}
6.2.3前后指针
int Part_sort3(int* a, int left, int right)//前后指针
{int pre = left;int cur = left;int key = a[left];while (cur <= right){if (a[cur] >= key)cur++;else //cur < key{pre++;Swap(&a[pre], &a[cur]);cur++;}}Swap(&a[pre], &a[left]);//&key不可以return pre;
}void Quick_sort(int* a,int begin, int end)//下标
{if (begin >= end)return;int meet_i = Part_sort3(a,begin,end);//此时数组分为3个区间 [begin,meet_i-1] meet_i [meet_i+1,end]Quick_sort(a, begin, meet_i-1 );Quick_sort(a,  meet_i + 1,end);
}
6.3快排对应的时间复杂度以及空间复杂度的分析

空间复杂度:O(1)

时间复杂度:O()

分析时间复杂度:

这三个方法实现的快排思想都是一样的,通过前期画图的理解,其实不难发现,快排的过程和二叉树往下递归的过程一样的

最坏的情况:O(N^2)当数组是降序的时候,这时候需要排成升序或者是数组本身就是升序需要排成降序的就是最坏的情况了,假设第一个数为基准,总的比较次数就是一个等差数列

最优的时间复杂度:O(N*logN)每一轮的排序都把区间差不多对半分(也就是基准数都来到中间位置)

 6.4快排的优化

很显然快排对随机数据的排序是很友好滴,当我们数据与要排序的方向相反的时候,那就很糟糕了,针对这个情况我们可以做些改进

三数取中:对left right mid(中间位置下标)取出一个不大不小的数

优化之后的代码:

int Get_mid(int* a, int left, int right)
{//三数取中 找不大不小的数所在位置int mid_i = (right + left) / 2;if (a[mid_i] > a[left]){if (a[left] > a[right])return left;else if (a[right] > a[mid_i]) //同时说明 left <= rightreturn mid_i;return right;}else// mid_i <= left{if (a[right] < a[mid_i])return mid_i;else if (a[right] > a[left]) //right>= mid_ireturn left;elsereturn right;}return mid_i;
}int  Part_sort1(int*a,int begin,int end) //Hoare 法
{//三路划分优化:针对数组本身就有序int key_i = Get_mid(a, begin, end);Swap(&a[begin], &a[key_i]);//让中位数与下标0的数交换key_i = begin;//默认第一个数所在位置为基准int left = begin;int right = end;while (left < right){while (left < right){if (a[right] < a[key_i]) //找小break;right--;}while (left < right){if (a[left] > a[key_i]) //找大break;left++;}Swap(&a[left], &a[right]);}//left right一定相遇if (left != key_i)Swap(&a[key_i], &a[left]);return left;}
7归并排序
7.1归并排序思想

为了方便理解这个思想先以一个题列来引入:合并2个有序数组,arr1,arr2:思想依次取小的尾插即可最终便可以实现整个数组有序。

对于归并而言也是一样的:先把数组进行分解,最后在层层回溯进行归并

把数组对半分直至分成只有一个元素的时候,再进行归并

分析见下:

注意在进行归并的时候一定不能再原数组进行:造成数据的覆盖,所以查立就需要开辟一个数组大小同原数组大小一样

7.2代码实现
void _Merge_sort(int* a,int* tmp ,int begin,int end)
{if (begin >= end)return;int mid_i = (end + begin) / 2;//中位数下标//此时分成2个区间[begin,mid+i] [mid_i+1,end];//左区间递归_Merge_sort(a,tmp, begin, mid_i);//右区间递归_Merge_sort(a,tmp, mid_i + 1, end);//归并int left1 = begin;int right1 = mid_i;int left2 = mid_i + 1;int right2 = end;int i = begin;//注意这里不能设置为0 ,每次递归调用的时候要不都会在0 重新赋值while (left1 <= right1 && left2 <= right2){if (a[left1] < a[left2]){tmp[i++] = a[left1++];}else{tmp[i++] = a[left2++];}}while (left1 <= right1){tmp[i++] = a[left1++];}while (left2 <= right2){tmp[i++] = a[left2++];}memcpy(a+begin, tmp+begin, sizeof(int) * (end - begin + 1)); //注意这里不能是 a,tmp道理同上
}void Merge_sort(int* a, int num)
{int begin = 0,  end = num -1;int* tmp = (int*)malloc(sizeof(int) * (end - begin + 1));if (tmp == NULL)return;memset(tmp, 0, sizeof(int) * (end - begin + 1));if (begin >= end)return;_Merge_sort(a, tmp, begin, end);
}
7.3时间复杂度以及空间复杂度分析

空间复杂度:O(N)需要为每次拷贝开辟额外空间

时间复杂度:O(N*logN)归并排序在进行递归调用的时候其实是一个二叉树往下递归的过程,外循环所指向次数就是二叉树的高度 logN,内循环是所执行次数N

7.4优化

当递归层次太深的时候,会造成栈顶溢出,因此就需要减少递归调用的次数

小区间优化

当递归到元素个数 少于10个的时候,这时候可以采用一些其他排序进行(效率高的),比如直接插入排序

为什么是少于10个呢?因为当递归到只有10个元素的时候这是就已经减少了80%以上的递归调用次数

7.5非递归的实现

先一 一进行归并 ,再二 二进行归并,依次类推直至数组有序

这个看起来是容易理解但是写起来很容易有问题:频繁的越界 ,以及拷贝数据下标的选择

分析见下:

代码: 

void Merge_sortNonR(int* a, int num)
{int* tmp = (int*)malloc(sizeof(int) * num);if (tmp == NULL)return;memset(tmp,0, sizeof(int) * num);//全部初始化0int gap = 1;//int i = 0;//记录tmp中下标位置while (gap < num) //需要取等{int i = 0;//记录tmp中下标位置for ( int j = 0; j < num ; j = j+2*gap) //单趟{int begin1 = j;int end1 = gap - 1 + begin1;int begin2 = gap + begin1;int end2 = gap - 1 + begin2;if (end1 >= num){end1 = num - 1;begin2 = num;end2 = num;}if (begin2 >= num){begin2 = num;end2 = num;}if (  end2 >= num){end2 = num - 1;}while (begin1 <= end1 && begin2 <= end2){if (a[begin1] < a[begin2])tmp[i++] = a[begin1++];elsetmp[i++] = a[begin2++];}while (begin1 <= end1 ){tmp[i++] = a[begin1++];}while (begin2 <= end2){tmp[i++] = a[begin2++];}} memcpy(a, tmp, sizeof(int) * num);//memcpy(a, tmp, sizeof(int) *i);gap *= 2;}
}
8计数排序 
8.1计数排序的思想

对于前面的七大排序都是基于数据比较之后实现的,而计数排序的实现是通过记录当前数据出现的次数来实现的

具体实现:

当数组的数据比较大的时候难道也要放到指定的下标位置:比如说最大的数89需要放到下标为89的位置吗,这样岂不是很浪费空间

采用相对映射的思想:让当前数据减去最小的数:min = 80,即为要存放的位置,这样就减少了空间浪费的现象,注意只是相对减少,但多多少少还是存在浪费的情况

当还原到原数组的时候让当前下标再加上min即为原始数据

 简单分析一下:就可以看出,当数组个数较少并且数据之间比较集中的时候是非常实用这个排序的

8.2代码实现

8.3时间复杂度以及空间复杂度的分析

空间复杂度:O(range)range是tmp数组大小 (max-min+1)

时间复杂度:O(N + range):range是tmp数组大小

结语 

以上就是要share 的内容,对于排序这部分知识也是不容忽视的。怎么说呢,你说他简单吧,但确实是不容易,说他难吧也不是多么难,就是自己把思想get 到,结合画图以及调试等相关的技巧慢慢的磨合吧,没有什么是一学就会的,尤其是在学习方面,希望大家看完此篇博客对相关排序的理解可以更上一层楼,各位大佬们支持一下呗,蟹蟹!

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

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

相关文章

npm 操作报错记录1- uninstall 卸载失效

npm 操作报错记录1- uninstall 卸载失效 1、问题描述 安装了包 vue/cli-plugin-eslint4.5.0 vue/eslint-config-prettier9.0.0 但是没有使用 -d &#xff0c;所以想重新安装&#xff0c;就使用 uninstall 命令卸载&#xff0c;结果卸载了没反应&#xff0c;也没有报错&#xf…

【Python】成功解决AttributeError: ‘MyClass‘ object has no attribute ‘my_attribute‘

【Python】成功解决AttributeError: ‘MyClass’ object has no attribute ‘my_attribute’ &#x1f308; 个人主页&#xff1a;高斯小哥 &#x1f525; 高质量专栏&#xff1a;Matplotlib之旅&#xff1a;零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门…

CRM术语速览:掌握这十个专业名词,成为CRM专家

无论您是销售人员还是采购经理&#xff0c;熟悉CRM管理系统专业术语都是一门必修课。擅于运用CRM专业术语帮助您理解CRM管理系统的功能、更好的开展业务。本文与您分享不得不知道的十大CRM专业术语&#xff0c;CRM常用术语合集。常见的CRM术语包括MQL、SQL、SDR、销售漏斗等等。…

【Docker】了解Docker Desktop桌面应用程序,TA是如何管理和运行Docker容器(3)

欢迎来到《小5讲堂》&#xff0c;大家好&#xff0c;我是全栈小5。 这是《Docker容器》系列文章&#xff0c;每篇文章将以博主理解的角度展开讲解&#xff0c; 特别是针对知识点的概念进行叙说&#xff0c;大部分文章将会对这些概念进行实际例子验证&#xff0c;以此达到加深对…

AI新工具 百分50%算力确达到了GPT-4水平;将音乐轨道中的人声、鼓声、贝斯等音源分离出来等

1: Pi 百分50%算力确达到了GPT-4水平 Pi 刚刚得到了巨大的升级&#xff01;它现在由最新的 LLMInflection-2.5 提供支持&#xff0c;它在所有基准测试中都与 GPT-4 并驾齐驱&#xff0c;并且使用不到一半的计算来训练。 地址&#xff1a;https://pi.ai/ 2: Moseca 能将音乐…

JAVA虚拟机、Dalvik虚拟机和ART虚拟机简要对比

1、什么是JVM&#xff1f; JVM本质上就是一个软件&#xff0c;是计算机硬件的一层软件抽象&#xff0c;在这之上才能够运行Java程序&#xff0c;JAVA在编译后会生成类似于汇编语言的JVM字节码&#xff0c;与C语言编译后产生的汇编语言不同的是&#xff0c;C编译成的汇编语言会…

【Web安全】htaccess攻击

.htaccess攻击 文章目录 .htaccess攻击1. .htaccess文件2. 常见用法2.1. 自定义出错界面2.2. 强制文件执行方式2.3. PCRE绕过正则匹配2.4. php_value修改php设定2.5. php_value文件包含2.6. 把htaccess当作php 1. .htaccess文件 .htaccess是Apache网络服务器一个配置文件&#…

【面试精讲】Java动态代理是如何实现的?JDK Proxy 和 CGLib 有什么区别?

Java动态代理是如何实现的&#xff1f;JDK Proxy 和 CGLib 有什么区别&#xff1f; 目录 一、Java动态代理的实现 1、使用JDK Proxy实现动态代理 2、使用CGLib实现动态代理 二、JDK Proxy 与 CGLib 的区别 三、Spring中的动态代理 四、 Lombok代理原理 总结 前言 本文…

21 easy 1. 两数之和

//给定一个整数数组 nums 和一个整数目标值 target&#xff0c;请你在该数组中找出 和为目标值 target 的那 两个 整数&#xff0c;并返回它们的数组下标。 // // 你可以假设每种输入只会对应一个答案。但是&#xff0c;数组中同一个元素在答案里不能重复出现。 // // 你可以…

Day18:信息打点-小程序应用解包反编译动态调试抓包静态分析源码架构

目录 小程序获取-各大平台&关键字搜索 小程序体验-凡科建站&模版测试上线 小程序抓包-Proxifier&BurpSuite联动 小程序逆向-解包反编译&动态调试&架构 思维导图 章节知识点 Web&#xff1a;语言/CMS/中间件/数据库/系统/WAF等 系统&#xff1a;操作系…

设计模式-行为型模式-职责链模式

在软件系统运行时&#xff0c;对象并不是孤立存在的&#xff0c;它们可以通过相互通信协作完成某些功能&#xff0c;一个对象在运行时也将影响到其他对象的运行。行为型模式&#xff08;Behavioral Pattern&#xff09;关注系统中对象之间的交互&#xff0c;研究系统在运行时对…

C++:多态

目录 1、多态的概念 2、多态如何实现 虚函数 虚函数的重写 虚函数重写的两个例外&#xff1a; c11中 override与final 3、重载 、重写、重定义的区别。 1、重载 2、重写 3、重定义 接口继承和实现继承 4、动态绑定与静态绑定 5、虚函数表 1、单继承中虚函数表 …

Uber/Google Golang编码标准深度分析

良好的代码风格对于开发优秀的产品至关重要&#xff0c;本文通过分析比较三部流传甚广的Golang代码风格指南&#xff0c;介绍了Go代码风格要点&#xff0c;并介绍了通过工具实现代码检查的方式。原文: Mastering Go: In-Depth Analysis of Uber and Google’s Coding Standards…

C++矢量运算与java矢量运算

矢量运算 概述&#xff1a; 矢量运算是一种基于向量的数学运算&#xff0c;它遵循特定的法则。以下是矢量运算的一些基本原理&#xff1a; 矢量加法&#xff1a;可以使用平行四边形法则或三角形法则来执行。当两个矢量相加时&#xff0c;可以将它们的起点放在同一个点上&…

RabbitMQ篇

1.初始MQ 1.1. 同步和异步通讯 微服务间通讯有同步和异步两种方式&#xff1a; 同步通讯&#xff1a;就像打电话&#xff0c;需要实时响应。 异步通讯&#xff1a;就像发邮件&#xff0c;不需要马上回复。 两种方式各有优劣&#xff0c;打电话可以立即得到响应&#xff0c;…

初阶数据结构:排序(学习笔记)

目录 1. 各种排序算法的分类2. 插入排序2.1 直接插入排序2.2 希尔排序 3. 选择排序3.1 选择排序3.2 堆排序4. 交换排序4.1 冒泡排序4.2 快速排序4.2.1 霍尔法&#xff08;hoare&#xff09;4.2.2 挖坑法&#xff08;hole&#xff09;4.4.3 前后指针法4.4.4 补充&#xff1a;非递…

存货计价方式 比较-移动平均和批次计价

SAP常用的存货计价方式有 标准价格移动平均价格批次计价 标准价格常用于制造企业&#xff0c;今天的方案比较主要集中在销售型企业常用的移动平均价和批次计价 批次计价&#xff1a; 移动平均&#xff1a; 两种计价方式的Pros&Cons 比较 批次计价 移动平均优点 1…

超好用的一键生成原创文案方法

在现代社会中&#xff0c;原创文案不管是在营销中&#xff0c;还是在品牌推广中都起着至关重要的作用。然而&#xff0c;对于许多人来说&#xff0c;创作出令人印象深刻且引人注目的原创文案并不容易。但随着技术的发展&#xff0c;我们现在可以利用一键生成原创文案的方法来帮…

黑马java-JavaSE进阶-java高级技术

1.单元测试 就是针对最小的功能单元方法&#xff0c;编写测试代码对其进行正确性测试 2.Junit单元测试框架 可以用来对方法进行测试&#xff0c;它是第三方公司开源出来的 优点&#xff1a; 可以灵活的编写测试代码&#xff0c;可以针对某个方法执行测试&#xff0c;也支持一键…

基于springboot的水果购物商城管理系统(程序+文档+数据库)

** &#x1f345;点赞收藏关注 → 私信领取本源代码、数据库&#x1f345; 本人在Java毕业设计领域有多年的经验&#xff0c;陆续会更新更多优质的Java实战项目&#xff0c;希望你能有所收获&#xff0c;少走一些弯路。&#x1f345;关注我不迷路&#x1f345;** 一、研究背景…