排序算法整理

先把常用排序算法进行分类：

插入排序	直接插入排序、折半插入排序、希尔排序
交换排序	冒泡排序、快速排序
选择排序	简单选择排序、堆排序
归并排序
基数排序

下面我们一个一个来看：

1.直接插入排序
进行n-1趟排序，每趟把一个元素插入到前面已经排好序的序列中，其时间复杂度为O(n²)，并且由于判断要插入的条件是<而不是<=，所以这是稳定的算法

public void insertSort(int[] a, int n) {
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (a[i] < a[j]) {
                    int temp = a[i];
                    for (int k = i; k > j; k--) {
                        a[k] = a[k - 1];
                    }
                    a[j] = temp;
                    break;
                }
            }
        }
}

2.折半插入排序
进行n-1趟排序，每趟排序在查找插入位置的时候用到了折半查找法，所以总的查找时间复杂度为O(nlog₂n)，但由于移动元素的时间复杂度没有变，所以此算法的时间复杂度仍为O(n²)，同时它也是一个稳定的排序算法

public void binaryInsertSort(int[] a, int n) {
        int low, high, mid = 0;
        for (int i = 1; i < n; i++) {
            low = 0;
            high = i - 1;
            while (low <= high) {
                mid = (low + high) / 2;
                if (a[mid] > a[i]) {
                    high = mid - 1;
                }
                if (a[mid] < a[i]) {
                    low = mid + 1;
                }
                if (a[mid] == a[i]) {
                    break;
                }
            }
            int temp = a[i];
            if (a[mid] <= temp) {
                for (int k = i; k > mid + 1; k--) {
                    a[k] = a[k - 1];
                }
                a[mid + 1] = temp;
            }
            if (a[mid] > temp) {
                for (int k = i; k > mid; k--) {
                    a[k] = a[k - 1];
                }
                a[mid] = temp;
            }
        }
}

3.希尔排序
步长d=n/2，步长相同的元素为一组，分别在组内进行直接插入排序，然后d=d/2，再进行上述步骤……直到d=1，此时元素已经基本有序，然后再总体进行一次直接插入排序，这样元素移动次数会小一些。最坏情况下，时间复杂度为O(n²)。当相同关键字的元素被划分到不同组时，可能改变它们的顺序，所以该算法是不稳定的

public void shellSort(int[] a, int n) {
        int d = n / 2;
        while (d >= 1) {
            for (int i = 0; i < d; i++) {
                int j = i;
                while (j < n) {
                    for (int k = i; k < j; k += d) {
                        if (a[k] > a[j]) {
                            int temp = a[j];
                            for (int p = j; p > k; p -= d) {
                                a[p] = a[p - d];
                            }
                            a[k] = temp;
                            break;
                        }
                    }
                    j += d;
                }
            }
            d /= 2;
        }
}

4.冒泡排序
进行n-1趟排序，从前往后通过两两交换把大的元素移到后面，这样每一趟都会有一个元素被放到正确的位置上，时间复杂度为O(n²)，是稳定的算法

