java排序算法，排序都有哪几种算法？

java排序算法，排序都有哪几种算法？

排序的算法有分别有：

1、插入排序 （直接插入排序、希尔排序）

2、交换排序（冒泡排序、快速排序）

3、选择排序（直接选择排序、堆排序）

4、归并排序

5、分配排序（箱排序、基数排序）

直接插入排序：
每次从无序表中取出第一个元素，把它插入到有序表的合适位置，使有序表仍然有序。
第一趟比较前两个数,然后把第二个数按大小插入到有序表中; 第二趟把第三个数据与前两个数从前向后扫描，把第三个数按大小插入到有序表中；依次进行下去，进行了(n-1)趟扫描以后就完成了整个排序过程。

直接插入排序Java版本的代码实现：

public class MainTest {
public static void main(String[] args) {
int[] a = { 46, 58, 15, 45, 90, 18, 10, 62 };
int n = a.length;
int i, j;
for (i = 0; i < n; i++) {
int temp = a[i];
for (j = i; j > 0 && temp < a[j-1]; j–) {
a[j] = a[j - 1];
}
a[j] = temp;
}
for(i=0;i<n;i++){
System.out.print(a[i]+”\t”);
}
}
}
更多的介绍 http://baike.baidu.cn/view/1193395.htm

希尔排序是插入排序的一种。是针对直接插入排序算法的改进，是将整个无序列分割成若干小的子序列分别进行插入排序。

希尔排序：先取一个正整数d1<n，把所有序号相隔d1的数组元素放一组，组内进行直接插入排序；然后取d2<d1，重复上述分组和排序操作；直至di=1，即所有记录放进一个组中排序为止。

更多关于希尔排序的介绍 http://baike.baidu.cn/view/178698.htm

冒泡排序：
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
冒泡排序java版本的代码实现如下：
public class BubbleSort{
    public void sort(int[] a) {
        int temp = 0;
        for (int i = a.length – 1; i > 0; –i) {
            for (int j = 0; j < i; ++j) {
                if (a[j + 1] < a[j]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }
}
更多关于冒泡排序算法的介绍 http://baike.baidu.cn/view/254413.htm

快速排序：

快速排序是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

快速排序java版本的代码实现如下：
public class QuickSort{
    public static void main(String[] ary){
        int[] arry = {49, 38, 65, 97, 76, 13, 27};
        sort(arry, 0, arry.length – 1);
    }
    /**
    * 一次排序单元，完成此方法，key左边都比key小，key右边都比key大。
    * @param array 排序数组
    * @param low 排序起始位置
    * @param high 排序结束位置
    * @return 单元排序后的数组
    */
    private static int sortUnit(int[] array, int low, int high){
        int key = array[low];
        while (low < high){
            //从后向前搜索比key小的值
            while (array[high] >= key && high > low)
                –high;
            //比key小的放左边
            array[low] = array[high];
            //从前向后搜索比key大的值，比key大的放右边
            while (array[low] <= key && high > low)
                ++low;
            //比key大的放右边
            array[high] = array[low];
            System.out.println(low + “,” + high);
        }
        //左边都比key小，右边都比key大。将key放在游标当前位置。此时low等于high
        array[high] = key;
        System.out.println(Arrays.toString(array));
        return high;
    }
    /**
    * 快速排序
    * @param arry
    * @return
    */
    public static void sort(int[] array, int low, int high){
        if (low >= high) return;
        //完成一次单元排序
        int index = sortUnit(array, low, high);
        //对左边单元进行排序
        sort(array, low, index – 1);
        //对右边单元进行排序
        sort(array, index + 1, high);
    }
}

更多关于快速排序算法的介绍 http://baike.baidu.cn/view/19016.htm

直接选择排序：

直接选择排序也是一种简单的排序方法，它的基本思想是：第一次从R[0]~R[n-1]中选取最小值，与R[0]交换，第二次从R[1]~R[n-1]中选取最小值，与R[1]交换，….，第i次从R[i-1]~R[n-1]中选取最小值，与R[i-1]交换，…..，第n-1次从R[n-2]~R[n-1]中选取最小值，与R[n-2]交换,总共通过n-1次,得到一个按排序码从小到大排列的有序序列.