排序（用java实现）

running up that hill2024-11-09 18:09

排序

排序的概念及引用

排序的概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i] = r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。

内部排序：数据元素全部放在内存中的排序。

外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求在内外存之间移动数据的排序。

常见的排序算法

常见排序算法的实现

插入排序

基本思想：

直接插入排序是一种简单的插入排序算法，其基本思想是：

把待排序的记录按照其关键码值的大小逐个插入到有个已经排好序的有序序列中，直到所有的记录插入完为止，得到新的有序序列。实际中玩扑克牌，就用了插入排序的思想。

直接插入排序

当插入第 i (i>=1) 个元素时，前面的array[0],array[1],...,array[i-1] 已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],...的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移

java 复制代码 
    /**
     * 时间复杂度为：O(N^2)
     *      最坏情况下：逆序的   5 4 3 2 1
     *      最好情况下：本身就是有序的  1 2 3 4 5 O(n)
     *              如果数据越有序，直接插入排序越快
     * 空间复杂度：O(1)
     * 稳定性：稳定的排序
     *      本身如果是一个稳定的排序，那么可以实现为不稳定的
     *      但是 如果一个 排序 本身就是不稳定，能实现为稳定的排序吗？
     * @param array
     */
public static void insertSort(int[] array){
    for (int i = 1; i < array.length; i++) {
        int tmp = array[i];
        int j = i - 1;
        for (; j >= 0; j--) {
            if(array[j] > tmp){
                array[j+1] = array[j];
            }else {
                break;
            }
        }
        array[j+1] = tmp;
    }
}
java 复制代码 
public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.insertSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
java 复制代码 
public static void main(String[] args) {
    testSimple();
}

时间复杂度为：1+2+3+4+...+N-1 = ( 1 + ( N − 1 ) ∗ ( N − 1 ) ) 2 \frac{(1+(N-1)*(N-1))}{2} 2(1+(N−1)∗(N−1)) = N 2 − N 2 \frac{N^2-N}{2} 2N2−N ，所以为O( N 2 N^2 N2)

直接插入排序的特性总结：

  1. 元素集合越接近越有序，直接插入排序算法的时间效率越高
  2. 时间复杂度： O ( N 2 ) O(N^2) O(N2)
  3. 空间复杂度： O ( 1 ) O(1) O(1)，它是一种稳定的排序算法
  4. 稳定性：稳定

希尔排序(缩小增量排序)

希尔排序又称缩小增量法。希尔排序法的基本思想：先选定一个整数，把待排序文件中所有记录分成多个组，所有距离为这个整数的记录在同一组内，并对每一组内的记录进行排序。然后再取，重复上述分组和排序的工作。当这个数=1时，所有记录在同一组内排好序。

java 复制代码 
/**
  * 不稳定的
  * 时间复杂度：n^1.3 - n^1.5
  * 空间复杂度：O(1)
  * @param array
  */
