几种排序算法JAVA实现

基于比较

冒泡排序、插入排序、归并排序、快速排序   

基于计算

计数排序

下面直接上干货

方法定义在ArrayUtil类中

public class ArrayUtil {
    public  void BubbleSortInt(int[] array){   //利用冒泡排序对int类型的数组array 进行排序
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0;j < array.length-1-i;j++){ //第i轮把第i大的移到最后面
                if (array[j] > array[j + 1]){  //大的向后面移动
                  int temp = array[j];
                  array[j] = array[j+1];
                  array[j+1] = temp;
                }
            }
        }
    }
    public void InsertSort(int[] array){  //都是进行从小到大的排序
        for (int i = 1; i < array.length ; i++) {  //从第二个开始即可
            // {3, 1, 99, 6, 88, 67, 89, 2};
            int key = array[i]; //当前要插入的元素
            int j = i - 1;
            while(j >= 0 && array[j] > key){ //一个&会报错，因为逻辑与需要两个都执行完毕，包索引超出异常
                array[j + 1] = array[j];
                j = j - 1;
            }
            array[j+1] = key;
        }
    }

    public void Merge(int[] array,int p,int q,int r){
        //其中array数组的p--->q之间是有序的，q+1---->r之间是有序的  假设都是从小到大
        //目标就是将两部分进行合并，使得p---->r之间是有序的
        int[] arrayL = new int[q - p + 2];  //+2是要比真正的长度多一，便于将最后一个置为正无穷大
        for (int i = 0; i < arrayL.length - 1; i++) {
            arrayL[i] = array[p+i];
        }       //将数组的左边单独放到一起
        arrayL[q-p+1] = (int)Double.POSITIVE_INFINITY;
        /*将最后一个位置置为正无穷大，便于后面有一部分都放上去之后，另一部分剩下的可以直接放上去
        * */
        int[] arrayR = new int[r - q+1];
        for (int i = 0; i < arrayR.length - 1 ; i++) {
            arrayR[i] = array[q+i+1];
        }               //同上，右边放到一起
        arrayR[r-q] = (int)Double.POSITIVE_INFINITY;
        ///-------------前面是对数组进行初始化------------------------///
        int k = 0;
        int j = 0;
        for (int i = p ; i < r + 1; i++) {  //对应的是原本数组的位置
            if (arrayL[j] <= arrayR[k]){
                array[i] = arrayL[j];
                j += 1;
                System.out.println("j="+j);
            }else{
                array[i] = arrayR[k];
                System.out.println("k="+k);
                k += 1;
                //System.out.println("k="+k);
            }
        }
    }
    public void MergeSort(int[] array,int p,int r){  //归并排序
        //分治法，递归求解，可以直接进行递归n=1时是出口
        //在出口需要调用的是对两个已经排好顺序的舒徐进行合并
        if ( p < r){
          //  {3, 1, 99, 6,    |   88, 67, 89, 2};
            int q = (int)((p + r) / 2); //强制分成两部分
            MergeSort(array,p,q);
            MergeSort(array,q + 1,r);
            Merge(array,p,q,r);
        }
    }

   public int swap(int[] array,int start,int end){ //快速排序的前期准备
        //实现交换的过程,需要开始和结束的索引，其实就是原址重排的过程
        // i是开始的索引  j是结束的索引   在array中需要查询的范围
        int i = start;
        int j = end;
        int flag = array[start];
       int temp;
       //  {3, 1, 99, 6,    |   88, 67, 89, 2};
        while (i < j){  //
            while (array[j] > flag && i < j) {
                j -= 1;
            }
            while (array[i] <= flag && i < j){ //如果不小于就不进行移动，说明当前的比较大
                i += 1;
            }
            temp = array[i];
            array[i] = array[j];
            array[j] = temp;   //交换完毕
        }
        array[start] = array[i];
        array[i] = flag;      //把标准值放在中间
        return i;             //交换完成之后返回值
    }
    public void FastSort(int[] array,int start,int end){   //快速排序算法
        if (start < end) {
            int mid = swap(array, start, end);  // 用不上这个mid
            FastSort(array, start, mid - 1);
            FastSort(array, mid + 1, end);
        }
    }
    public int[] CountSort(int[] array,int k){  //计数排序
        /* @parameter
        * array :要进行排序的数组
        * k : 保证array中所有的数字都在0 - (k - 1)之间
        * */
        int[] B = new int[array.length];
        int[] C = new int[k];
        for (int i = 0; i < array.length; i++) {
            C[array[i]] = C[array[i]] + 1;  //保存的是在数组array中出现array[i]这个数的次数
        }
        for (int i = 1; i < C.length; i++) {
            C[i] = C[i - 1] + C[i];  //这个时候C每个位置保存的就是比当前小的数量
        }
        for (int j = array.length - 1; j >= 0; j--){
            B[C[array[j]] - 1] = array[j]; //此时B中保存的就是排好的顺序
            C[array[j]] -= 1;
        }
        return B;
    }
    public  void ShowArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+"\t");
        }
    }


}

可以自己利用主类主方法进行调用。

代码如下：

public class Test {
    public  static void main(String[] args) {
        //定义一个中间值用来交换
        int[] array = new int[]{ 3,1, 99, 100,6, 88, 67, 89, 2};
        ArrayUtil arr = new ArrayUtil();
        //arr.BubbleSortInt(array);
        arr.ShowArray(array);
        System.out.println();
        //arr.InsertSort(array);
        //arr.MergeSort(array,0, array.length-1);
        //arr.FastSort(array,0, array.length-1);
        int[] B=arr.CountSort(array,101);
        arr.ShowArray(B);
    }
}