排序算法（java）

• 1. 冒泡排序
• 2. 选择排序
• 3. 插入排序
• 4. 归并排序
• 5. 快速排序
• 6. 堆排序

1. 冒泡排序

对序号为0~n-1的元素进行比较：将输入的前一个元素和后一个元素做比较，如果前一个大于后一个，就交换这两个元素，这样经过一轮循环后，就会将最大的元素换到最后一个位置，因此下一次循环只需要对0~n-2的元素进行比较,以此类推，每一次处理好一个数，因此时间复杂度为O(n*n)。其代码如下：

    public static void bubbleSort(int[] arr) {
        if (arr.length == 1 || arr == null) {
            return;
        }
        for (int i = arr.length - 1; i > 0; i--) {
            for (int j = 0; j < i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                }
            }
        }
    }
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

上面的算法即使在最好的情况下，时间复杂度也为O(n*n),其实在在排序的过程中，如果没有交换的操作那么就意味着排序完成了，因此可以添加一个变量判断是否有无排序操作，这样可以改进算法，在最好情况下时间复杂度为O(n),代码如下：

public static void bubbleSort(int[] arr) {
        boolean flag=true;
        if (arr.length == 1 || arr == null) {
            return;
        }
        for (int i = arr.length - 1&&flag; i > 0; i--) {
            flag=false;
            for (int j = 0; j < i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                    flag=true;
                }
            }
        }

冒泡排序的优势是：可以检测输入序列是否已经是有序的。
2. 选择排序
首先对序号为0~N-1进行处理：令N-1为序列中的最大值max，然后进行遍历，如果有max的，就用当前位置的值和max交换，这样经过一轮循环后，最大值就会被找到，第二次循环只需要处理0~N-2的数，一次类推，因此，选择排序也是每次处理好一个数，时间复杂度为O(n*n).代码如下：

    public static void selectSort(int[] arr) {
        if (arr.length == 1 || arr == null) {
            return;
        }
        for (int i = arr.length - 1; i > 0; i--) {
            int max = i;
            for (int j = i - 1; j > 0; j--) {
                if (arr[j] > arr[max]) {
                    swap(arr, i, j);
                }
            }
        }
    }

选择排序的优点是：容易实现，原地排序（不需要额外的存储空间）
3. 插入排序
插入排序重复如下过程：每次从输入的数据中移除一个元素，并将其插入已经排序序列的正确位置，直到所有输入的元素都插入有序序列中。经过k次迭代后，前k+1个元素已经排好序。

public static void insertSort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            int cur=arr[i];
            int preIndex=i-1;
            while (preIndex>=0&&arr[preIndex]>cur) {
                arr[preIndex+1]=arr[preIndex];
                preIndex--;
            }
            arr[preIndex+1]=cur;
        }
    }

插入排序的效率与数据状况有很大关系，如果数据是相对有序的可以使用插入排序。
4. 归并排序
归并排序是分治排序的一个例子，其算法的思想是将左右两边排好序，然后再进行将两个序列排成一个序列。合并时是新建一个数组，然后将左右两边的序列复制到这个数组中，有两个指针p1,p2分别指向这两个子序列，如果arr[p1] < arr[p2]，那么就arr[p1] 填入这个新数组，并且经p1指向下一个数，如果arr[p1] >arr[p2]，那么就arr[p2] 填入这个新数组，并且经p2指向下一个数，直到遍历完某个子序列，然后将另一个子序列剩余的部分复制到新数组中。对左右两边的序列进行排序时，将其视作子问题进行递归。
递归算法的时间复杂度的计算：
T(N)=aT(n/b)+O(n^d)，其中n/b是指子过程的样本量，O(n^d)为除去调用子过程之外剩下的过程的时间复杂度。若递归过程满足这个表达式，则时间复杂度为：
1) log(b,a) > d ,复杂度为O(N^log(b,a))
2) log(b,a) = d , 复杂度为O(N^d * logN)
3) log(b,a) < d , 复杂度为O(N^d)

public static void mergeSort(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        int mid = left + ((right - left) >> 1);
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }

public static void merge(int[] arr, int left, int mid, int right) {
        int[] help = new int[right - left + 1];
        int i = 0;
        int p1 = left;
        int p2 = mid + 1;
        while (p1 <= mid && p2 <= right) {
            help[i++] = (arr[p1] < arr[p2]) ? arr[p1++] : arr[p2++];
        }
        while (p1 <= mid) {
            help[i++] = arr[p1++];
        }
        while (p2 <= right) {
            help[i++] = arr[p2++];
        }
        for (int j = 0; j < help.length; j++) {
            arr[left + j] = help[j];
        }
    }