几种基本的排序算法

1.选择排序（以递增排序为例）：

通过内部循环第一次遍历数组找到最小的元素与数组的第一个元素交换位置，第二次遍历数组找到第二小的元素与数组的第二个元素交换位置，当内存循环找到最小的元素并交换位置后下次遍历时应该避开这个最小元素。这种排序方法对任何结构的数组都是O(n²)的时间复杂度

 public int[] choose(int[] a) {
        for (int i = 0; i < a.length; i++) {
            int temp = a[i];
            int index = i;
            for (int j = i + 1; j < a.length; j++) {
                if (temp > a[j]) {
                    temp = a[j];
                    index = j; }
            }
            if (index != i) {
                a[index] = a[i];
                a[i] = temp;
            }
        }
        return a;
    }

2.插入排序(以递增排序为例)：

假定第一个元素为最小元素，判定第二个元素与第一元素的大小，如果第二个小于第一个，则交换位置，这时候第一个和第二个已经排好序，通过第三个元素与前面已经排好的第二个元素进行比较，如果大于第二个，则进行下一轮循环、否则交换位置后继续与第一个元素进行比较，外部控制循环到达直到到达数组末端。这种排序方式有个相对于选择排序有个好处就是如果数组本身就已经有部分排好序，则在后面的比较中当与前面已经排好序的最大值进行比较时如果大于最大值的元素就会忽略掉与其他元素的比较，节省了时间

public static int[] orderByInsert(int[] a){
        for(int i=1;i=0 && a[j]>temp){//如果子集的元素大于当前值，则修改当前值的位置
                    a[j+1]=a[j];//将j的位置的值向前移动,用于存放当前值
                    j--;//进入下一次循环
                }
                a[j+1]=temp;//循环结束后子集中所有大于temp的值都向前移动了一步，这时候j+1的位置就是temp应该插入的位置
            }
        }
        return a;
    }

3.冒泡排序(以递增排序为例)：

冒泡排序的思想是从左到右(从右到左)进行相邻元素的大小判定，如果后一个元素小于前一个元素，交换位置，一轮循环后最大值将在最右边

public static int[] orderByBubble(int[] a){
        for(int i=0;ia[j+1]){
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        return a;
    }

4.归并排序(以递增排序为例)：

感觉这个算法比较难以理解，花了不少时间，归并排序的本质是利用空间换时间的方式，所谓规即指的是递归，并指的是合并，将目标数组进行递归平分直到最多只有2个元素的数组时执行排序，然后两两经过归并排序的数组进行再次归并······，由于在递归中需要不断地创建数组来比较排序，因此空间复杂度为O(nlogn),具体算法如下：

/**
     * 归并排序(递归和合并)
     * @param a 目标数组
     * @param p 目标数组的起始位置
     * @param r 目标数组的结束位置
     */
    public static void mergeSort(int[] a, int p, int r) {
        if(p

5. 快速排序(以递增排序为例)：

public static void quickSort(int[] a){
        sort(a,0,a.length-1);
    }

    /**
     * 快速排序
     * @param a 目标数组
     * @param begin 起始下标
     * @param end 终止下标
     */
    private static void sort(int[] a, int begin, int end) {
        int i,j,index;
        if(begin>=end)//数组合法性判定
            return;
        i=begin;
        j=end;
        index=a[i];//拷贝第一个元素
        //以下循环主要完成将一个数组平分成两部分，左边部分的每一个值均小于右边的每一个值
        //原理：一次循环中分别从尾端向首端遍历找到一个小于index的元素并赋值给a[i](a[i]的值保存在index中不会丢失),这时候尾端的元素可
        //通过j作为下标找到，接下来通过首端向尾端遍历找到一个大于index的元素并赋值给之前已经赋值到左
        //部分的元素，这些条件都是在i=index)
                j--;
            if(i