public static void shellSort(int[] array){
    int gap = array.length;
    while(gap > 1){
        gap /= 2;
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i - gap;
            for (; j >= 0; j = j - gap) {
                if(array[j] >= tmp){
                    array[j+gap] = array[j];
                }else {
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }
}
java 复制代码 
public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.shellSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
java 复制代码 
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

希尔排序的特性总结：

  1. 希尔排序是对直接插入排序的优化
  2. 当gap > 1时都是预排序，目的是让数组更接近于有序，当gap == 1时，数组已经接近有序的了，这样就会很快，这样整体而言，可以达到优化的效果。
  3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书中的希尔排序的时间复杂度都不固定：
    《数据结构(C语言版)》--- 严蔚敏

    《数据结构-用面向对象方法与C++描述》--- 殷人昆

    因为我们的gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照：O(n1.25)到O(1.6*n1.25)来算
  4. 稳定性：不稳定

选择排序

基本思想：

每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

直接选择排序

  • 在元素集合array[i] ~ array[i-1]中选择关键码最小(或最大)的元素
  • 若它不是这组元素中最后一个元素(或第一个元素)，则将它与这组元素中的最后一个(第一个)元素交换
  • 在剩余的array[i] ~ array[n-2](array[i+1] ~ array[n-1])集合中，重复上述步骤，直到集合剩一个元素。
java 复制代码 
public static void selectSort(int[] array){
    for (int i = 0; i < array.length; i++) {
        int minIndex = i;
        for (int j = i+1; j < array.length; j++) {
            if(array[j] < array[minIndex]){
                minIndex = j;
            }
        }
        swap(array,i,minIndex);
    }
}

private static void swap(int[] array, int j, int i) {
    int tmp = array[j];
    array[j] = array[i];
    array[i] = tmp;
}
java 复制代码 
public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.selectSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

可以继续改进：

java 复制代码 
/**
 * 选择排序：
 * 时间复杂度：O(N^2)
 *      和数据是否有序无关
 * 空间复杂度：O(1)
 * 稳定性：不稳定的排序
 * @param array
 */
public static void selectSort(int[] array){
    int left = 0;
    int right = array.length - 1;
    while(left < right){
        int minIndex = left;
        int maxIndex = left;
        for (int i = left+1; i < right; i++) {
            if(array[minIndex] > array[i]){
                minIndex = i;
            }
            if(array[maxIndex] < array[i]){
                maxIndex = i;
            }
        }
        swap(array,left,minIndex);
        if(maxIndex == left){
            maxIndex = minIndex;
        }
        swap(array,right,maxIndex);
        left++;
        right--;
    }
}

private static void swap(int[] array, int j, int i) {
    int tmp = array[j];
    array[j] = array[i];
    array[i] = tmp;
}
java 复制代码 
public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.selectSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

总结：

  1. 直接选择排序好理解，但是效率不是很好，实际中很少使用
  2. 时间复杂度：O(N2)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

堆排序

堆排序(HeapSort)即利用堆的思想进行排序，是指利用堆积树(堆)这种数据结构所设计的一种排序算法，它是选择排序的一种，它是通过堆来进行选择数据。总共分为两个步骤：

  1. 建堆
    • 升序：建大堆
    • 降序：建小堆
  2. 利用堆删除思想来进行排序

建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。

java 复制代码 
/**
* 堆排序
* 时间复杂度：O(n * logN)
* 空间复杂度：O(1)
* 稳定性：不稳定
* @param array
*/
public static void heapSort(int[] array){
   int end = array.length - 1;
   createHeap(array);
   while(end >= 0){
       swap(array, end, 0);
       siftDown(array, 0, end);
       end--;
   }

}

public static void createHeap(int[] array) {
   for (int parent = (array.length - 2) / 2; parent >= 0; parent--) {
       siftDown(array, parent, array.length);
   }
}

/**
*
* @param array
* @param parent   每棵子树调整的根节点
* @param length    每棵子树调整的结束结点
*/
public static void siftDown(int[] array,int parent, int length){
   int child = parent * 2 + 1;
   while(child < length){
       if(child + 1 < length && array[child + 1] > array[child]){
           child++;
       }
       if(array[child] > array[parent]){
           swap(array,parent,child);
           parent = child;
           child = parent * 2 + 1;
       }else{
           break;
       }
   }
}
java 复制代码 
public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.heapSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

时间复杂度为：排序之前需创建大根堆或小根堆，时间复杂度为O(N)，向下调整加每个结点的时间复杂度为：O(N * l o g 2 N log_2N log2N)，所以堆排序的时间复杂度为：O(N) + O(N * l o g 2 N log_2N log2N) = O(N * l o g 2 N log_2N log2N) ，详见堆排序这篇文章

总结：

  1. 堆排序使用堆来选数，效率高了很多
  2. 时间复杂度：O(N * l o g 2 N log_2N log2N)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

交换排序

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

冒泡排序

java 复制代码 
public static void  bubbleSort(int[] array){
    for (int i = 0; i < array.length - 1; i++) {
        for (int j = 0; j < array.length-1; j++) {
            if(array[j] > array[j+1]){
                swap(array,j,j+1);
            }
        }
    }
}
java 复制代码 
public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.bubbleSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

可以加以改进：

java 复制代码 
/**
 * 冒泡排序：
 * 时间复杂度：【讨论 没有优化的情况下，也就是 没有下方的boolean元素和 -i操作】
 *              O(N^2)
 *              优化以后 可能会达到O(N)
 * 空间复杂度：O(1)
 * 稳定性：稳定的排序
 * @param array
 */
public static void  bubbleSort(int[] array){
    for (int i = 0; i < array.length - 1; i++) {
        boolean flag = false;
        for (int j = 0; j < array.length-1-i; j++) {
            if(array[j] > array[j+1]){
                swap(array,j,j+1);
                flag = true;
            }
        }
        if(!flag){
            break;
        }
    }
}

总结：

  1. 冒泡排序是一种非常容易理解的排序
  2. 时间复杂度：O(N2)
  3. 空间复杂度：O(1)
  4. 稳定性：稳定

快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任待取元素序列的某元素作为基准值，按照该序列将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后对左右子序列重复该过程，直到所有元素都排列在相应的位置上为止。

java 复制代码 
public static void quickSort(int[] array){
    quick(array,0,array.length - 1);
}

//假设按照升序对array数组中[left, right]区间中的元素进行排序
public static void quick(int[] array, int left, int right){
    if(left >= right){
        return;
    }

    //按照基准值对array数组的[left, right]区间中的元素进行划分
    int div = partion(array, left, right);

    //划分成功后以div为边界形成了左右两部分[left, div-1]和[div+1, right]
    //递归排[left, div-1]
    quick(array, left, div-1);

    //递归排[div+1, right]
    quick(array,div+1, right);
}

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，所以写递归框架可想想二叉树前序遍历规则即可快速写出来，后续只需分析如何按照基准值来对区间中数据进行划分的方式即可。

将区间按照基准值划分为左右两部分的常见方式有：

  1. Hoare版

java 复制代码 
private static void swap(int[] array, int j, int i) {
    int tmp = array[j];
    array[j] = array[i];
    array[i] = tmp;
}
/**
     * 时间复杂度：
     *          最坏情况：当数据指定的是1 2 3 4 ......有序的情况下，确实是O(n^2)
     *                                9 8 7 6 ......
     *          最好情况：O(n * logN)
     * 空间复杂度：
     *      最坏情况下：O(N)
     *      最好情况下：O(logN)
     * 稳定性：
     *      不稳定
     * @param array
     */
public static void quickSort(int[] array){
    quick(array,0,array.length - 1);
}

//假设按照升序对array数组中[left, right]区间中的元素进行排序
public static void quick(int[] array, int left, int right){
    if(left >= right){
        return;
    }

    //按照基准值对array数组的[left, right]区间中的元素进行划分
    int div = partition(array, left, right);

    //划分成功后以div为边界形成了左右两部分[left, div-1]和[div+1, right]
    //递归排[left, div-1]
    quick(array, left, div-1);

    //递归排[div+1, right]
    quick(array,div+1, right);
}

public static int partition(int[] array, int left, int right){
    int tmp = array[left];
    int tmpLeft = left;
    while(left < right){
        while(left < right && array[right] >= tmp){
            right--;
        }
        while(left < right && array[left] <= tmp){
            left++;
        }
        swap(array,left,right);
    }
    swap(array,left,tmpLeft);
    return left;
}
java 复制代码 
public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.quickSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]




  1. 挖坑法
java 复制代码 
public static void quickSort(int[] array){
    quick(array,0,array.length - 1);
}

//假设按照升序对array数组中[left, right]区间中的元素进行排序
public static void quick(int[] array, int left, int right){
    if(left >= right){
        return;
    }

    //按照基准值对array数组的[left, right]区间中的元素进行划分
    int div = partition(array, left, right);

    //划分成功后以div为边界形成了左右两部分[left, div-1]和[div+1, right]
    //递归排[left, div-1]
    quick(array, left, div-1);

    //递归排[div+1, right]
    quick(array,div+1, right);
}

public static int partition(int[] array, int left, int right){
    int tmp = array[left];
    while(left < right){
        while(left < right && array[right] > tmp){
            right--;
        }
        array[left] = array[right];
        while(left < right && array[left] < tmp){
            left++;
        }
        array[right] = array[left];
    }
    array[left] = tmp;
    return left;
}
java 复制代码 
public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.quickSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]
  1. 前后指针
