排序算法（十大排序算法和sort()自定义排序算法）

木星健谈能手

已于 2023-09-17 13:27:17 修改

阅读量100

点赞数 2

文章标签：排序算法算法数据结构

于 2023-09-16 22:14:37 首次发布

本文链接：https://blog.csdn.net/qq_43461982/article/details/132926284

版权

十大排序算法

在这里插入图片描述

算法的稳定性：

https://www.cnblogs.com/zwei1993/p/5031224.html

稳定：如果a原本在b前面，而a=b，排序之后a还是在b前面。
不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面。
概述：
- 交换排序
  - 冒泡排序是稳定的，相等的元素不会交换；快速排序是不稳定的，不稳定发生在中枢元素和a[idx]交换的时刻；
- 插入排序
  - 插入排序是稳定的，相同元素不会发生交换；希尔排序是不稳定的；
- 选择排序
  - 直接选择排序是不稳定的，不稳定发生在5 8 5 2，相同元素的先后顺序就会发生交换；堆排序是不稳定的；
- 归并排序是稳定的；
- 基数排序是稳定的；

时间复杂度：

快速排序每次分成两组进行递归为logN，而每次的时间复杂度为N，故为NlogN。其他相同时间复杂度类似。

排序算法的选择

算法要求稳定，数据量小，有序场景下，插入排序为最优解
算法要求稳定，数据量小，无序场景下，归并排序为最优解
算法不要求稳定，数据量小，有序场景下，插入排序为最优解
算法不要求稳定，数据量小，无序场景下，快速排序为最优解

程序实现

#include<iostream>
using namespace std;
#include <vector>
void print(vector<int>& nums) {
    for (auto a : nums)
        cout << a << " ";
    cout << endl;

}

//冒泡排序
void bubbleSort(vector<int>& arr) {
    //时间复杂度:n*n
    //空间复杂度：1
    for (int i = 0; i < arr.size() - 1; ++i) {
        bool flag = true;
        for(int j = 0; j < arr.size() - 1 - i; ++j) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
                flag = false;
            }
        }
        if (flag)break;
    }
}

//选择排序
//其大致原理是：将序列划分为无序和有序区，寻找无序区中的最小值和无序区的首元素交换，有序区扩大一个，循环最终完成全部排序。
void selectSorrt(vector<int>& arr) {
    //时间复杂度:n*n
    //空间复杂度：1
    for (int i = 0; i < arr.size() - 1; ++i) {
        int minIdx = i;
        for (int j = i + 1; j < arr.size(); ++j) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j;
            }
        }
        swap(arr[minIdx], arr[i]);
    }
}

//插入排序
//其大致原理是：将数组分为无序区和有序区两个区，然后不断将无序区的第一个元素按大小顺序插入到有序区中去，最终将所有无序区元素都移动到有序区完成排序。
void insertSort(vector<int>& arr) {
    //时间复杂度:n*n
    //空间复杂度：1
    for (int i = 1; i < arr.size(); ++i) {
        int j = i - 1;
        int temp = arr[i];
        while (temp < arr[j] && j>=0) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = temp;
    }
}

//快速排序
//其大致原理是：不断寻找一个序列的中点，将小于该中点的元素搬移到中点左边，大于该中点的元素搬移到中点右边，或者反过来。然后对中点左右的序列递归的进行排序，直至全部序列排序完成，使用了分治的思想。
void quickSort(vector<int>& arr, int begin, int end) {
    cout << begin << end << endl;
    if (begin >= end)return;
    int left = begin, right = end;
    int key = arr[left];
    while (left < right) {
        
        while (left < right && key <= arr[right])right--;
        arr[left] = arr[right];
        if (left < right)left++;

        while (left < right && key >= arr[left])left++;
        arr[right] = arr[left];
        if (left < right)right--;
    }
    arr[left] = key;
    quickSort(arr, begin, left - 1);
    quickSort(arr, left + 1, end);
    
}

//希尔排序
//其大致原理是：将数组分为无序区和有序区两个区，然后不断将无序区的第一个元素按大小顺序插入到有序区中去，最终将所有无序区元素都移动到有序区完成排序。
void shellCore(vector<int>& arr, int i, int gap) {
    int temp = arr[i];
    int j = i - gap;
    while (arr[j] > temp && j - gap >= 0) {
        arr[j + gap] = arr[j];
        j -= gap;
    }
    arr[j + gap] = temp;
}

void shellSort(vector<int>& arr) {
    int len = arr.size();
    for (int gap = len / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < len; ++i) {
            shellCore(arr, i, gap);
        }
    }
}

//归并排序
//其大致原理是：将原序列划分为有序的两个序列，然后利用归并算法进行合并，合并之后即为有序序列。
void mergeSort(vector<int>& arr, vector<int>& temp, int begin, int end) {
    if (begin >= end)return;
    int mid = (begin + end) / 2;
    int left1 = begin, right1 = mid;
    int left2 = mid + 1, right2 = end;
    mergeSort(temp, arr, left1, right1);
    mergeSort(temp, arr, left2, right2);
    int idx = left1;
    while (left1 <= right1 && left2 <= right2) {
        if (arr[left1] >= arr[left2]) {
            temp[idx] = arr[left2];
            left2++;
            idx++;
        }
        else {
            temp[idx] = arr[left1];
            left1++;
            idx++;
        }
    }

    while (left1 <= right1) {
        temp[idx] = arr[left1];
        left1++;
        idx++;
    }
    while (left2 <= right2) {
        temp[idx] = arr[left2];
        left2++;
        idx++;
    }
}


int main() {
    vector<int> arr = {1,3,2,4,6,7,5};
    //bubbleSort(arr);
    //selectSorrt(arr);
    //insertSort(arr);
    //quickSort(arr, 0, arr.size() - 1);
    //shellSort(arr);

    //vector<int> temp(arr.begin(), arr.end());
    //mergeSort(arr, temp, 0, arr.size() - 1);
    //arr.assign(temp.begin(), temp.end());

    print(arr);
    return 0;
}

自定义排序

#include<iostream>
#include<algorithm>
using namespace std;

bool cmp(int x,int y){//必须定义未静态函数
	return x % 10 > y % 10;
}

int main(){
	int num[10] = {65,59,96,13,21,80,72,33,44,99};
	sort(num,num+10,cmp);
	for(int i=0;i<10;i++){
		cout<<num[i]<<" ";
	}//输出结果：59 99 96 65 44 13 33 72 21 80
	
	return 0;
	
}