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]