java 复制代码 
public static void quickSort(int[] array){
    quick(array,0,array.length - 1);
}

//假设按照升序对array数组中[left, right]区间中的元素进行排序
public static void quick(int[] array, int left, int right){
    if(left >= right){
        return;
    }

    //按照基准值对array数组的[left, right]区间中的元素进行划分
    int div = partition(array, left, right);

    //划分成功后以div为边界形成了左右两部分[left, div-1]和[div+1, right]
    //递归排[left, div-1]
    quick(array, left, div-1);

    //递归排[div+1, right]
    quick(array,div+1, right);
}

public static int partition(int[] array, int left, int right){
    int prev = left;
    int cur = left+1;
    int key = left;
    while(cur <= right){
        if(array[cur] < array[key] && array[++prev] != array[cur]){
            swap(array,prev,cur);
        }
        cur++;
    }
    swap(array,prev,key);
    return left;
}
java 复制代码 
public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.quickSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

快速排序的优化

由于快排使用递归，若待排序列是有序的或无序的，所开辟的栈是需要很多的，空间复杂度达到O(N)，所以为了减少栈的开辟，提高空间的利用率和时间成本，对此进行了优化

  1. 三数取中选key

java 复制代码 
public static void quickSort(int[] array){
    quick(array,0,array.length - 1);
}

