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:\java\java_test\sortprogram>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:\java\java_test\sortprogram>
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:\Java2018\Atom\sort> 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:\Java2018\Atom\sort> 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]