标签：元素 直接插入排序 static sel public 分组 net quick 交换操作
一、直接插入排序
往有序的数组中快速插入一个新的元素。
基本思想：将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过为止。
1 // 插入排序 2 public static void insertSort(int[] arr) { 3 if(arr == null || arr.length <= 0) { 4 return; 5 } 6 7 for(int i = 1; i < arr.length; i++) { 8 int tmp = arr[i]; 9 10 for(int j = i; j >= 0; j--) { 11 if(j > 0 && arr[j-1] > tmp) { 12 arr[j] = arr[j-1]; 13 } else { 14 arr[j] = tmp; 15 break; 16 } 17 } 18 } 19 }
二、希尔排序
希尔排序又称递减增量排序算法。希尔排序是先把待排序的记录序列分割成若干子序列，分别进行直接插入排序，待整个序列中基本有序时，再对全体记录进行直接插入排序。
①. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；（一般初次取数组半长，之后每次再减半，直到增量为1）
②. 按增量序列个数k，对序列进行k 趟排序；
③. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
希尔排序实质上是一种分组插入方法。它的基本思想是：对于n个待排序的数列，取一个小于n的整数gap(gap被称为步长)将待排序元素分成若干个组子序列，所有距离为gap的倍数的记录放在同一个组中；然后，对各组内的元素进行直接插入排序。 这一趟排序完成之后，每一个组的元素都是有序的。然后减小gap的值，并重复执行上述的分组和排序。重复这样的操作，当gap=1时，整个数列就是有序的。
下面以数列{80,30,60,40,20,10,50,70}为例，演示它的希尔排序过程
第1趟：(gap=4)
当gap=4时,意味着将数列分为4个组： {80,20},{30,10},{60,50},{40,70}。 对应数列： {80,30,60,40,20,10,50,70}
对这4个组分别进行排序，排序结果： {20,80},{10,30},{50,60},{40,70}。 对应数列： {20,10,50,40,80,30,60,70}
第2趟：(gap=2)
当gap=2时,意味着将数列分为2个组：{20,50,80,60}, {10,40,30,70}。 对应数列： {20,10,50,40,80,30,60,70}
注意：{20,50,80,60}实际上有两个有序的数列{20,80}和{50,60}组成。
{10,40,30,70}实际上有两个有序的数列{10,30}和{40,70}组成。
对这2个组分别进行排序，排序结果：{20,50,60,80}, {10,30,40,70}。 对应数列： {20,10,50,30,60,40,80,70}
第3趟：(gap=1)
当gap=1时,意味着将数列分为1个组：{20,10,50,30,60,40,80,70}
注意：{20,10,50,30,60,40,80,70}实际上有两个有序的数列{20,50,60,80}和{10,30,40,70}组成。
对这1个组分别进行排序，排序结果：{10,20,30,40,50,60,70,80}
1 public static void shellSort(int[] arr){ 2 int gap = arr.length / 2; 3 4 for (; gap > 0; gap /= 2) { //不断缩小gap，直到1为止 5 6 for (int j = 0; (j+gap) < arr.length; j++){ //使用当前gap进行组内插入排序 7 8 for(int k = 0; (k+gap)< arr.length; k += gap){ 9 if(arr[k] > arr[k+gap]) { 10 11 int temp = arr[k+gap]; //交换操作 12 arr[k+gap] = arr[k]; 13 arr[k] = temp; 14 } 15 } 16 } 17 } 18 }
选择排序
选择排序的基本思想：比较+交换
①、从待排序的序列中，找到关键字最小的元素；
②、如果最小的元素不是待排序序列的第一个元素，将其和第一个元素交换；
③、从余下的N-1个元素中，找出关键字最小的元素，重复1和2，直到排序结束
1 // 选择排序 2 public static void selectionSort(int[] arr) { 3 if(arr == null || arr.length < 0) { 4 return; 5 } 6 7 for(int i = 0; i < arr.length; i++) { 8 int tmp = arr[i]; // 当前最小值 9 int flag = i; 10 11 for(int j = i + 1; j < arr.length; j++) { 12 if(arr[j] < tmp) { 13 tmp = arr[j]; 14 flag = j; 15 } 16 } 17 18 if(flag != i) { 19 arr[flag] = arr[i]; 20 arr[i] = tmp; 21 } 22 } 23 }
堆排序
堆排序的过程就是将待排序的序列构成一个堆，选出堆中的最大元素移走，再把剩余的元素调整成堆，找出最大的再移走，重复直到有序。
快速排序
基本思想：挖坑填数+分治法
①. 从数列中挑出一个元素，称为”基准”（pivot）。
②. 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
③. 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。
1 public static void quickSort(int[] arr, int low, int high) { 2 if(arr == null || arr.length <= 0) { 3 return; 4 } 5 6 int left = low; 7 int right = high; 8 int tmp = arr[left]; 9 10 while(left < right) { 11 while(left < right && arr[right] >= tmp) { 12 right--; 13 } 14 15 arr[left] = arr[right]; 16 17 while(left < right && arr[left] <= tmp) { 18 left++; 19 } 20 21 arr[right] = arr[left]; 22 } 23 24 arr[left] = tmp; 25 quickSort(arr, low, left-1); 26 quickSort(arr, left+1, high); 27 }
归并排序
基本思想：归并排序算法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
1 public class Solution { 2 public static void mergeSort(int[] nums) { 3 int[] tmp = new int[nums.length]; 4 5 mergeSort(nums, tmp, 0, nums.length-1); 6 } 7 8 private static void mergeSort(int[] nums, int[] tmp, int left, int right) { 9 if(left < right) { 10 int mid = (left + right) >> 1; 11 mergeSort(nums, tmp, left, mid); 12 mergeSort(nums, tmp, mid+1, right); 13 merge(nums, tmp, left, mid+1, right); 14 } 15 } 16 17 private static void merge(int[] nums, int[] tmp, int leftPos, int rightPos, int rightEnd) { 18 int leftEnd = rightPos-1; 19 int tmpPos = leftPos; 20 int numElements = rightEnd-leftPos+1; 21 22 while(leftPos <= leftEnd && rightPos <= rightEnd) { 23 if(nums[leftPos] <= nums[rightPos]) { 24 tmp[tmpPos++] = nums[leftPos++]; 25 } else { 26 tmp[tmpPos++] = nums[rightPos++]; 27 } 28 } 29 30 while(leftPos <= leftEnd) { 31 tmp[tmpPos++] = nums[leftPos++]; 32 } 33 34 while(rightPos <= rightEnd) { 35 tmp[tmpPos++] = nums[rightPos++]; 36 } 37 38 for(int i = 0; i < numElements; i++, rightEnd--) { 39 nums[rightEnd] = tmp[rightEnd]; 40 } 41 } 42 }
基数排序
它是这样实现的：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。
基数排序按照优先从高位或低位来排序有两种实现方案：
MSD（Most significant digital） 从最左侧高位开始进行排序。先按k1排序分组, 同一组中记录, 关键码k1相等, 再对各组按k2排序分成子组, 之后, 对后面的关键码继续这样的排序分组, 直到按最次位关键码kd对各子组排序后. 再将各组连接起来, 便得到一个有序序列。MSD方式适用于位数多的序列。
LSD （Least significant digital）从最右侧低位开始进行排序。先从kd开始排序，再对kd-1进行排序，依次重复，直到对k1排序后便得到一个有序序列。LSD方式适用于位数少的序列。
1 public static void radixSort(int[] arr){ 2 if(arr.length <= 1) return; 3 4 //取得数组中的最大数，并取得位数 5 int max = 0; 6 for(int i = 0; i < arr.length; i++){ 7 if(max < arr[i]){ 8 max = arr[i]; 9 } 10 } 11 12 // 最大数的位数 13 int maxDigit = 1; 14 while(max / 10 > 0){ 15 maxDigit++; 16 max = max / 10; 17 } 18 19 //申请一个桶空间 20 int[][] buckets = new int[10][arr.length]; 21 22 int base = 10; 23 24 //从低位到高位，对每一位遍历，将所有元素分配到桶中 25 for(int i = 0; i < maxDigit; i++){ 26 27 int[] bktLen = new int[10];//存储各个桶中存储元素的数量 28 29 //分配：将所有元素分配到桶中 30 for(int j = 0; j < arr.length; j++){ 31 int whichBucket = (arr[j] % base) / (base / 10); 32 buckets[whichBucket][bktLen[whichBucket]] = arr[j]; 33 bktLen[whichBucket]++; 34 } 35 36 //收集：将不同桶里数据挨个捞出来,为下一轮高位排序做准备,由于靠近桶底的元素排名靠前,因此从桶底先捞 37 int k = 0; 38 for(int b = 0; b < buckets.length; b++){ 39 40 for(int p = 0; p < bktLen[b]; p++){ 41 // important here 42 arr[k++] = buckets[b][p]; 43 } 44 } 45 46 base *= 10; 47 } 48 }
参考：
https://www.cnblogs.com/skywang12345/p/3597597.html
https://blog.csdn.net/hguisu/article/details/7776068
标签：元素 直接插入排序 static sel public 分组 net quick 交换操作
原文地址：https://www.cnblogs.com/wylwyl/p/10497509.html
