低级排序算法之快速排序

25881,对等连续:9976,足足:54毫秒

从运行结果之前，可以注意到对于随机核酸，较快顺序迭代可执行速度是比较快的，和重设顺序不尽相同，但给运算元核酸顺序时，效果则比较差，几乎和选取顺序一样的效率了。那这是为什么呢？

根本原因，就在于枢纽站的选取上，较快顺序为了让枢纽站并不需要将变量拆分成两个间距几乎不尽相同的长子变量，这样能也就是说的均衡相对连续和对等连续。对于随机核酸，简单的选取最上方数据项当做枢纽站不至于频繁显现约莫长子变量极度不均衡的情况，而对于运算元核酸，则几乎每次划定都是极度不均衡的两个长子变量，终于导致较大侧的长子变量要被划定来得多次。

也就是说化枢纽站选取迭代

较快顺序的也就是说划定结果是划定的两个变量间距相等，为了降至这个意在，我们每次都要在划定前，先找到长子变量的尾端数据项吗？显然，不能这么做的，因为很可能你找之前个数的小时差不多多于你顺序的小时了。所以，我们仅仅选取一个构建既不是极为适合于，又比“选取最上方数据项当做枢纽站”的迭代来得具普适性。

上图示意图取枢纽站的新方法叫“三数据项取之前”，即从变量之前选取第一个、就此一个以及尾端的数据项，从这三个数据项之前取出大小在尾端的项当做枢纽站，在选取流程之前，我们实际上也对这三个数据项做了顺序，那顺便把分别多于、多于枢纽站的那两个数据项也放到正确的右边（即前方多于枢纽站，上方多于枢纽站）。

该新方法每次划定都需要至少有三个数据项，所以当长子变量项数不多于3个的时候，就可以结束形式化划定了，此时的顺序可以通过其他顺序迭代构建，如应用于手动顺序（待顺序的数据项不多于3个，所以手动顺序几乎可以轻松搞定），也可以应用于比如说（如果应用于比如说，我们甚至可以当数据项不多于10（这个10没有具体意义，你也可以20、30）的时候就可以用比如说来紧接了）。下面我们用该新方法来选取枢纽站（用比如说来紧接），对预定义进行修改。

