Java常用的排序算法三

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]

 

posted @ 2018-04-17 20:33  笑谭枫昇  阅读(230)  评论(0编辑  收藏  举报