public void bubbleSort(int[] a, int n) {
        int temp;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (a[j] > a[j + 1]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
}

5.快速排序
利用了分治思想，每趟排序以序列中第一个元素为基准，将比它小和比它大的元素分别划分到它的两边，这样基准元素就放在了正确的位置上。递归地对它的左右两个序列继续进行排序，最后所有元素就都有序了。平均情况下时间复杂度为O(nlog₂n)，当元素基本有序时会出现最坏情况，时间复杂度为O(n²)。其空间复杂度最坏情况下为O(n)，平均情况下为O(log₂n)。在交换区间的过程中相同关键字元素的顺序可能会发生变化，所以它是不稳定的。

public void quickSort(int[] a, int low, int high) {
        if (low < high) {
            int temp = a[low];
            int tempLow = low, tempHigh = high;
            while (low < high) {
                while (low < high && a[high] >= temp) high--;
                a[low] = a[high];
                while (low < high && a[low] <= temp) low++;
                a[high] = a[low];
            }
            a[low] = temp;
            quickSort(a, tempLow, low - 1);
            quickSort(a, low + 1, tempHigh);
        }
}

6.简单选择排序
进行n-1趟排序，每次从剩余序列中选择一个最小的与当前位置上的元素交换，时间复杂度为O(n²)，在交换位置的过程中可能会改变相同大小元素的相对顺序，所以是不稳定的算法

public void selectSort(int[] a, int n){
        for(int i = 1; i < n; i++){
            int min = a[i];
            int minIndex = i;
            for(int j = i+1; j <= n; j++){
                if(a[j] < min){
                    min = a[j];
                    minIndex = j;
                }
            }
            a[minIndex] = a[i];
            a[i] = min;
}

7.堆排序
将所有非叶结点进行一次向下调整，建立大根堆，然后不断把堆顶元素与堆底元素交换位置，堆容量减一，向下调整堆顶元素，则每次都有一个元素放到正确位置上，当堆容量变为1时排序完成，时间复杂度为O(nlog₂n)，因为靠前的元素反而先被输出到后面，所以是不稳定的算法

//堆排序
public void heapSort(int[] a, int n) {
    buildMaxHeap(a, n);
    for (int i = 1; i < n; i++) {
        int temp = a[1];
        a[1] = a[n - i + 1];
        a[n - i + 1] = temp;
        adjustDown(a, 1, n - i);
    }
}

//建立大根堆
public void buildMaxHeap(int[] a, int n) {
    for (int i = n / 2; i > 0; i--) {
        adjustDown(a, i, n);
    }
}

//向下调整
public void adjustDown(int[] a, int k, int n) {
    for (int i = k * 2; i <= n; i *= 2) {
        if (i < n && a[i] < a[i + 1]) i++;
        if (a[k] >= a[i]) break;
        else {
            int temp = a[k];
            a[k] = a[i];
            a[i] = temp;
            k = i;
        }
    }
}

8.归并排序
递归划分，直到每组只剩下一个元素，重点是合并算法，注意是将两个有序序列合并，用到了辅助数组，二路归并排序时间复杂度为O(nlog₂n)，因为合并算法不改变相同大小元素的相对顺序，所以为稳定算法

//归并排序
public void mergeSort(int[] a, int low, int high){
    if(low < high){
        int mid = (low+high)/2;
        mergeSort(a, low, mid);
        mergeSort(a, mid+1, high);
        merge(a,low,mid,high);
    }
}

//合并操作
public void merge(int[] a, int low, int mid, int high) {
    int[] b = new int[high-low+2];
    int k = 1,i = low,j = mid+1;
    while(i <=mid&&j<=high){
        if(a[i]<=a[j]){
            b[k++] = a[i];
            i++;
        }else {
            b[k++] = a[j];
            j++;
        }
    }
    while(i <= mid)b[k++] = a[i++];
    while(j <= high)b[k++] = a[j++];
    i = low;
    j = 1;
    while(i <= high){
        a[i++] = b[j++];
    }
}

9.基数排序
r为最大基数，d为位数，借助r+1个队列，从后往前进行d趟排序，时间复杂度为O(d(n+r))，为稳定算法

public void radixSort(int[][] a, int r, int d, int n) {
    LinkedList<int[]>[] queues = new LinkedList[r + 1];
    for (int i = 0; i <= r; i++) {
        queues[i] = new LinkedList<>();
    }
    for (int i = d; i > 0; i--) {
        for (int j = 1; j <= n; j++) {
            int k = a[j][i];
            queues[k].add(a[j]);
        }
        for (int j = 0, k = 1; j <= r; j++) {
            while (!queues[j].isEmpty()) {
                a[k++] = queues[j].poll();
            }
        }
    }
}