【排序】常见的七种排序：直接插入排序；希尔排序；选择排序；堆排序；冒泡排序；快速排序；归并排序

Wik_西瓜

于 2022-04-13 10:49:00 发布

阅读量353

点赞数 1

分类专栏：数据结构文章标签： java

本文链接：https://blog.csdn.net/Wisk1019/article/details/124142821

版权

数据结构专栏收录该内容

8 篇文章 0 订阅

订阅专栏

本文介绍了排序算法的多种实现，包括直接插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序及其优化，归并排序，以及它们的时间复杂度、空间复杂度和稳定性特点。深入理解这些排序方法有助于提高代码效率和优化策略选择。

摘要由CSDN通过智能技术生成

排序

文章目录

排序

1.直接插入排序

整个区间被分为

有序区间
无序区间
每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入
当一组数据，数据量不大，且趋近于有序，此时直接插入排序更快，（越有序越快）

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;
    }
}

时间复杂度，O(N^2), 最好情况，当数组有序时，时间复杂度是O(N)，

空间复杂度：O(1)

稳定性：稳定

2. 希尔排序

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

希尔排序是对直接插入排序的优化。
当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。

public static void shellSort(int [] array){
    int gap = array.length;
    while(gap>1){
        gap = gap / 3 + 1;//  +1 保证最后一次gap为1
        shell(array,gap);
    }
}
public static void shell(int [] array,int gap){
    for(int i = gap; i < array.length;i++){
        int tmp = array[i];
        int j = i-1;
        for(; i >= 0; j -= gap){
            if(array[j] > tmp){
                array[j+1] = array[j];
            }else{
                break;
            }
        }
        array[j+gap] = tmp;
    }
}

时间复杂度：O^(N1.3 - N^1.5)

空间复杂度：O(1)

稳定性：不稳定（如果在比较过程中，没有发生跳跃式的交换，就是稳定的）

3. 选择排序

每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完

public static void selectSort(int [] array){
    for(int i = 0 ; i < array.length; i++){
        for(int j = i+1; i < array.length;j++){
            if(array[i] > array[j]){
                int tmp = array[i];
                array[i] = array[j];
                array[j] = tmp;
            }
        }
    }
}

时间复杂度：O(N^2)

空间复杂度：O(1)

稳定性：不稳定

4. 堆排序

基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的数。
注意：排升序要建大堆；排降序要建小堆

public static void heapSort(int [] array){
 	creatHeap(array);
    int end = array.length-1;
    while(end > 0){
        int tmp = array[0];
        array[0] = array[end];
        array[end] = tmp;
        siftDown(array,0,end);
        end--;
    }
}
public static void creatHeap(int [] array){
    for(int i = (array.length-1-1)/2; i >= 0;i--){
        siftDown(array,i,array.length);
    }
}
public static void siftDown(int [] array,int root,int len){
    int parent = root;
    int child = root*2+1;
    while(child < len){
        if((child+1)< len && array[child] < array[child+1]){
            child = child + 1;
        }
        if(array[child] > array[parent]){
            int tmp = array[child];
            array[child] = array[parent];
            array[parent] = tmp;
            parent = child;
            child = parent*2+1;
        }else{
            break;
        }
    }
}

时间复杂度：O(N^logN)

空间复杂度：O(1)

稳定性：不稳定

5. 冒泡排序

在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序

public static void bubbleSort(int [] array){
    for(int i = 0; i < array.length-1;i++){
        boolean flg = false;
        for(int j = 0 ; j < array.length - 1; j++){
            if(array[j] > array[j+1]){
                int tmp = array[j];
                array[j] = array[j+1];
                array[j+1] = tmp;
                flg = true;
            }
        }
        if(flg == true){
            break;
        }
    }
}

时间复杂度：代码优化前：O(N^2) 优化后：当数据有序时 O(N)

空间复杂度：O(1)

稳定性：稳定

6. 快速排序

从待排序区间选择一个数，作为基准值(pivot)；
Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可
以包含相等的）放到基准值的右边；
采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间
的长度 == 0，代表没有数据。

