Java常用的排序算法三

Merge Sort :归并排序；用递归的思想，分解成单个元素的排序，在归并

代码：

 import java.util.*;

 public class  MergeSort
 {
     public static void main(String[] args)
     {
         System.out.println("Hello World!");
         int [] a = {3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
         mergeSort(a,0,14);
         //System.out.println(Arrays.toString(a));
     }

     //思路，先将数组分成两部分，这两部分在分别再分，分成单个的为一个partion,
     //然后再归并这些partion
     public static int[] mergeSort(int [] num , int low, int high)
     {
         int mid = (low + high)/2;

         if(low < high)//分解，递归
         {
             mergeSort(num, low, mid);
             mergeSort(num, mid + 1, high);
             merge(num, low, mid, high);//归并
             System.out.println(low+"::" + high + "::::"+Arrays.toString(num));
         }

         return num;
     }
     //归并的函数
     public static void merge(int [] num, int low, int mid, int high)
     {
         int [] store = new int [high - low + 1];
         int i = low;
         int j = mid + 1;
         int k = 0;

         //比较两个partion,生成新的排序好的数组
         while(i <= mid && j <= high)
         {
             if(num[i] > num[j])
             {
                 store[k] = num[j];
                 k++;
                 j++;
             }
             else
             {
                 store[k] = num[i];
                 k++;
                 i++;
             }
         }

         //插入剩余的元素
         while(i <= mid)
         {
             store[k] = num[i];
             k++;
             i++;
         }
         while(j <= high)
         {
             store[k] = num[j];
             k++;
             j++;
         }

         //将排序后的代码拷贝到原来的数组，原来的位置
         for(int m = 0; m < store.length; m++)
         {
             num[m + low] = store[m];
         }
     }
 }

运行结果：打印出了每次归并的结果

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.然后遍历计数数组，把数据从新写回原来的数组，排序完成

代码：

 import java.util.*;

 public class CountSort{
   public static void main(String[] args)
   {
     System.out.println("Hello world!");
     int[] a = new int[]{2, 3, 8, 7, 1, 2, 2, 2, 7, 3, 9, 8, 2, 1, 4, 2, 4, 6, 9, 2};
     int min = 100, max = 0;

     //find the largest and the minest
     for(int i = 0; i < a.length; i++)
     {
       if(a[i] > max)
       {
         max = a[i];
       }
       if(a[i] < min)
       {
         min = a[i];
       }
     }

     System.out.println(max+"---"+min);

     //create array depend on the max and min
     int[] b = new int[]{0,0,0,0,0,0,0,0,0,0};

     //统计数组中每个元素的个数
     for(int i = 0; i < a.length; i++)
     {
       System.out.print(a[i] - min);
       b[(a[i]-min)]++;//b数组的下标加min就是对应的值，b中存放的是对应值的数量
     }
     System.out.println();

     //将结果拷贝回原数组

     int j = 0;
     for(int i = 0; i < b.length; i++)
     {
       while(b[i] != 0)
       {
         a[j] = i + min;
         b[i]--;
         j++;
       }
     }
     System.out.println(Arrays.toString(a));
     System.out.println(Arrays.toString(b));
   }
 }

运行结果：

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，用拿到个位数的方法，可以拿到十位数的值，然后再把多位数减少一位

　　　　依次类推，可以拿到最高位的值

代码实例：

 import java.util.*;

 public class RadixSort{
   public static void main(String[] args)
   {
     //System.out.println(getRadix(1020,9));

     int[] a = {3221, 1, 10, 9680, 577, 9420, 7, 5622, 4793, 2030, 3138, 82, 2599, 743, 4127};

     LinkedHashSet[] l = new LinkedHashSet[10];//创建集合来暂存数据0-9
     //初始画，这个很类似二维数组啊，感觉
     for(int i = 0; i < 10; i++)
     {
       l[i] = new LinkedHashSet();
     }

     for(int i = 0; i < 4; i++)//由于指定了四位数，就先按四位数来，---实际要按位数最多来设定
     {
       //System.out.println("d"+i);
       for(int j = 0; j < a.length; j++)//遍历数组，根据对应的值放到对应的集合中
       {
         //System.out.println("c"+j);
         int index = getRadix(a[j], i+1);
         //System.out.println(index+"++++"+a[j]);
         l[index].add(a[j]);
       }

       int tem = 0;
       //一次遍历完成后，再把数据按照规则重写写回原数组
       for(int k = 0; k < 10; k++)
       {
         for(Object v : l[k])
         {
           //System.out.println(tem+"----"+(Integer)v);
           a[tem]=(Integer)v;
           tem++;

         }
         l[k].clear();//某个集合数据完全拷贝到原数组后，将该集合清空，为了下次循环的存储否则会出错
       }
       System.out.println(Arrays.toString(a));
     }

   }

   //方法获取多位数某位的数字，e:多位数 index:第几位的数字（从后往前，从右往左的顺序
   public static int getRadix(int e, int index)
   {
     int result = 0;
     for(int i = 0; i < index; i++)
     {
       result = e % 10;
       e = e / 10;
     }
     return result;
   }
 }

运行结果：//打印出了每次排序的结果

 1 个警告
 PS E:\Java2018\Atom\sort> java RadixSort
 [10, 9680, 9420, 2030, 3221, 1, 5622, 82, 4793, 743, 577, 7, 4127, 3138, 2599]
 [1, 7, 10, 9420, 3221, 5622, 4127, 2030, 3138, 743, 577, 9680, 82, 4793, 2599]
 [1, 7, 10, 2030, 82, 4127, 3138, 3221, 9420, 577, 2599, 5622, 9680, 743, 4793]
 [1, 7, 10, 82, 577, 743, 2030, 2599, 3138, 3221, 4127, 4793, 5622, 9420, 9680]