张家口网站建设,网站建设练手项目,大庆网站建设公司,网站的绝对路径怎么做排序在现实生活中的应用可谓相当广泛#xff0c;比如电商平台中#xff0c;选购商品时#xff0c;使用价格排序或是综合排序、高考填报志愿的时候#xff0c;会参考全国大学排名的情况。下面介绍一些计算机中与排序相关的概念#xff1a;排序#xff1a;所谓排序#xf…排序在现实生活中的应用可谓相当广泛比如电商平台中选购商品时使用价格排序或是综合排序、高考填报志愿的时候会参考全国大学排名的情况。下面介绍一些计算机中与排序相关的概念排序所谓排序就是使一串记录按照其中的某个或某些关键字的大小递增或递减的排列起来的操作。 稳定性假定在待排序的记录序列中存在多个具有相同的关键字的记录若经过排序这些记录的相对次序保持 不变即在原序列中r[i]r[j]且r[i]在r[j]之前而在排序后的序列中r[i]仍在r[j]之前则称这种排序算法是稳 定的否则称为不稳定的。 内部排序数据元素全部放在内存中的排序。 外部排序数据元素太多不能同时放在内存中根据排序过程的要求不能在内外存之间移动数据的排序。 插入排序1.1 直接插入排序1.1.1 插入排序的基本思想把待排序的记录按其关键码值的大小与已经排好序的序列逐个比较大小插入到合适的位置使整个序列重新有序。实际中我们玩扑克牌时就用了插入排序的思想。当插入第i(i1)个元素时前面的array[0],array[1],…,array[i-1]已经排好序此时用array[i]的排序码与array[i-1],array[i-2],…array[0]的排序码顺序进行比较找到插入位置即将array[i]插入原来位置上的元素顺序后移。1.1.2 直接插入法的代码实现 public class Test {public static void insertSort(int[] arr){for (int i 1; i arr.length; i) {int j i - 1;int temp arr[i];for (; j 0 ; j--) {if(arr[j] temp){arr[j1] arr[j];}else{break;}}arr[j 1] temp;}}public static void main(String[] args) {int[] arr {4,2,5,3,134,74,36,7,8,76,32,17,38,54,38,87,54};insertSort(arr);System.out.println(Arrays.toString(arr));}
}输出 [2, 3, 4, 5, 7, 8, 17, 32, 36, 38, 38, 54, 54, 74, 76, 87, 134]1.1.3 直接插入法的特性总结直接插入排序的特性总结 1. 元素集合越接近有序直接插入排序算法的时间效率越高 2. 时间复杂度O(N^2) 3. 空间复杂度O(1) 4. 稳定性稳定 它是一种稳定的排序算法 1.2 希尔排序1.2.1 希尔排序的基本思想希尔排序法又称缩小增量法。希尔排序法的基本思想是先想好间隔的设定方法比如gap一开始为数组的长度那么每个记录自成一组无需排序往后的间隔依次除以2(可以自己设定)把待排序文件中所有记录分成gap个组 并对每一组内的记录进行直接插入排序。然后重复上述分组和排序的工作。当gap 1时所有记录在统一组内最后插入排序。 1.2.2 希尔排序的代码实现 //希尔排序对直接插入法的优化public static void shellSort(int[] arr){int gap arr.length;while(gap 1){gap / 2;shell(arr,gap);}}private static void shell(int[] arr, int gap) {for (int i gap; i arr.length; i) {int j i - gap;int temp arr[i];for (; j 0 ; j-gap) {if(arr[j] temp){arr[j gap] arr[j];}else{break;}}arr[j gap] temp;}}public static void main(String[] args) {int[] arr {5,23,2,51,4,5,642,14,56,82,1,73,59,42,77};shellSort(arr);System.out.println(Arrays.toString(arr));}输出 [1, 2, 4, 5, 5, 14, 23, 42, 51, 56, 59, 73, 77, 82, 642]1.2.3 希尔排序的特性总结希尔排序的特性总结 1. 希尔排序是对直接插入排序的优化。 2. 当gap 1时都是预排序目的是让数组更接近于有序。当gap 1时数组已经接近有序的了这样就会很 快。这样整体而言可以达到优化的效果。我们实现后可以进行性能测试的对比。 3. 希尔排序的时间复杂度不好计算因为gap的取值方法很多导致很难去计算。Knuth进行了大量的试验统计 当n很大时关键码平均比较次数以及对象平均移动次数大约在范围内。所以对于希尔排序的时间复杂度我们暂时就按照来计算。 4. 稳定性不稳定 2. 选择排序2.1 直接选择排序2.1.1 直接先择排序的基本思想每一次从待排序的数据元素中选出最小或最大的一个元素存放在序列的起始位置。此时就有1个元素有序那么继续从剩下待排序元素中找到最小或最大的一个元素放到有序数组后面直到全部待排序的数据元 素排完 。写代码时如果是在原本数组进行操作那么只能让序列的最小值与相应位置进行交换了。 2.1.2 直接选择排序的代码实现 //选择排序//从一边查找最小元素public static void selectSort(int[] arr){//i下标是排序的位置//j则是遍历剩下数组元素找到最小下标for (int i 0; i arr.length; i) {int j i 1;int minIndex i;for (; j arr.length; j) {if(arr[j] arr[minIndex]){minIndex j;}}swap(arr,i,minIndex);}}public static void main(String[] args) {int[] arr {3,7,54,24,33,22,18,33,28,13,64,8,26};selectSort(arr);System.out.println(Arrays.toString(arr));}输出 [3, 7, 8, 13, 18, 22, 24, 26, 28, 33, 33, 54, 64]为了让选择排序更高效能不能在序列中查找最小值的同时查找最大值让最小值与最大值与各自相应位置进行交换 //从序列同时查找最大最小元素并与相应位置上的元素进行交换public static void selectSort(int[] arr){int left 0;int right arr.length - 1;while(left right){int minIndex left;int maxIndex left;for (int j left 1; j right; j) {if(arr[j] arr[minIndex]){minIndex j;}if(arr[j] arr[maxIndex]){maxIndex j;}}swap(arr,minIndex,left);if(left maxIndex){maxIndex minIndex;}swap(arr,maxIndex,right);left;right--;}}public static void main(String[] args) {int[] arr {4,3,22,56,77,23,53,7,13,75,224,6,27,69,49,88};selectSort(arr);System.out.println(Arrays.toString(arr));}输出 [3, 4, 6, 7, 13, 22, 23, 27, 49, 53, 56, 69, 75, 77, 88, 224]2.1.3 直接排序的特定1. 直接选择排序思考非常好理解但是效率不是很好。实际中很少使用 2. 时间复杂度O(N^2) 3. 空间复杂度O(1) 4. 稳定性不稳定 2.2 堆排序堆排序(Heapsort)是指利用堆积树堆这种数据结构所设计的一种排序算法它是选择排序的一种。它是通过堆 来进行选择数据。需要注意的是排升序要建大堆排降序建小堆。 2.2.1 堆排序的代码实现 //堆排序从小到大 - 建立大堆 从大到小 - 建立小堆public static void heapSort(int[] arr){if(arr null){return;}createHugeHeap(arr);int end arr.length - 1 ;while(end 0){swap(arr,0,end);shiftDown(arr,0,end);end--;}}//向下调整private static void shiftDown(int[] arr,int parent,int len){int child 2 * parent 1;while(child len){if(child 1 len arr[child] arr[child 1]){child;}if(arr[child] arr[parent]){swap(arr,child,parent);parent child;child 2 * parent 1;}else{break;}}}private static void createHugeHeap(int[] arr){for (int parent (arr.length - 1 - 1)/2; parent 0 ; parent--) {shiftDown(arr,parent,arr.length );}}public static void main(String[] args) {int[] arr {76,35,62,5,62,43,55,13,27,28,33,2,79,1};Sort.heapSort(arr);System.out.println(Arrays.toString(arr));}输出 [1, 2, 5, 13, 27, 28, 33, 35, 43, 55, 62, 62, 76, 79]2.2.2堆排序的特性【堆排序的特性总结】 1. 堆排序使用堆来选数效率就高了很多。 2. 时间复杂度O(N*logN) 3. 空间复杂度O(1) 4. 稳定性不稳定 3. 交换排序基本思想所谓交换就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置交换排序的特 点是将键值较大的记录向序列的尾部移动键值较小的记录向序列的前部移动。 3.1 快速排序3.1.1 快速排序的基本思想快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法其基本思想为任取待排序元素序列中的某元 素作为基准值按照该排序码将待排序集合分割成两子序列左子序列中所有元素均小于基准值右子序列中所有 元素均大于基准值然后最左右子序列重复该过程直到所有元素都排列在相应位置上为止。 3.1.2 快速排序的代码实习 public static void quickSort(int[] arr){quick(arr,0,arr.length - 1);}private static void quick(int[] arr, int start, int end) {if(start end){return;}//int pivot partition(arr,start,end);int pivot partition1(arr,start,end);quick(arr,start,pivot - 1);quick(arr,pivot 1,end);}填坑法 //填坑法private static int partition(int[] arr,int left,int right){int temp arr[left];while(left right){//这里的等号不能省略否则会陷入死循环//而有了等号left right 这个条件就不能省略while(left right arr[right] temp){right--;}swap(arr,right,left);while(left right arr[left] temp){left;}swap(arr,left,right);}arr[left] temp;return left;}Hoare法 //Hoare 法private static int partition1(int[] arr,int left,int right){int temp arr[left];int i left;while(left right){while(left right arr[right] temp){right--;}while(left right arr[left] temp){left;}swap(arr,left,right);}swap(arr,left,i);return left;}上述的快速排序有一个问题那就是如果数组已经是有序或是逆序的情况下再次快排每次都没有左树或是右数比较费空间和时间时间复杂度会达到O(N²)而且空间复杂度达到O(N)而只有每次划分都很平均的情况下时间复杂度会达到O(NlogN)而且空间复杂度达到O(logN)。所以这里可以采用三数取中法来对快速排序进行优化。三数取中法优化快排 //三数取中法优化快排private static int midThree(int[] arr,int head ,int tail ,int mid){if(arr[head] arr[tail]){if(arr[mid] arr[head]){return head;}else if(arr[tail] arr[mid]){return tail;}else{return mid;}}else{if(arr[mid] arr[tail]){return tail;}else if(arr[mid] arr[head]){return head;}else{return mid;}}}//上述quick 方法修改如下private static void quick(int[] arr, int start, int end) {if(start end){return;}int mid (start end)/2;int midIndex midThree(arr,start,end,mid);swap(arr,mid,start);//int pivot partition(arr,start,end);int pivot partition1(arr,start,end);quick(arr,start,pivot - 1);quick(arr,pivot 1,end);}public static void main(String[] args) {int[] arr {9,8,7,6,5,4,3,2,1,0};Sort.quickSort(arr);System.out.println(Arrays.toString(arr));}快排的非递归实现public static void quickSortNor(int[] arr){int left 0;int right arr.length - 1;int pivot partition(arr,left,right);DequeInteger stack new LinkedList();if(pivot - 1 left){stack.push(pivot - 1);stack.push(left);}if(right pivot 1){stack.push(right);stack.push(pivot 1);}while(!stack.isEmpty()){left stack.pop();right stack.pop();pivot partition(arr,left,right);if(pivot - 1 left){stack.push(pivot - 1);stack.push(left);}if(right pivot 1){stack.push(right);stack.push(pivot 1);}}
}3.1.3 快速排序的特点1. 快速排序整体的综合性能和使用场景都是比较好的所以才叫快速排序 2. 时间复杂度O(N*logN) 3. 空间复杂度O(logN) 4. 稳定性不稳定 3.2 冒泡排序3.2.1 冒泡排序的代码实现 //改进之后的冒泡排序public static void bubbleSort(int[] arr){for (int i 0; i arr.length - 1; i) {boolean flag false;for (int j 0; j arr.length - 1 - i; j) {if(arr[j] arr[j 1]){swap(arr,j,j1);flag true;}}if(flag false){return;}}}public static void main(String[] args) {int[] arr {2,35,7,245,65,24,26,12,15,2,52,74,55,29,39,6};Sort.bubbleSort(arr);System.out.println(Arrays.toString(arr));}输出 [2, 2, 6, 7, 12, 15, 24, 26, 29, 35, 39, 52, 55, 65, 74, 245]3.2.2 冒泡排序的特点【冒泡排序的特性总结】 1. 冒泡排序是一种非常容易理解的排序 2. 时间复杂度O(N^2) 3. 空间复杂度O(1) 4. 稳定性稳定 4. 归并排序4.1 归并排序的基本思想归并排序MERGE-SORT是建立在归并操作上的一种有效的排序算法,该算法是采用分治法Divide and Conquer的一个非常典型的应用。将已有序的子序列合并得到完全有序的序列即先使每个子序列有序再使 子序列段间有序。若将两个有序表合并成一个有序表称为二路归并。 归并排序核心步骤 4.2 归并排序的代码实现递归实现归并排序public static void mergeSort(int[] arr){divide(arr,0,arr.length - 1);
}private static void divide(int[] arr,int left,int right){if(left right){return;}int mid (left right)/2;divide(arr,left,mid);divide(arr,mid1,right);merge(arr,left,right,mid);
}private static void merge(int[] arr, int start, int end, int mid) {int s1 start;int s2 mid 1;int[] temp new int[end - start 1];int k 0;while(s1 mid s2 end){if(arr[s1] arr[s2]){temp[k] arr[s1];}else{temp[k] arr[s2];}}while(s1 mid){temp[k] arr[s1];}while(s2 end){temp[k] arr[s2];}for (int i 0; i temp.length; i) {arr[start i] temp[i];}}非递归实现归并排序 public static void mergeSort(int[] arr){int gap 1;while(gap arr.length){for (int i 0; i arr.length; i 2 * gap) {int left i;int mid left gap - 1;if(mid arr.length){mid arr.length - 1;}int right mid gap;if(right arr.length){right arr.length - 1;}merge(arr,left,right,mid);}gap * 2;}}4.3 归并排序的特点1. 归并的缺点在于需要O(N)的空间复杂度归并排序的思考更多的是解决在磁盘中的外排序问题。 2. 时间复杂度O(N*logN) 3. 空间复杂度O(N) 4. 稳定性稳定 5. 其他排序5.1 计数排序5.1.1 计数排序的基本思想思想计数排序又称为鸽巢原理是对哈希直接定址法的变形应用。 操作步骤 1. 统计相同元素出现次数 2. 根据统计的结果将序列回收到原来的序列中 5.1.2 计数排序的代码实现 public static void countSort(int[] arr){int max arr[0];int min arr[0];for (int i 1; i arr.length; i) {if(arr[i] max){max arr[i];}if(arr[i] min){min arr[i];}}int[] count new int[max - min 1];for (int i 0; i arr.length; i) {count[arr[i] - min];}int k 0;for (int i 0; i count.length; i) {while(count[i] 0){arr[k] i min;k;count[i]--;}}}5.1.3 计数排序的特点【计数排序的特性总结】 1. 计数排序在数据范围集中时效率很高是一种不需要比较大小的排序方式但是适用范围及场景有限。 2. 时间复杂度O(MAX(N,范围)) 3. 空间复杂度O(范围) 4. 稳定性稳定