public static void quickSort(int [] array){
    quick(array,0,array.length-1);
}
public static void quick(int [] array,int start, int end){
    if(start >= end){
        return;
    }
    int piovt = partition(array,start,end);
    quick(array,start,piovt-1);
    quick(array,piovt+1,end);
}
public static int partition(int [] array,int low,int high){
    int tmp = array[low];
    while(low < high){
        while(low < high && array[high] >= tmp){
            high--;
        }
        array[low] = array[high];
        while(low < high && array[low] <= tmp){
            low--;
        }
        array[high] = array[low];
    }
    array[low] = tmp;
    return low;
}

时间复杂度：最坏情况下：O(N^2)数组有序时，不能完全分割
最好情况下：O(N*logN)，均匀分割：基准恰好时中位数

空间复杂度：最坏情况下：O(N) 最好情况下：O(logN)

稳定性：不稳定

6.1 快速排序的优化

基准值的选择：三数找中

待排序区间小于一个阙值时，使用直接插入排序

public static void quickSort(int [] array){
    quick(array,0,array.length-1);
}
public static void quick(int [] array,int start, int end){
    if(start >= end){
        return;
    }
    //待排序区间小于一个阙值时，使用直接插入排序
    if((end - start +1) < 100){
        insertSort(array,start,end);
        return;
    }
    //基准值的选择：三数找中
    int mid = (start + end) / 2;
    selectPivoMedianOfThree(array,start,end,mid);
    int piovt = partition(array,start,end);
    quick(array,start,piovt-1);
    quick(array,piovt+1,end);
}
public static int partition(int [] array,int low,int high){
    int tmp = array[low];
    while(low < high){
        while(low < high && array[high] >= tmp){
            high--;
        }
        array[low] = array[high];
        while(low < high && array[low] <= tmp){
            low--;
        }
        array[high] = array[low];
    }
    array[low] = tmp;
    return low;
}
//三数找中
public static void selectPivoMedianOfThree(int [] array,int start,int end,int mid){
    //调整为：array[mid] <= array[start] <= array[end]
    if(array[mid] > array[start]){
        swap(mid,start);
    }//array[mid] <= array[start]
    if(array[start] > array[end]){
        swap(start,end);
    }//array[start] <= array[end]
    if(array[mid] > array[end]){
        swap(mid,end);
    }//array[mid] <= array[end]
}
//交换
public static void swap(int [] array,int i,int j){
    int tmp = array[i];
    array[i] = array[j];
    array[j] = tmp;
}
//调用的插入排序
public static void insertSort(int [] array,int start,int end){
    for(int i = start+1;i <= end;i++){
        int tmp = array[i];
        int j = i-1;
        for(; j >= start; j--){
            if(array[j] > tmp){
                array[j+1] = array[j];
            }else{
                break;
            }
        }
        array[j+1] = tmp;
    }
}

6.2 快速排序非递归

public static void quickSort(int array[]){
    int start = 0;
    int end = array.length-1;
    int pivot = paratition(array,start,end);
    Stack<Integer> stack = new Stack<>();
    //判断左区间是否有两个元素及以上  将区间的两个边界放入栈中
    if(pivot > start + 1){
        stack.push(start);
        stack.push(pivot - 1);
    }
    //判断右区间是否右两个元素及以上  将区间的两个边界放入栈中	
    if(pivot < end-1){
        stack.push(pivot + 1);
        stack.push(end);
    }
    //如果栈不为空，就弹出两个元素，因为先放的是左边界，所以先弹出的是右边界，
    while(!stack.empty()){
        end = stack.pop();
        start = stack.pop();
        pivot = paratition(array,start,end);
        if(pivot > start + 1){
        stack.push(start);
        stack.push(pivot - 1);
    }
    if(pivot < end-1){
        stack.push(pivot + 1);
        stack.push(end);
    }
    }
}
public static int paratition(int array[],int low,int high){
    int tmp = array[low];
    while(low < high){
        if(low < high && array[high] >= tmp){
            high--;
        }
        array[low] = array[high];
        if(low < high && array[low] <= tmp){
            low++;
        }
        array[high] = array[low];
    }
    array[low] = tmp;
    return low;
}

