排序算法（冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序）

冒泡排序

思想：比较两个相邻的元素，将较大的元素放在右边

代码：

//写法一  
public static void bubbleSort(int[] arr) {
        for (int i = arr.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[j + 1]) swap(arr, j+1, j);
            }
        }
    }

//写法二
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {     //外循环控制循环的趟数，len个数比较len-1趟
            for (int j = 0; j < arr.length - 1 - i; j++) {  //内循环为每趟比较的次数，第i趟比较len-i次
                if (arr[j] > arr[j+1]) swap(arr, j+1, j);
            }
        }
    }

流程总结：

1. 首先比较第一个数和第二个数，将较大的数放在右边
2. 然后比较第二个数和第三个数，将较大的数放在右边
3. 直到倒数第二个数和倒数第一个数比较完，则当前数组中最大的数就放在了最右边。
4. 然后进入下一次循环，重复上述比较步骤，直到倒数第二个数和倒数第三个数比较完，那么倒数第二个数就是数组的倒数第二大的数。
   因此，每一轮结束后，在下一轮比较的时候，比较的次数都会减少一次，也就理解了写法二中的 j < arr.length - 1 -i 了。

时间复杂度：O(n²)
稳定性：稳定。如果两个数相等，则不交换

选择排序

第一次从待排序的数组中选出最小的元素，放在数组的起始位置；
第二次从待排序的数组中选出最小的元素，放在已排序数组的末尾(已排序数组的后一个数和未排序数组的最小数进行交换)
以此类推，直到排完所有元素

代码：

    public static void selection(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            //最小值的索引
            int minIndex = i;
            //寻找i~N-1索引上的最小值
            for (int j = i + 1; j < arr.length; j++) {
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            }
            swap(i, minIndex, arr);
        }
    }

时间复杂度：O(n²)
稳定性：不稳定。假设数组是 [5,4,5,2,3] ，在第一遍排序的时候，第一个5会和2交换，就会导致第一个5跑到第二个5后面，因此不稳定。

插入排序

遍历数组，每一步将一个待排序的数组插入到已经排好序的序列的合适位置，直到排完为止

1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已排序的序列中从后向前扫描
3. 如果该已排序元素大于新元素，就将两个数的位置交换
4. 重复步骤3，直到找到某个已排序的元素小于等于新元素

代码：

public static void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {  //外层遍历每一个待排序的数
            for (int j = i - 1; j >= 0; j--) {     //内层控制待排序的数和已排序的数比较和交换
                if (arr[j] > arr[j + 1]) swap(arr, j + 1, j);
            }
        }
    }

时间复杂度：O(n²)
稳定性：稳定

希尔排序

是改进的插入排序（插入排序每次只能将数据移动一位），也称递减增量排序，减少了交换的次数。

思想：希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多。当增量减至1时，整个文件恰被分成一组，算法便终止。

过程图解：

上图参考：https://www.cnblogs.com/chengxiao/p/6104371.html

代码：

public static void sort(int[] arr) {
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            //插入排序
            //外层循环控制当前对第几个数进行排序
            for (int i = gap; i < arr.length; i++) {
                //内存循环控制当前要排序的数在和谁作比较
                for (int j = i; j > gap - 1; j -= gap) {
                    //如果当前排序的数比它前面的数小就交换
                    if (arr[j] < arr[j - gap]) {
                        swap(arr, j, j - gap);
                    }
                }
            }
        }
    }

时间复杂度：O(n^1.3)
稳定性：不稳定。如 [4,3,6,5,1,5] 数据序列，第一次分组：(4,5),(3,1)(6,5)， 分别对其插入排序，结果[4,1,5,5,3,6]，在这个过程中两个5的前后顺序发生了改变。

归并排序

归并排序是分治算法的一个典型的应用。Java对象排序用的就是这种算法。
描述：将数组分为两部分，对每部分递归地应用归并排序。在两部分都排好序后，对他们进行归并。

代码：

/将两个有序数组合并
    public static int[] merge(int[] list1, int[] list2) {
        int[] temp = new int[list1.length + list2.length];

        int current1 = 0; //current index in list1
        int current2 = 0; //current index in list2
        int current3 = 0; //current index in temp

        while (current1 < list1.length && current2 < list2.length) {
            temp[current3++] = list1[current1] <= list2[current2] ? list1[current1++] : list2[current2++];
        }

        while (current1 < list1.length) temp[current3++] = list1[current1++];
        while (current2 < list2.length) temp[current3++] = list2[current2++];
        return temp;
    }
    //将数组归并排序
    public static void mergeSort(int[] list) {
        if (list.length > 1) {
            //mergeSort the first half
            int[] firstHalf = new int[list.length / 2];
            System.arraycopy(list, 0, firstHalf, 0, list.length / 2);
            mergeSort(firstHalf);

            //mergeSort the second half
            int[] secondHalf = new int[list.length - list.length / 2];
            System.arraycopy(list, list.length / 2, secondHalf, 0, list.length - list.length / 2);
            mergeSort(secondHalf);

            int[] merge = merge(firstHalf, secondHalf);
            System.arraycopy(merge, 0, list, 0, merge.length);
        }
    }

时间复杂度：O(nlogn)
稳定性：稳定。

快速排序

代码：

// 写法一：
    public static void quickSort(int[] arr, int left, int right) {
        // 如果区间不只是一个数
        if (left >= right) return;
        //定义一个基准值（轴）
        int base = arr[left];
        int i = left;	// 从左到右进行查找的指针
        int j = right;	// 从右到左进行查找的指针
        while (i != j) {	
            while (i < j && arr[j] >= base) j--;
            while (i < j && arr[i] <= base) i++;
            if (i < j) swap(arr, i, j);
        }
        //退出循环就代表 i == j
        //将基准数和i j位置上（同一个位置）的数交换
        arr[left] = arr[i];
        arr[i] = base;
        //使用递归对i j 左侧和右侧的子数组进行排序
        quickSort(arr, left, i - 1);
        quickSort(arr, j + 1, right);
    }

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

	//写法二：
    // 快速排序
    public static void quickSort(int[] nums, int left, int right) {
        // 如果区间不只是一个数
        if (left > right) {
            return;
        }
        // 基准数
        int base = nums[left];
        int i = left;   // 从左到右查找的指针
        int j = right;  // 从右到左查找的指针
        while (i < j) {
            // 从右边先找，直到找到小于基准数的数
            while (i < j && nums[j] >= base) j--;
            nums[i] = nums[j];
            // 从左向右找，直到找到大于基准数的数
            while (i < j && nums[i] <= base) i++;
            nums[j] = nums[i];
        }
        nums[i] = base;
        quickSort(nums, 0, i-1);
        quickSort(nums, i+1, right);
    }

时间复杂度：O(nlogn)
稳定性：不稳定。比如 [7,6,7,2,9,8] 首先选取7为基准点，从有向左找出小于7的数，j停留在2位置；从左边找大于7的数，i停留在2位置，然后将base和 i、j 共同指向的数交换，此时第一个7就跑到第二个7后面了，因此不稳定。