Java 常用排序算法

稳定排序与不稳定排序
排序中会遇到相等的数，如数列｛a1,a2,a3,a4,a5｝中a2＝a4，如果排序后，a2有可能会在a4的后面，那么就是不稳定排序，否则为稳定排序。

对换方法
很多排序算法都会有两个数据的对换，故将其写成一个方法swap()。

public static void swap(int array[],int i,int j) {
      int temp = array[i];
      array[i] = array[j];
      array[j] = temp;
}

冒泡排序

public static void bubbleSort(int a[]) {
    for(int i=0;i<a.length-1;i++) {
        for(int j=0;j<a.length-1-i;j++) {
            if(a[j]>a[j+1]) {
                swap(a,j,j+1);
            }
        }
    }
    System.out.println(Arrays.toString(a));
}

选择排序

 public static void selectSort(int a[]) {
     for(int i=0;i<a.length-1;i++) {
         int min = i;
         for(int j=i+1;j<a.length;j++) {
             if(a[min] > a[j]) {
                 min = j;
             }
         }
         swap(a,i,min);
     }
     System.out.println(Arrays.toString(a));
 }

快速排序
使用递归的方式实现该算法，为了让排序方法只有一个参数，使用了两个方法实现。

public static void quickSort(int a[]) {
    quickSort(a,0,a.length-1);//调用递归实现的排序方法
    System.out.println(Arrays.toString(a));
}

public static void quickSort(int a[],int l,int r) {
    if(r>l) {
        int temp, high, low;
        low = l;
        high = r;
        temp = a[l];

        while (high > low) {
            while (high > low && a[high] > temp) {
                high --;
            }

            if(high > low) {
                a[low++] = a[high];
            }

            while(high > low && a[low] < temp) {
                low++;
            }

            if(high > low) {
                a[high --] = a[low];
            }
        }
        a[low] = temp;
        quickSort(a,l,low-1);
        quickSort(a,low+1,r);
    }

}

直接插入排序

public static void insertSort(int a[]) {
    for(int i = 1;i < a.length;i++) {
        for(int j = i;j > 0;j--) {
            if (a[j] < a[j-1]) {
                swap(a,j,j-1);
            }
        }
    }
    System.out.println(Arrays.toString(a));
}

希尔排序
根据gap的计算方式不同，写出两种略有不同的代码，下面是第一种：

public static void shellSort(int[] a) {
    int len = a.length;
    //对不同的gap进行排序
    for(int gap = len/2; gap > 0 ; gap/=2)
        //插入排序总共比较（数组长-1）轮
        //希尔排序将数组分为gap个子组，对每个子数组进行插入排序
        //每个子数组进行插入排序的轮数为：（子数组长-1），那么总共为（数组长-gap）轮
        for(int i = 0; i < len-gap ; i++)
            //插入排序相当于gap=1
            for(int j = gap+i; j >= gap;j-=gap) {
                if(a[j] < a[j-gap])
                    swap(a,j,j-gap);
            }
}

再来看看第二种：

public static void shellSort2(int[] a) {
    int len = a.length;
    int gap = 1;
    while(gap<=len/3) {
        gap = gap*3+1;
    }
    for(; gap > 0 ; gap=(gap-1)/3)
        for(int i = 0; i < len-gap ; i++)
            for(int j = gap+i; j >= gap;j-=gap) {
                if(a[j] < a[j-gap])
                    swap(a,j,j-gap);
            }
}

文章推荐
8大排序算法图文讲解，该文用动态图的方式描绘了常用的8个排序算法，有助于理解算法原理。