排序算法

1.冒泡排序

实现原理：

1. 数组从从低位到高位，相邻的两位之间比大小，将值较大的放在后边，
   值小的放在前一位，最终数组中最大值移动到了最高位；
2. 去除已排好序的高位，数组的前几位（未排好序）继续步骤1的操作，最终实现由小到大排序。

时间复杂度：O(n2)

Java代码实现

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5,4,1,3};
        bubbleSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static void bubbleSort(int[] arr){
        if (arr == null || arr.length < 2){
            return;
        }else {
            for (int end = arr.length-1;end > 0;end--){
                for (int i = 0; i < end; i++) {
                    if(arr[i] > arr[i+1]){
                        swap(arr,i,i+1);
                    }
                }
            }
        }
    }
    public static void swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

结果：

1
3
4
5

2.选择排序

实现原理：

1. 设置最小值索引minIndex为最低位的索引，数组从最小位以此与该索引值对比，如果小于该值，将该索引替换minIndex，最后找到整个数组的最小值，将最低位与最小值替换；
2. 除去已排好序的前几位，数组后部分重复步骤1，实现有小到大排序。

时间复杂度：O(n2)

Java代码实现

public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = {5,4,1,3};
        selectionSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static void selectionSort(int[] arr){
        if (arr == null || arr.length < 2){
            return;
        }else {
            for (int i = 0; i < arr.length - 1; i++) {
                int minIndex = i;
                for (int j = i + 1; j < arr.length; j++) {
                    minIndex = arr[j] < arr[minIndex] ? j : minIndex;
                }
                swap(arr, i, minIndex);
            }
        }
    }
    public static void swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

结果：

1
3
4
5

3.插入排序

实现原理：
类似扑克牌排序，从第二位开始，与前面的值对比，进行排序；然后第三位再与前面对比，如小于前面的值就交换位置，一直遇到比该值小的值结束对比；然后再用第四位…

时间复杂度：O(n2)

Java实现代码

public class InsertionSort {
    public static void main(String[] args) {
        int[] arr = {5,4,1,3};
        insertionSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static void insertionSort(int[] arr){
        if (arr == null || arr.length < 2){
            return;
        }else {
            for (int i = 1; i < arr.length; i++) {
                for (int j = i ; j > 0;j--) {
                    if (arr[j] < arr[j-1]){
                        swap(arr,j,j-1);
                    }else {
   //                   return; 错误，直接跳出函数
                        break;//跳出一层for循环
                    }

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

结果：

1
3
4
5

4.归并排序

实现原理：
先进行递归，将数组从中间分开分为两部分，将两部分利用外排的方式排序。

时间复杂度：
T(N) = 2T(N/2) + O(N)
由master方程得：O(N*logN)
空间复杂度：
O(N)

注：
master 公式计算形如T(N) = a*T(N/b) + O(N^d)的复杂度
log(b,a) > d -> 复杂度为O(N^log(b,a))
log(b,a) = d -> 复杂度为O(N^d * logN)
log(b,a) < d -> 复杂度为O(N^d)
log(b,a)表示以b为底数，a为真数

Java实现代码

public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {5,4,1,3};
        mergeSort(arr,0,arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static void mergeSort(int[] arr,int L,int R){
        if (arr == null || arr.length < 2){
            return;
        }
        if (L == R){
            return;
        }
        int mid = L + (R - L)/2;
//        int mid = L + ((R - L) >> 1);
        mergeSort(arr,L,mid);//T(N/2)
        mergeSort(arr,mid+1,R);//T(N/2)
        merge(arr,L,mid,R);//O(N)

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

结果：

1
3
4
5