public static int privot(int[] array,int left,int right){
int key=array[left];
int i=left;
while (right>left){
while (array[right]>=key&&left<right){
right--;
}
while (array[left]<=key&&left<right){
left++;
}
swap(right,left,array);
}
swap(i,left,array);
return left;
}
public static int privot1(int[] array,int left,int right){
int privot=array[left];
while (left<right){
while (array[right]>=privot&&left<right){
right--;
}
array[left]=array[right];
while (array[left]<=privot&&left<right){
left++;
}
array[right]=array[left];
}
array[left]=privot;
return left;
}
5.双指针（了解）：
代码实现：
java复制代码
public static int privot2(int[] array,int left,int right){
int prev=left;
int k=array[prev];
int cur=left+1;
while (cur<=right){
if(array[cur]<k&&(++prev)!=cur){
swap(cur,prev,array);
}
cur++;
}
swap(prev,left,array);
return prev;
}
这里的双指针法了解就好，小编不再赘述，可以画图理解一下。
6.快速排序总结：
快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
时间复杂度：O(N*logN)
空间复杂度：O(logN)
稳定性：不稳定
2.2归并排序
1.递归基本思想：
运用递归实现，我们需要进行查找中间索引，进行两两拆分直到只有一个数据，再实现两两合并。
图解：
代码实现：
java复制代码
public static void Merge(int[] array,int left,int right){
if(left>=right){
return;
}
int mid=(left+right)/2;
Merge(array,left,mid);
Merge(array,mid+1,right);
mergeCore(array,left,right,mid);
}
2.非递归基本思想：
即分组进行合并排序，先是一个和一个，再次为二和二到最后全部合并（这里的合并是排好序的）
图解：
代码实现：
java复制代码
public static void Mergenor(int[] array){
int left;
int right;
int gap=1;
int mid;
while (gap<array.length){
for (int i = 0; i < array.length; i+=2*gap) {
left=i;
mid=left+gap-1;
right=mid+gap;
if(mid >= array.length) {
mid = array.length-1;
}
if(right >= array.length) {
right = array.length-1;
}
mergeCore(array,left,right,mid);
}
gap*=2;
}
}
public static void mergeCore(int[] array,int left,int right,int mid){
int[] tmp=new int[right-left+1];
int k=0;
int s1=left;
int s2=mid+1;
while (s1<=mid&&s2<=right){
if(array[s1]<=array[s2]){
tmp[k]=array[s1];
k++;
s1++;
}else {
tmp[k]=array[s2];
k++;
s2++;
}
}
while (s1>mid&&s2<=right){
tmp[k]=array[s2];
s2++;
k++;
}
while (s2>right&&s1<=mid){
tmp[k]=array[s1];
k++;
s1++;
}
for (int i = 0; i <k ; i++) {
array[i+left]=tmp[i];
}
}
4.归并排序总结：
归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
时间复杂度：O(N*logN)
空间复杂度：O(N)
稳定性：稳定
📚️3.非比较排序
3.1计数排序
思路步骤：
1. 统计相同元素出现次数
2. 根据统计的结果将序列回收到原来的序列中
图解：
代码实现：
java复制代码
public static void CountSort(int[] array){
int max=array[0];
int min=array[0];
for (int i = 1; i < array.length; i++) {
if (array[i]<min){
min=array[i];
}
if(array[i]>max){
max=array[i];
}
}
int[] tmp=new int[max-min+1];
for (int i = 0; i < array.length ; i++) {
tmp[array[i]-min]++;
}
for (int i = 0; i < tmp.length ; i++) {
while (tmp[i]!=0){
System.out.print(i+min+" ");
tmp[i]--;
}
}
}
public static void BaseSort(int[] array){
int max=max(array);
int maxLength=0;
while (max!=0){
max/=10;
maxLength++;
}
int[][] bucket = new int[10][array.length-1];
int[] elementCount = new int[10];
int n=1;
for (int i = 0; i < maxLength; i++) {
for (int j = 0; j < array.length ; j++) {
int element=array[j]/n%10;
bucket[element][elementCount[element]]=array[j];
elementCount[element]++;
}
//拿出数据
int index=0;
for (int j = 0; j <elementCount.length ; j++) {
if(elementCount[j]!=0){
for (int k = 0; k < elementCount[j]; k++) {
array[index]=bucket[j][k];
index++;
}
}
elementCount[j]=0;
}
n*=10;
}
}
public static int max(int[] array){
int max=array[0];
for (int i = 1; i < array.length ; i++) {
if(array[i]>max){
max=array[i];
}
}
return max;
}
}
