[置顶] ［算法］Java中数组的排序算法

选择排序法：
选择排序法是将要排序的数组分为两部分，一部分是从小到大已经排序好的，还有一部分是
无序的，从无序的部分取出最小的数值，放到已经排好序的最后。实现代码如下：

public int[] xuanze(int[] arr)
{
    int t;
    for(int i = 0; i <arr.length; i++)
    {
        int m = i;
        for(int j = i + 1; j < arr.length; j++)
        {
            //如果j元素比m元素小，将j赋值给m
            if(arr[j] < arr[m])
            {
                m = j;
            }
        }
        //交换m和I两个元素的位置
        if(i != m)
        {
            t = arr[i];
            arr[i] = arr[m];
            arr[m] = t;
        }
    }
    return arr;
}

冒泡排序法：
从数组开始扫描带排序的元素，在扫描过程中依次对相邻元素进行比较，将数值大的元素
后移。每经过一趟排序后，数值最大的元素将移到末尾，此时记下该元素的位置，下一趟
排序只需要比较到此位置为止，直到所有元素都已有序排列，实现代码如下：

public int[] maopao(int[] arr)
{
    int t;
    for(int i = 0; i < arr.length; i++)
    {
    for(int j = 0; j < arr.length-i-1; j++)
    {
        //比较相邻元素大小，小的前移，大的后移
        if(arr[j] > arr[j+1])
        {
            t = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = t;
        }
    }

    }
    return arr;

}

插入排序法：
将要排序的数组分为两部分，每次从后面的数组部分取出索引最小的数组元素，插入到前
面数组部分的适当位置中。通常在开始排序时，将数组的第一个元素中作为一组，后面所
有的元素被当成一组。实现代码如下：

public static int[] charu(int[] arr)
{
    //把第一个元素看做一部分，第二个元素看做另一部分
    //从第二部分依次取元素插入到第一部分中
    for(int i = 1; i < arr.length; i++)
    {
        int tmp = arr[i];
        int j = i - 1;
        //依次和i前面元素比较，寻找合适插入位置
        while(tmp < arr[j])
        {
            arr[j+1] = arr[j];
            j--;
            if(j == -1)
            {
                break;
            }
        }
        //将插入元素插入到合适位置
        arr[j+1] = tmp;
    }
    return arr;
}

快速排序法：
快速排序法是当今被认为最好的排序算法之一。基本思路是：将一个大的数组的排序问题，分解成2个小的数组的排序，而每个小的数组的排序又可以继续分解成更小的2个数组，这样一直递归分解下去，直到数组的大小最大为2.实现代码如下：

public static int[] kuaisu(int[] arr)
{
    return quicksort(arr, 0, arr.length - 1);
}

//递归分组排序
public static int[] quicksort(int[] arr, int left, int right)
{
    int t;
    if(left < right)
    {
        int s = arr[left];
        int i = left;
        int j = right + 1;
        while(true)
        {
            //向右找大于s的数的索引
            while(i+1 < arr.length && arr[++i] < s);
            while(j-1 > -1 && arr[--j] > s);
            //如果i>=j,退出循环
            if(i >= j)
            {
                break;
            }
            else
            {
                //交换i和j的位置
                t = arr[i];
                arr[i] = arr[j];
                arr[j] = t;
            }
        }
        arr[left] = arr[j];
        arr[j] = s;
        //对左边进行递归
        quicksort(arr, left, j-1);
        //对右边进行递归
        quicksort(arr, j+1, right);
    }
    return arr;
}