public static void quick(int[] array, int left, int right){
    if(left >= right){
        return;
    }

    int midIndex = getMiddleNum(array,left,right);
    swap(array,midIndex,left);
    int div = partition(array, left, right);

    quick(array, left, div-1);

    quick(array,div+1, right);
}
public static int partition(int[] array, int left, int right){
    int tmp = array[left];
    while(left < right){
        while(left < right && array[right] > tmp){
            right--;
        }
        array[left] = array[right];
        while(left < right && array[left] < tmp){
            left++;
        }
        array[right] = array[left];
    }
    array[left] = tmp;
    return left;
}
java 复制代码 
public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.quickSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]
  1. 递归到小的子区间时，可以考虑使用插入排序
    对于排序，越排是越有序的，而且对于二叉树来讲，越到后面结点越集中，所需开辟的空间越多，但是更有序，对于有序的序列，直接插入排序是最快的。
java 复制代码 
public static void quickSort(int[] array){
   quick(array,0,array.length - 1);
}

public static void quick(int[] array, int left, int right){
   if(left >= right){
       return;
   }

   if(right - left + 1 <= 7){
       insertSortRange(array,left,right);
       return;
   }

   int midIndex = getMiddleNum(array,left,right);
   swap(array,midIndex,left);
   int div = partition(array, left, right);

   quick(array, left, div-1);

   quick(array,div+1, right);
}

private static void insertSortRange(int[] array, int left, int right) {
   for (int i = left+1; i < right; i++) {
       int tmp = array[i];
       int j = i-1;
       for (; j >= left; j--) {
           if(array[j] > array[j+1]){
               array[j+1] = array[j];
           }else{
               array[j+1] = tmp;
               break;
           }
       }
       array[j+1] = tmp;
   }
}

public static int partition(int[] array, int left, int right){
   int tmp = array[left];
   while(left < right){
       while(left < right && array[right] > tmp){
           right--;
       }
       array[left] = array[right];
       while(left < right && array[left] < tmp){
           left++;
       }
       array[right] = array[left];
   }
   array[left] = tmp;
   return left;
}
java 复制代码 
public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.quickSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

快速排序非递归

java 复制代码 
public static void quickSort(int[] array){
    quickNor(array,0,array.length - 1);

}
public static void quickNor(int[] array, int left, int right){
    Stack<Integer> stack = new Stack<>();
    int div = partition(array,left,right);
    if(div > left + 1){
        stack.push(left);
        stack.push(div-1);
    }
    if(div < right-1){
        stack.push(div+1);
        stack.push(right);
    }
    while(!stack.isEmpty()){
        right = stack.pop();
        left = stack.pop();
        div = partition(array,left,right);
        if(div > left + 1){
            stack.push(left);
            stack.push(div-1);
        }
        if(div < right-1){
            stack.push(div+1);
            stack.push(right);
        }
    }
}
public static int partition(int[] array, int left, int right){
    int tmp = array[left];
    while(left < right){
        while(left < right && array[right] > tmp){
            right--;
        }
        array[left] = array[right];
        while(left < right && array[left] < tmp){
            left++;
        }
        array[right] = array[left];
    }
    array[left] = tmp;
    return left;
}
java 复制代码 
public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.quickSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的
  2. 时间复杂度：O(N* l o g 2 N log_2N log2N)
  3. 空间复杂度：O( l o g 2 N log_2N log2N)
  4. 稳定性：不稳定

