Merge Sort :归并排序；用递归的思想，分解成单个元素的排序，在归并
代码：
1 import java.util.*; 2 3 public class MergeSort 4 { 5 public static void main(String[] args) 6 { 7 System.out.println("Hello World!"); 8 int [] a = {3,44,38,5,47,15,36,26,27,2,46,4,19,50,48}; 9 mergeSort(a,0,14); 10 //System.out.println(Arrays.toString(a)); 11 } 12 13 //思路，先将数组分成两部分，这两部分在分别再分，分成单个的为一个partion, 14 //然后再归并这些partion 15 public static int[] mergeSort(int [] num , int low, int high) 16 { 17 int mid = (low + high)/2; 18 19 if(low < high)//分解，递归 20 { 21 mergeSort(num, low, mid); 22 mergeSort(num, mid + 1, high); 23 merge(num, low, mid, high);//归并 24 System.out.println(low+"::" + high + "::::"+Arrays.toString(num)); 25 } 26 27 return num; 28 } 29 //归并的函数 30 public static void merge(int [] num, int low, int mid, int high) 31 { 32 int [] store = new int [high - low + 1]; 33 int i = low; 34 int j = mid + 1; 35 int k = 0; 36 37 //比较两个partion,生成新的排序好的数组 38 while(i <= mid && j <= high) 39 { 40 if(num[i] > num[j]) 41 { 42 store[k] = num[j]; 43 k++; 44 j++; 45 } 46 else 47 { 48 store[k] = num[i]; 49 k++; 50 i++; 51 } 52 } 53 54 55 //插入剩余的元素 56 while(i <= mid) 57 { 58 store[k] = num[i]; 59 k++; 60 i++; 61 } 62 while(j <= high) 63 { 64 store[k] = num[j]; 65 k++; 66 j++; 67 } 68 69 //将排序后的代码拷贝到原来的数组，原来的位置 70 for(int m = 0; m < store.length; m++) 71 { 72 num[m + low] = store[m]; 73 } 74 } 75 }
运行结果：打印出了每次归并的结果
E:javajava_testsortprogram>java MergeSort Hello World! 0::1::::[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48] 2::3::::[3, 44, 5, 38, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48] 0::3::::[3, 5, 38, 44, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48] 4::5::::[3, 5, 38, 44, 15, 47, 36, 26, 27, 2, 46, 4, 19, 50, 48] 6::7::::[3, 5, 38, 44, 15, 47, 26, 36, 27, 2, 46, 4, 19, 50, 48] 4::7::::[3, 5, 38, 44, 15, 26, 36, 47, 27, 2, 46, 4, 19, 50, 48] 0::7::::[3, 5, 15, 26, 36, 38, 44, 47, 27, 2, 46, 4, 19, 50, 48] 8::9::::[3, 5, 15, 26, 36, 38, 44, 47, 2, 27, 46, 4, 19, 50, 48] 10::11::::[3, 5, 15, 26, 36, 38, 44, 47, 2, 27, 4, 46, 19, 50, 48] 8::11::::[3, 5, 15, 26, 36, 38, 44, 47, 2, 4, 27, 46, 19, 50, 48] 12::13::::[3, 5, 15, 26, 36, 38, 44, 47, 2, 4, 27, 46, 19, 50, 48] 12::14::::[3, 5, 15, 26, 36, 38, 44, 47, 2, 4, 27, 46, 19, 48, 50] 8::14::::[3, 5, 15, 26, 36, 38, 44, 47, 2, 4, 19, 27, 46, 48, 50] 0::14::::[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50] E:javajava_testsortprogram>
Random Quick Sort:随机快速排序/快速随机排序:就是快速排序，只是每次迭代时选择的比较标志随机选择了,
COUNTING SORT:计数排序----计算数组中的每个数出现的次数-----计数数组适用于当前数组密集的情况：
1.找出要排序数组中的最大值，和最小值，并根据最大值，和最小值创建计数数组
2.遍历要排序的数组（计数数组中保存的是这个值出现的次数，每个位置对应了一个数，--个人感觉用如i[0]这个位置存储的最小值出现的个数）
3.然后遍历计数数组，把数据从新写回原来的数组，排序完成
代码：
1 import java.util.*; 2 3 public class CountSort{ 4 public static void main(String[] args) 5 { 6 System.out.println("Hello world!"); 7 int[] a = new int[]{2, 3, 8, 7, 1, 2, 2, 2, 7, 3, 9, 8, 2, 1, 4, 2, 4, 6, 9, 2}; 8 int min = 100, max = 0; 9 10 //find the largest and the minest 11 for(int i = 0; i < a.length; i++) 12 { 13 if(a[i] > max) 14 { 15 max = a[i]; 16 } 17 if(a[i] < min) 18 { 19 min = a[i]; 20 } 21 } 22 23 System.out.println(max+"---"+min); 24 25 //create array depend on the max and min 26 int[] b = new int[]{0,0,0,0,0,0,0,0,0,0}; 27 28 29 //统计数组中每个元素的个数 30 for(int i = 0; i < a.length; i++) 31 { 32 System.out.print(a[i] - min); 33 b[(a[i]-min)]++;//b数组的下标加min就是对应的值，b中存放的是对应值的数量 34 } 35 System.out.println(); 36 37 //将结果拷贝回原数组 38 39 int j = 0; 40 for(int i = 0; i < b.length; i++) 41 { 42 while(b[i] != 0) 43 { 44 a[j] = i + min; 45 b[i]--; 46 j++; 47 } 48 } 49 System.out.println(Arrays.toString(a)); 50 System.out.println(Arrays.toString(b)); 51 } 52 }
运行结果：
PS E:Java2018Atomsort> java CountSort Hello world! 9---1 12760111628710313581 [1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 4, 6, 7, 7, 8, 8, 9, 9] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
RADIX SORT:好像叫基数排序，就是多位数排序时的算法，多位数的，按数组中位数最多的算，不够的前面补0啊
1.创建0-9的9个位置来暂存数据，每个位置可能出现存储多个数据，取出数据的时候按先存先出（类似栈）
2.遍历多位数的最后一位，然后根据数字，对应存放到对应的位置中，遍历完成后，再把0-9这9个空间的数据，按规则写回到原来的数组中
3，再次遍历多位数的倒数第二位，重复上面的操作，直到遍历完成多位数的第一位
#######拿到多位整数中每个数位对应数字的的想法————网上看到的，感觉很好用
1，先拿到个位数的值，然后用这个整数除以10使这个多位数减少一位
2，用拿到个位数的方法，可以拿到十位数的值，然后再把多位数减少一位
依次类推，可以拿到最高位的值
代码实例：
1 import java.util.*; 2 3 public class RadixSort{ 4 public static void main(String[] args) 5 { 6 //System.out.println(getRadix(1020,9)); 7 8 int[] a = {3221, 1, 10, 9680, 577, 9420, 7, 5622, 4793, 2030, 3138, 82, 2599, 743, 4127}; 9 10 LinkedHashSet[] l = new LinkedHashSet[10];//创建集合来暂存数据0-9 11 //初始画，这个很类似二维数组啊，感觉 12 for(int i = 0; i < 10; i++) 13 { 14 l[i] = new LinkedHashSet(); 15 } 16 17 18 for(int i = 0; i < 4; i++)//由于指定了四位数，就先按四位数来，---实际要按位数最多来设定 19 { 20 //System.out.println("d"+i); 21 for(int j = 0; j < a.length; j++)//遍历数组，根据对应的值放到对应的集合中 22 { 23 //System.out.println("c"+j); 24 int index = getRadix(a[j], i+1); 25 //System.out.println(index+"++++"+a[j]); 26 l[index].add(a[j]); 27 } 28 29 int tem = 0; 30 //一次遍历完成后，再把数据按照规则重写写回原数组 31 for(int k = 0; k < 10; k++) 32 { 33 for(Object v : l[k]) 34 { 35 //System.out.println(tem+"----"+(Integer)v); 36 a[tem]=(Integer)v; 37 tem++; 38 39 } 40 l[k].clear();//某个集合数据完全拷贝到原数组后，将该集合清空，为了下次循环的存储否则会出错 41 } 42 System.out.println(Arrays.toString(a)); 43 } 44 45 46 47 } 48 49 //方法获取多位数某位的数字，e:多位数 index:第几位的数字（从后往前，从右往左的顺序 50 public static int getRadix(int e, int index) 51 { 52 int result = 0; 53 for(int i = 0; i < index; i++) 54 { 55 result = e % 10; 56 e = e / 10; 57 } 58 return result; 59 } 60 }
运行结果：//打印出了每次排序的结果
1 1 个警告 2 PS E:Java2018Atomsort> java RadixSort 3 [10, 9680, 9420, 2030, 3221, 1, 5622, 82, 4793, 743, 577, 7, 4127, 3138, 2599] 4 [1, 7, 10, 9420, 3221, 5622, 4127, 2030, 3138, 743, 577, 9680, 82, 4793, 2599] 5 [1, 7, 10, 2030, 82, 4127, 3138, 3221, 9420, 577, 2599, 5622, 9680, 743, 4793] 6 [1, 7, 10, 82, 577, 743, 2030, 2599, 3138, 3221, 4127, 4793, 5622, 9420, 9680]