预定义展示出 private static int medianOf3(int left,int right,int[] array){ int center = (left+right)/2; if(array[left]>array[center]){ swap(left,center,array); } if(array[left]>array[right]){ swap(left,right,array); } if(array[center]>array[right]){ swap(center,right,array); } swap(center,right-1,array); return array[right-1]; } private static void insertSort(int left,int right,int[] array){ for (int i = left+1; i <= right; i++) { int temp = array[i]; int cur = i; // 右移数字，构建cur下标的前方都是有序的 while (cur> 0 && compare(temp, array[cur - 1]) < 0) { copy(cur-1,cur,array); cur---; } // 如果cur==i则说明数据项从未在正确的右边了，不需要进行对等 if (cur != i) { // 不满足temp0){ } if(leftPtr>=rightPtr){ break; } // 对等需要来得改右边的两个数据项 swap(leftPtr,rightPtr,array); } // 将枢纽站挪到中间尾端 swap(leftPtr,right-1,array); return leftPtr; } private static void recQuickSort(int left,int right,int[] array){ int size = right-left+1; if(size <10){ insertSort(left,right,array); }else{ int median = medianOf3(left,right,array); int partition = partitionIt(left,right,median,array); recQuickSort(left,partition-1,array); recQuickSort(partition+1,right,array); } } public static void quickSort(int[] array){ compareCount=0; swapCount=0; long start = new Date().getTime(); recQuickSort(0,array.length-1,array); long end = new Date().getTime(); printResult("较快顺序","对等连续",start,end); }运行结果

冒泡顺序——相对连续:49995000,对等连续:25138570,足足:170毫秒

选取顺序——相对连续:49995000,对等连续:9990,足足:65毫秒

比如说——相对连续:25069178,粘贴连续:25069176,足足:34毫秒

重设顺序——相对连续:120483,粘贴连续:267232,足足:2毫秒

波特顺序——相对连续:231598,粘贴连续:235991,足足:6毫秒

对随机核酸顺序：较快顺序——相对连续:154857,对等连续:44570,足足:3毫秒

对运算元核酸顺序：较快顺序——相对连续:188034,对等连续:20067,足足:1毫秒

从可执行结果可以看出，也就是说化过枢纽站选取迭代后，无论是随机核酸顺序还是运算元核酸顺序，顺序速度都比较快。

至此，本文结束

完整预定义package team.ngup.study;import ja.util.Arrays;import ja.util.Date;import ja.util.concurrent.ThreadLocalRandom;/** * @author zww * @date 2022/8/4 10:35 */public class SortStudy { static final int ARRAY_SIZE = 10000; static int compareCount = 0; static int swapCount = 0; /** * 生成随机性变量 * * @return */ public static int[] buildRandomArray() { int[] array = new int[ARRAY_SIZE]; for (int i = 0; i < ARRAY_SIZE; i++) { int randomWithThreadLocalRandom = ThreadLocalRandom.current().nextInt(0, 1000000); array[i] = randomWithThreadLocalRandom; } return array; } /** * a和b右边的数据对等 * * @param a * @param b * @param array */ public static void swap(int a, int b, int[] array) { swapCount++; int temp = array[a]; array[a] = array[b]; array[b] = temp; } /** * 粘贴 右边 a->b * @param a * @param b * @param array */ private static void copy(int a,int b,int[] array){ swapCount++; array[b] = array[a]; } /** * 粘贴 数个数a->右边b * @param a * @param b * @param array */ private static void copyData(int a,int b,int[] array){ swapCount++; array[b]=a; } /** * dataa多于datab调回1，否则调回-1 * * @param dataa * @param datab * @return */ public static int compare(int dataa, int datab) { compareCount++; if (dataa>= datab) { return 1; } return -1; } /** * 输出顺序结果 * * @param name 顺序新方法名 * @param operName 对等/粘贴 * @param start 开始小时 * @param end 结束小时 */ private static void printResult(String name,String operName,long start,long end){ System.out.print( name + "——相对连续:" + compareCount + ","+operName+":" + swapCount + ",足足:" + (end - start) + "毫秒"); } /** 冒泡顺序 */ public static void maopao(int[] array) { compareCount = 0; swapCount = 0; // 待顺序核酸间距， int length = array.length; long start = new Date().getTime(); while (length> 0) { for (int a = 0; a < length - 1; a++) { if (compare(array[a], array[a + 1])> 0) { // 对等右边 swap(a, a + 1, array); } } // 一次从头到尾的结点，寻找了端的个数（也就是说），这将较长第二次结点的核酸间距 length---; } long end = new Date().getTime(); // 输出顺序结果 printResult("冒泡顺序","对等连续", start, end); } /** 选取顺序 */ public static void xuanze(int[] array) { compareCount = 0; swapCount = 0; int length = 0; long start = new Date().getTime(); while (length != array.length - 1) { // 绝对个数右边 int minPosition = -1; // 绝对个数 int min = array[length]; for (int i = length + 1; i < array.length; i++) { if (compare(array[i], min) < 0) { min = array[i]; minPosition = i; } } // 存在比当前个数还要小的个数，则进行右边对换，否则无需对调右边 if (minPosition != -1) { // 对等右边 swap(length, minPosition, array); } length++; } long end = new Date().getTime(); printResult("选取顺序","对等连续", start, end); } /** 比如说 */ public static void charu(int[] array) { swapCount = 0; compareCount = 0; // 第一次顺序无需相对，所以直接从1开始 long start = new Date().getTime(); for (int i = 1; i < array.length; i++) { int temp = array[i]; int cur = i; // 右移数字，构建cur下标的前方都是有序的 while (cur> 0 && compare(temp, array[cur - 1]) < 0) { copy(cur-1,cur,array); cur---; } // 如果cur==i则说明数据项从未在正确的右边了，不需要进行对等 if (cur != i) { // 不满足temp0){ for(outer=h;outerh-1 && compare(array[inner-h],temp)>0){ copy(inner-h,inner,array); inner -= h; } copyData(temp,inner,array); } h=(h-1)/3; } long end = new Date().getTime(); printResult("波特顺序","粘贴连续",start,end); } //-------------------较快顺序-------------------------------// private static int medianOf3(int left,int right,int[] array){ int center = (left+right)/2; if(compare(array[left],array[center])>0){ swap(left,center,array); } if(compare(array[left],array[right])>0){ swap(left,right,array); } if(compare(array[center],array[right])>0){ swap(center,right,array); } swap(center,right-1,array); return array[right-1]; } private static void insertSort(int left,int right,int[] array){ for (int i = left+1; i <= right; i++) { int temp = array[i]; int cur = i; // 右移数字，构建cur下标的前方都是有序的 while (cur> 0 && compare(temp, array[cur - 1]) < 0) { copy(cur-1,cur,array); cur---; } // 如果cur==i则说明数据项从未在正确的右边了，不需要进行对等 if (cur != i) { // 不满足temp0){ } if(leftPtr>=rightPtr){ break; } // 对等需要来得改右边的两个数据项 swap(leftPtr,rightPtr,array); } // 将枢纽站挪到中间尾端 swap(leftPtr,right-1,array); return leftPtr; } private static void recQuickSort(int left,int right,int[] array){ int size = right-left+1; if(size <10){ insertSort(left,right,array); }else{ int median = medianOf3(left,right,array); int partition = partitionIt(left,right,median,array); recQuickSort(left,partition-1,array); recQuickSort(partition+1,right,array); } } public static void quickSort(int[] array){ compareCount=0; swapCount=0; long start = new Date().getTime(); recQuickSort(0,array.length-1,array); long end = new Date().getTime(); printResult("较快顺序","对等连续",start,end); } public static void main(String[] args) { int[] array = buildRandomArray(); int[] array2 = Arrays.copyOf(array, ARRAY_SIZE); int[] array3 = Arrays.copyOf(array, ARRAY_SIZE); int[] array4 = Arrays.copyOf(array,ARRAY_SIZE); int[] array5 = Arrays.copyOf(array,ARRAY_SIZE); int[] array6 = Arrays.copyOf(array,ARRAY_SIZE); maopao(array); System.out.println(); xuanze(array2); System.out.println(); charu(array3); System.out.println(); mergeSort(array4); System.out.println(); xierSort(array5); System.out.println(); // 随机性据项 进行较快顺序 System.out.print("对随机核酸顺序："); quickSort(array6); System.out.println(); // 将array6运算元 int[] array6a = new int[array6.length]; for(int i=array6.length-1,j=0;i>=0;i---){ array6a[j] = array6[i]; j++; } // 对运算元的变量应用于较快顺序 System.out.print("对运算元核酸顺序："); quickSort(array6a); }}

注解格式极佳：高级顺序迭代之较快顺序|NGUP的来得进一步技术开发博客

。

刚做完手术吃什么
安必丁能长期服用吗
重庆妇科检查多少钱
复方鳖甲软肝片的功效与作用
胰腺癌
血糖仪哪个牌子准确
胃肠炎吃什么药有效果
流感咳嗽有痰吃什么药
流感可以吃金笛复方鱼腥草合剂吗
血糖仪什么型号的准确度高