归并排序

基本思想

归并排序(MEGRE-SORT)是建立在归并操作上的一种有效的排序算法，该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列：即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路合并。归并排序核心步骤：分解和合并

归并排序

java 复制代码 
public static void mergeSort(int[] array){
    merge(array,0,array.length-1);
}

private static void merge(int[] array, int left, int right) {
    if(left >= right){
        return;
    }
    int mid = (left + right) / 2;
    merge(array,left,mid);
    merge(array,mid+1,right);
    
}
java 复制代码 
/**
 * 归并排序：
 * 时间复杂度：O(N * logN)
 * 空间复杂度：O(N)
 * 稳定性：稳定
 * @param array
 */
public static void mergeSort(int[] array){
    mergeSortTmp(array,0,array.length-1);
}

private static void mergeSortTmp(int[] array, int left, int right) {
    if(left >= right){
        return;
    }
    int mid = (left + right) / 2;
    mergeSortTmp(array,left,mid);
    mergeSortTmp(array,mid+1,right);

    merge(array,left,right,mid);

}

private static void merge(int[] array, int left, int right, int mid) {
    int s1 = left;
    //int e1 = mid;
    int s2 = mid+1;
    //int e2 = right;
    int k = 0;
    int len = right - left + 1;
    int tmp[] = new int[len];
    while(s1 <= mid && s2 <= right){
        if(array[s1] > array[s2]){
            tmp[k++] = array[s2++];
        }else{
            tmp[k++] = array[s1++];
        }
    }
    while(s1 <= mid){
        tmp[k++] = array[s1++];
    }
    while(s2 <= right){
        tmp[k++] = array[s2++];
    }
    for (int i = 0; i < tmp.length; i++) {
        array[i+left] = tmp[i];
    }
}
java 复制代码 
public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.mergeSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

归并排序的非递归

java 复制代码 
public static void mergeSortNor(int[] array){
    int gap = 1;
    while(gap < array.length){
        gap = gap * 2;
        for (int i = 0; i < array.length; i = i+gap*2) {
            int left = i;
            int right = left + gap - 1;
            if(right >= array.length){
                right = array.length-1;
            }
            int mid = (left + right) / 2;
            if(mid >= array.length){
                mid = array.length-1;
            }

            merge(array,left,right,mid);
        }
    }
}