7. 归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

public static void mergeSort(int [] array){
    mergeSortInernal(array,0,array.length-1);
}
public static void mergeSortInternal(int [] array,int low,int high){
    //先分解
    int mid = (high + low) / 2;
    mergeSortInternal(array,low,mid);
    mergeSortInternal(array,mid+1,high);
    //再合并
    merge(array,low,mid,high);
}
//合并
public static void merge(int [] array,int low,int mid,int high){
    int s1 = low;
    int e1 = mid;
    int s2 = mid + 1;
    int e2 = high;
    int [] tmp = new int [high - low + 1];
    int k = 0;//tmp数组的下标
    while(s1 <= e1 && s2 <= e2){
        if(array[s1] <= array[s2]){
            tmp[k] = array[s1];
            k++;
            s1++;
        }else{
            tmp[k] = array[s2];
            k++;
            s2++;
        }
    }
    //循环结束有两种情况
    //s2段中的数据空了  就将s1段中剩下的元素都放入tmp中
    while(s1 <= e1){
        tmp[k] = array[s1];
        k++;
        s1++;
    }
    //s1段中的数据空了，就将s2中剩下的元素都放入tmp中
    while(s2 <= e2){
        tmp[k] = array[s2];
        k++;
        s2++;
    }
    //此时tmp中存储的数据就是归并好的数据， 就tmp中数据都放入array，注意array要从i+low下标处开始
    for(int i = 0; i < tmp.length; i++){
        array[i+low] = tmp[i];
    }
}

时间复杂度：O(N * logN)

空间复杂度：O(N)

稳定性：稳定

7.1 归并排序非递归

public static void mergeSort(int [] array){
    for(int i = 1; i < array.length;i *= 2){
        merge(array,gap);
    }
}
public static void merge(int [] array,int gap){
   	int s1 = 0;
    int e1 = s1 + gap -1;
    int s2 = e1 + 1;
    int e2 = s2 + gap -1 < array.length ? s2 + gap -1 : array.length - 1;
    int [] tmp = new int [array.length];
    int k = 0;
    //当有两个归并段时  进入循环
    while(s2 < array.length){
        while(s1 <= e1 && s2 <= e2){
            if(array[s1] <= array[s2]){
                tmp[k] = array[s1];
                k++;
                s1++;
            }else{
                tmp[k] = array[s2];
                k++;
                s2++;
            }
        }
        while(s1 <= e1){
            tmp[k] = array[s1];
            k++;
            s1++;
        }
        while(s2 <= e2){
            tmp[k] = array[s2];
            k++;
            s2++;
        }
        //此时一组归并结束，
        s1 = e2+1;
        e1 = s1 + gap -1;
        s2 = e1 + 1;
        e2 = s2 + gap - 1 < array.length ? s2 + gap - 1 : array.length - 1;
    } 
        //如果没有第二个归并段
    while(s1 <= array.length - 1){
        tmp[k] = array[s1];
    }
    for(int i = 0 ; i < tmp.length ; i++){
        array[i] = tmp[i];
    }
}

8. 总结

排序方式	最好时间复杂度	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
冒泡排序	O(N)	O(N^2)	O(N^2)	O(1)	稳定
插入排序	O(N)	O(N^2)	O(N^2)	O(1)	稳定
选择排序	O(N^2)	O(N^2)	O(N^2)	O(1)	不稳定
希尔排序	O(N^1.3)	O(N^1.3)	O(N^1.5)	O(1)	不稳定
堆排序	O(N * log N)	O(N * log N)	O(N * log N)	O(1)	不稳定
快速排序	O(N * log N)	O(N * log N)	O(N^2)	O(log N) ~ O(N)	不稳定
归并排序	O(N * log N)	O(N * log N)	O(N * log N)	O(N)	稳定