常见排序算法：O(N²)

github已上传相关源码

1.冒泡排序

比较两个相邻的元素，将值大的元素交换至右端。第一趟排序后，最后一个元素就是最大的，然后再次遍历[0,n-1],这一趟排序倒数第二位就是剩下的元素李最大的，重复遍历，直到剩下一个元素时，就获得排序好的数组。代码如下：

    /**
     * @param arr 待排序数组
     * @param n  数组长度
     */
    public void BubbleSort(int[] arr,int n){
        for (int i = 0 ; i < arr.length - 1 ; i ++){
            for (int j = 0 ; j < arr.length - 1 - i ; j ++){
                if (arr[j] > arr[j + 1]){
                    SortHelper.swap(arr,j,j + 1);
                }
            }
        }
    }

2.选择排序

对数组排序时，实际上是遍历数组，将最小的那一位与索引为0的位置的元素交换，然后在剩下的元素中继续选择最小的元素与索引位置为1的位置交换，如此重复遍历，直到交换完所有元素。代码如下：

    /**
     * @param arr 待排序数组
     * @param n   数组长度
     */
    public static void selectionSort(int[] arr, int n) {
        for (int i = 0; i < n; i++) {
            //寻找[i,n]区间最小值
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            SortHelper.swap(arr, i, minIndex);
        }
    }

3.插入排序

在对数组排序时，将数组分成两部分，前半部分有序，后半部分无序，遍历数组，将无序不分每个元素插入到有序不分合适的位置。代码如下：

    public void insertionSort(int[] arr , int n){
        for (int i = 1 ; i < n ; i ++){
            //寻找元素arr[i]合适的插入位置
            for (int j = i ; j > 0 ; j --){
                if (arr[j] < arr[j - 1]){
                    SortHelper.swap(arr,j,j-1);
                }else {
                    break;
                }
            }
        }
    }

相比于选择排序，可以发现插入排序内层的for循环是可以提前结束的，相比于选择排序性能会有提升（也就是如果是基本有序的数组，插入排序效率更高）。考虑到比较和交换过程中的多次赋值操作也是需要消耗性能的，还可以做如下改进：

    //升级版
    public static void insertionSortV2(int[] arr , int n){
        for (int i = 1 ; i < n ; i ++){
            //寻找元素arr[i]合适的插入位置
            int e = arr[i];
            for (int j = i ; j > 0 ; j --){
                if (arr[j - 1] > e){
                    arr[j] = arr[j - 1];
                }else {
                    break;
                }
                arr[j] = e;
            }
        }
    }

因为不再是进行元素的交换，比起来减少了赋值操作，会节约一点性能。因为能够提前终止第二层循环，在数组有序的情况下甚至可能比O(nlogn)级别的排序算法还要快。