private static void merge(int[] array, int left, int right, int mid) {
    int s1 = left;
    //int e1 = mid;
    int s2 = mid+1;
    //int e2 = right;
    int k = 0;
    int len = right - left + 1;
    int tmp[] = new int[len];
    while(s1 <= mid && s2 <= right){
        if(array[s1] > array[s2]){
            tmp[k++] = array[s2++];
        }else{
            tmp[k++] = array[s1++];
        }
    }
    while(s1 <= mid){
        tmp[k++] = array[s1++];
    }
    while(s2 <= right){
        tmp[k++] = array[s2++];
    }
    for (int i = 0; i < tmp.length; i++) {
        array[i+left] = tmp[i];
    }
}
java 复制代码 
public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.mergeSortNor(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

总结：

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多是解决在磁盘中的外排序问题。
  2. 时间复杂度：O(N* l o g 2 N log_2N log2N)
  3. 空间复杂度：O(N)
  4. 稳定性：稳定

海量数据的排序问题

外部排序：排序过程需要在磁盘等外部存储进行的排序

前提：内存只有1G，需要排序的数据有100G

因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序

  1. 先把文件切分成200份，每个512M
  2. 分别对512M排序，因为内存已经可以放得下，所以任意排序方式都可以
  3. 进行2路归并，同时对200份有序文件做归并过程，最终结果就有序了

排序算法复杂度及稳定性分析

排序方法 最好 平均 最坏 空间复杂度 稳定性
冒泡排序 O(N)(优化以后)没有优化为O(N2) O(N2) O(N2) O(1) 稳定
插入排序 O(N) O(N2) O(N2) O(1) 稳定
选择排序 O(N2) O(N2) O(N2) O(1) 不稳定
希尔排序 O(N) O(N1.3~N1.5) O(N2) O(1) 不稳定
堆排序 O(N * l o g 2 N log_2N log2N) O(N * l o g 2 N log_2N log2N) O(N * l o g 2 N log_2N log2N) O(1) 不稳定
快速排序 O(N * l o g 2 N log_2N log2N) O(N * l o g 2 N log_2N log2N) O(N2) O( l o g 2 N log_2N log2N)~O(N) 不稳定
归并排序 O(N * l o g 2 N log_2N log2N) O(N * l o g 2 N log_2N log2N) O(N * l o g 2 N log_2N log2N) O(N) 稳定

其他非基于比较排序

  1. 计数排序
    思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。操作步骤：

    1. 统计相同元素出现次数
    2. 根据统计的结果将序列回收到原来的序列中

    计数排序的特性总结：

    1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限
    2. 时间复杂度：O(Max(N,范围))
    3. 空间复杂度：O(范围)
    4. 稳定

  2. 基数排序

  3. 桶排序

选择题

1.快速排序算法是基于()的一个排序算法。

A：分治法 B：贪心法 C：递归法 D：动态规划法

答案：A

没有递归法这种说法

2.对记录（54,38,96,23,15,72,60,45,83）进行从小到大的直接插入排序时，当把第8个记录45插入到有序表时，为找到插入位置需比较()次？（采用从后往前比较）

A: 3 B: 4 C: 5 D: 6

答案：C

3.设一组初始记录关键字序列为(65,56,72,99,86,25,34,66)，则以第一个关键字65为基准而得到的一趟快速排序结果是（）

A: 34，56，25，65，86，99，72，66 B: 25，34，56，65，99，86，72，66

C: 34，56，25，65，66，99，86，72 D: 34，56，25，65，99，86，72，66

答案： A

4.以下排序方式中占用O(n)辅助存储空间的是()

A: 简单排序 B: 快速排序 C: 堆排序 D: 归并排序

答案：D

5.4.下列排序算法中稳定且时间复杂度为O(n^2)的是()

A: 快速排序 B: 冒泡排序 C: 直接选择排序 D: 归并排序

答案：B

6.关于排序，下面说法不正确的是()

A: 快排时间复杂度为O(N*logN)，空间复杂度为O(logN)

B: 归并排序是一种稳定的排序,堆排序和快排均不稳定

C: 序列基本有序时，快排退化成 "冒泡排序"，直接插入排序最快

D: 归并排序空间复杂度为O(N), 堆排序空间复杂度的为O(logN)

答案：D

这篇文章先了解到这，希望对大家有帮助，多谢阅读！！！

相关推荐
纪元A梦24 分钟前
贪心算法应用：顶点覆盖问题详解
java·算法·贪心算法
bing_1581 小时前
Spring MVC 中Model, ModelMap, ModelAndView 之间有什么关系和区别？
java·spring·mvc
268572591 小时前
JVM 监控
java·开发语言·jvm
promise5241 小时前
JVM之jcmd命令详解
java·linux·运维·服务器·jvm·bash·jcmd
曼岛_1 小时前
[Java实战]Spring Boot 静态资源配置（十三）
java·开发语言·spring boot
篱笆院的狗1 小时前
MySQL 中如何进行 SQL 调优？
java·sql·mysql
爱补鱼的猫猫1 小时前
22、近端策略优化算法（PPO）论文笔记
论文阅读·算法
开心星人2 小时前
【论文阅读】Reconstructive Neuron Pruning for Backdoor Defense
论文阅读·算法·剪枝
随风奔跑的十八岁2 小时前
java 破解aspose.words 18.6 使用
java·linux·word转pdf·aspose-words
居然是阿宋2 小时前
C语言的中断 vs Java/Kotlin的异常：底层机制与高级抽象的对比
java·c语言·kotlin
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】04【分布式】Hadoop完全分布式的搭建（零基础）05【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！06西电B测-计算机网络综合实验(含验收问题)07Coze扣子平台完整体验和实践（附国内和国际版对比）08苍穹外卖面试总结09DeepSeek各版本说明与优缺点分析10最新 Kubernetes 集群部署 + flannel 网络插件（保姆级教程，最新 K8S 版本）