Java 实现各种基本排序算法

 

1. 冒泡排序；

//冒泡排序，法1
    public static int[] sort1(int[] a){
        int n = a.length;

        for(int i = 0; i < n - 1; i++){
            for(int j = i + 1; j < n; j++){ //每次都跟后面的值比较，较小值像水泡一样浮上来
                if(a[i] > a[j]){
                    int tmp = a[i];
                    a[i] = a[j];
                    a[j] = tmp;
                }
            }
        }

        return a;
    }

    //冒泡排序，法2
    public static int[] sort2(int[] a){
        int n = a.length;

        for(int i = 0; i < n ; i++){
            for(int j = 0; j < n - 1 - i; j++){ //每次都跟后面的值比较，较小值像水泡一样浮上来,较大值沉下去
                if(a[j] > a[j+1]){
                    int tmp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = tmp;
                }
            }
        }

        return a;
    }

2.选择排序；

//选择排序
    public static int[] selectSort(int[] a){
        int n = a.length;

        for(int i = 0; i < n; i++){
           int min = i;
           for(int j = i; j < n; j++){ //每次选取后面的最小值
               if(min > a[j]){
                   min = j;
               }
           }
           int tmp = a[i];
           a[i] = a[min];
           a[min] = tmp;
        }

        return a;
    }

3. 插入排序；

 //插入排序 方法1
    public static int[] inseartSort1(int[] a){
        int n = a.length;

        for(int i = 1; i < n; i++){
            for(int j = i; j>0; j--){ //每次跟前面的值比较大小，交换
                if(a[j] < a[j-1]){
                    int tmp = a[j];
                    a[j] = a[j-1];
                    a[j-1] = tmp;
                }
            }
        }

        return a;
    }

    //插入排序 方法2
    public static int[] inseartSort2(int[] a){
        int n = a.length;

        for(int i = 0; i < n; i++){
            int j = i;
            while(j>0 && a[i]<a[j-1]){  //找出a[i]合适的位置，是下标为j的位置
                j--;
            }
            int tmp = a[i]; //因为后续会覆盖掉a[i]的值，需要先保存下来
            for(int k = i; k > j; k--){ //将a[i]到a[j]前面的值往后挪，腾出合适的位置给原来的a[i]（即tmp）
                a[k] = a[k-1];
            }
            if(j != i){ //放入合适的位置
                a[j] = tmp;
            }
        }

        return a;
    }

4.希尔排序；

 //shell 希尔排序
    public static int[] shellSort(int[] a){
        //将a[]按升序排列
        int n = a.length;
        //在插入排序inseartSort1中加入一个外循环来将h
        // 按照递增序列递减，我们就能得到这个简洁的希尔排序。
        // 增幅h 的初始值是数组长度乘以一个常数因子，最小为1。

        int h = 1;//希尔排序的间隔长度
        //这边选择将数组分为3段长度来处理
        while(h < n/3){
            h = 3 * h + 1;
        }

        while(h >= 1){
            for(int i = h; i < n; i++){
                for(int j = i; j >= h; j -= h){ // 隔段h长度比较
                    if(a[j] < a[j-h]){
                        int tmp = a[j];
                        a[j] = a[j-h];
                        a[j-h] = tmp;
                    }
                }
            }
            h = h / 3; //缩短比较的间隔长度
        }

        return a;
    }

5.归并排序：

import java.util.Arrays;

public class MergeSort {
    public static void main(String []args){
        int []arr = {9,8,7,6,5,4,3,2,1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void sort(int []arr){
        int []temp = new int[arr.length];//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        sort(arr,0,arr.length-1,temp);
    }
    private static void sort(int[] arr,int left,int right,int []temp){
        if(left<right){
            int mid = (left+right)/2;
            sort(arr,left,mid,temp);//左边归并排序，使得左子序列有序
            sort(arr,mid+1,right,temp);//右边归并排序，使得右子序列有序
            merge(arr,left,mid,right,temp);//将两个有序子数组合并操作
        }
    }
    private static void merge(int[] arr,int left,int mid,int right,int[] temp){
        int i = left;//左序列指针
        int j = mid+1;//右序列指针
        int t = 0;//临时数组指针
        while (i<=mid && j<=right){
            if(arr[i]<=arr[j]){
                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
            }
        }
        while(i<=mid){//将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }
        while(j<=right){//将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }
        t = 0;
        //将temp中的元素全部拷贝到原数组中
        while(left <= right){
            arr[left++] = temp[t++];
        }
    }
}

6.快速排序；

public class QuickSort {
    public void sort(int[] array) {
        quickSort(array, 0, array.length - 1);
    }

    /**
     * 递归排序
     * @param src
     * @param begin
     * @param end
     */
    private void quickSort(int[] src, int begin, int end) {
        if (begin < end) {
            int key = src[begin];
            int i = begin;
            int j = end;
            while (i < j) {
                while (i < j && src[j] > key) {
                    j--;
                }
                if (i < j) {
                    src[i] = src[j];
                    i++;
                }
                while (i < j && src[i] < key) {
                    i++;
                }
                if (i < j) {
                    src[j] = src[i];
                    j--;
                }
            }
            src[i] = key;
            quickSort(src, begin, i - 1);
            quickSort(src, i + 1, end);
        }
    }
}

 

测试主代码

public class Test {

    public static void main(String[] args){
        int[] a = new int[]{0,9,8,7,1,2,3,6,5,4,9};
        sort2(a);
        for(int i = 0; i<a.length; i++){
            System.out.print(a[i]);
            System.out.print(" ");
        }
        System.out.println();
        System.out.println("=============================");

    }

    
    

   
   
}

参考：https://www.cnblogs.com/chengxiao/p/6194356.html

http://data.biancheng.net/view/117.html