十大排序 C++语言

已于 2024-09-13 16:05:20 修改
阅读量710 收藏 11
点赞数 12
文章标签： c++ 算法 数据结构
于 2024-09-12 11:22:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45886404/article/details/142170090
版权

1、冒泡排序 (Bubble Sort)

        每次遍历列表时，比较相邻元素并交换位置，将最大的元素逐渐“冒泡”到列表的最后。时间复杂度为 O(n²)。

#include <iostream>
using namespace std;

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

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);
    bubbleSort(arr, n);
    cout << "Sorted array: \n";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

2、选择排序 (Selection Sort)

        每次从未排序部分选择最小（或最大）的元素，放到已排序部分的末尾。时间复杂度为 O(n²)。

#include <iostream>
using namespace std;

void selectionSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j;
            }
        }
        swap(arr[minIdx], arr[i]);
    }
}

int main() {
    int arr[] = {64, 25, 12, 22, 11};
    int n = sizeof(arr) / sizeof(arr[0]);
    selectionSort(arr, n);
    cout << "Sorted array: \n";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

3、插入排序 (Insertion Sort)

        每次将未排序元素插入到已排序部分的正确位置，类似于整理扑克牌。时间复杂度为 O(n²)。

#include <iostream>
using namespace std;

void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);
    insertionSort(arr, n);
    cout << "Sorted array: \n";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

4、希尔排序 (Shell Sort)

        基于插入排序的改进版，通过使用不同间隔的子序列逐步排序。时间复杂度平均为 O(n log n)，最坏情况下 O(n²)。

#include <iostream>
using namespace std;

void shellSort(int arr[], int n) {
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j;
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                arr[j] = arr[j - gap];
            }
            arr[j] = temp;
        }
    }
}

int main() {
    int arr[] = {12, 34, 54, 2, 3};
    int n = sizeof(arr) / sizeof(arr[0]);
    shellSort(arr, n);
    cout << "Sorted array: \n";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

5、归并排序 (Merge Sort)

        采用分治法，将数组递归分成两个子数组，然后合并两个已排序的子数组。时间复杂度为 O(n log n)。

#include <iostream>
using namespace std;

void merge(int arr[], int l, int m, int r) {
    int n1 = m - l + 1;
    int n2 = r - m;
    int L[n1], R[n2];
    for (int i = 0; i < n1; i++) L[i] = arr[l + i];
    for (int j = 0; j < n2; j++) R[j] = arr[m + 1 + j];
    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) arr[k++] = L[i++];
        else arr[k++] = R[j++];
    }
    while (i < n1) arr[k++] = L[i++];
    while (j < n2) arr[k++] = R[j++];
}

void mergeSort(int arr[], int l, int r) {
    if (l >= r) return;
    int m = l + (r - l) / 2;
    mergeSort(arr, l, m);
    mergeSort(arr, m + 1, r);
    merge(arr, l, m, r);
}

int main() {
    int arr[] = {12, 11, 13, 5, 6, 7};
    int n = sizeof(arr) / sizeof(arr[0]);
    mergeSort(arr, 0, n - 1);
    cout << "Sorted array: \n";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

6、快速排序 (Quick Sort)

        选择一个基准元素，将数组分为比基准小和比基准大的两部分，然后递归排序。时间复杂度平均为 O(n log n)，最坏情况下 O(n²)。

#include <iostream>
using namespace std;

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = (low - 1);
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[i + 1], arr[high]);
    return (i + 1);
}

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    quickSort(arr, 0, n - 1);
    cout << "Sorted array: \n";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

7、堆排序 (Heap Sort)

        通过构建大顶堆（或小顶堆）进行排序，每次从堆顶取出最大（或最小）元素并调整堆。时间复杂度为 O(n log n)。

#include <iostream>
using namespace std;

void heapify(int arr[], int n, int i) {
    int largest = i;
    int l = 2 * i + 1;
    int r = 2 * i + 2;
    if (l < n && arr[l] > arr[largest])
        largest = l;
    if (r < n && arr[r] > arr[largest])
        largest = r;
    if (largest != i) {
        swap(arr[i], arr[largest]);
        heapify(arr, n, largest);
    }
}

void heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);
    for (int i = n - 1; i > 0; i--) {
        swap(arr[0], arr[i]);
        heapify(arr, i, 0);
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6, 7};
    int n = sizeof(arr) / sizeof(arr[0]);
    heapSort(arr, n);
    cout << "Sorted array: \n";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

8、计数排序 (Counting Sort)

        适用于范围较小的整数排序，使用额外的计数数组记录每个元素出现的次数。时间复杂度为 O(n+k)，k 是整数的范围。

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

void countingSort(int arr[], int n, int range) {
    int output[n];
    int count[range + 1], i;
    memset(count, 0, sizeof(count));
    for (i = 0; i < n; i++) count[arr[i]]++;
    for (i = 1; i <= range; i++) count[i] += count[i - 1];
    for (i = n - 1; i >= 0; i--) {
        output[count[arr[i]] - 1] = arr[i];
        count[arr[i]]--;
    }
    for (i = 0; i < n; i++) arr[i] = output[i];
}

int main() {
    int arr[] = {4, 2, 2, 8, 3, 3, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    int range = 8;
    countingSort(arr, n, range);
    cout << "Sorted array: \n";
    for (int i =

9、桶排序 (Bucket Sort)

        将数据划分到有限数量的桶中，分别对每个桶进行排序，最后合并桶中的数据。时间复杂度为 O(n+k)，k 为桶的数量。

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

void bucketSort(float arr[], int n) {
    vector<float> buckets[n];
    
    // 将元素分配到桶中
    for (int i = 0; i < n; i++) {
        int bucketIdx = n * arr[i];  // 假设输入数据范围为[0,1)
        buckets[bucketIdx].push_back(arr[i]);
    }

    // 对每个桶内部进行排序
    for (int i = 0; i < n; i++) {
        sort(buckets[i].begin(), buckets[i].end());
    }

    // 合并所有桶中的元素
    int index = 0;
    for (int i = 0; i < n; i++) {
        for (size_t j = 0; j < buckets[i].size(); j++) {
            arr[index++] = buckets[i][j];
        }
    }
}

int main() {
    float arr[] = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    bucketSort(arr, n);

    cout << "Sorted array: \n";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

10、基数排序 (Radix Sort)

        将元素按位数进行分配和排序，先按最低位，再按次低位，以此类推。时间复杂度为 O(d*(n+k))，d 是最大数的位数。

#include <iostream>
using namespace std;

// 获取数组中的最大值
int getMax(int arr[], int n) {
    int max = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > max)
            max = arr[i];
    }
    return max;
}

// 按位进行计数排序
void countingSort(int arr[], int n, int exp) {
    int output[n];
    int count[10] = {0};

    // 根据当前位数的值来计数
    for (int i = 0; i < n; i++) {
        count[(arr[i] / exp) % 10]++;
    }

    // 更新 count 以获取每个元素在输出中的位置
    for (int i = 1; i < 10; i++) {
        count[i] += count[i - 1];
    }

    // 根据当前位数的值进行排序
    for (int i = n - 1; i >= 0; i--) {
        output[count[(arr[i] / exp) % 10] - 1] = arr[i];
        count[(arr[i] / exp) % 10]--;
    }

    // 将排序结果复制到原数组
    for (int i = 0; i < n; i++) {
        arr[i] = output[i];
    }
}

// 基数排序
void radixSort(int arr[], int n) {
    // 获取最大值，以确定有多少位数
    int max = getMax(arr, n);

    // 从个位开始对每一位进行计数排序
    for (int exp = 1; max / exp > 0; exp *= 10) {
        countingSort(arr, n, exp);
    }
}

int main() {
    int arr[] = {170, 45, 75, 90, 802, 24, 2, 66};
    int n = sizeof(arr) / sizeof(arr[0]);

    radixSort(arr, n);

    cout << "Sorted array: \n";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

以下两图引用自：http://t.csdnimg.cn/ASzEG

?~L
关注
c++十大排序之快速排序（例题+代码+注释+讲解+动态图）
weixin_47067783的博客
02-23 1211
对于新手来说函数虽然简单但如果把所有代码结合到一起对于小白就很难理解了所以就有了今天的文章： 今天是先讲解在练习： 快速排序是冒泡排序的升级版（也可以叫改进版） 下面是简介： 快速排序由C. A. R. Hoare在1962年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 动态图与讲解：从数列中挑出一个元素，称为 "基准".
c++十大排序之桶排序（最底下有解释，非常易懂）
weixin_47067783的博客
02-20 1030
十大排序之桶排序（最底下有解释，非常易懂）c++
排序算法小结
11-18 1896
排序小结    排序算法是一种基本并且常用的算法。由于实际工作中处理的数量巨大，所以排序算法对算法本身的速度要求很高。    而一般我们所谓的算法的性能主要是指算法的复杂度，一般用O方法来表示。在后面我将给出详细的说明。    对于排序的算法我想先做一点简单的介绍，也是给这篇文章理一个提纲。    我将按照算法的复杂度，从简单到难来分析算法。    第一部分是简单排序算法，后面你将看到他们的共
C++常用排序法研究
djcsch2001的专栏
10-03 362
C++常用排序法研究上一篇 / 下一篇  2008-05-22 13:59:17 查看( 877 ) / 评论( 0 ) / 评分( 0 / 0 )     首先介绍一个计算时间差的函数，它在头文件中定义，于是我们只需这样定义2个变量，再相减就可以计算时间差了。函数开头加上     clock_t   start   =   clock();      
C++排序法
tingtingrichard的专栏
03-14 479
C++排序算法全集 排序算法是一种基本并且常用的算法。由于实际工作中处理的数量巨大，所以排序算法对算法本身的速度要求很高。 而一般我们所谓的算法的性能主要是指算法的复杂度，一般用O方法来表示。在后面我将给出详细的说明。 对于排序的算法我想先做一点简单的介绍，也是给这篇文章理一个提纲。 我将按照算法的复杂度，从简单到难来分析算法。 第一部分是简单排序算法，后面你将看到他们的共同
C++排序算法
Ru_Ella的博客
03-31 2510
1.冒泡排序 冒牌排序是一种经典的排序算法，它是一种稳定的排序。其原理是如果前面的数比后面的数要大，就交换两个数字的位置。代码如下： for(int i=1; i<=n-1; i++){ for(int j=1; j<=n; j++){ if(a[j]>a[j+1]){ swap(a[j],a[j+1]); } } } 2.归并排序 归并排序的思想是把一串数字从中间分开，然后两边分别排序，最后再合并，从而得到
C/C++各种排序法
Mobidogs Blog
11-30 1674
#include#includestruct node{    int key;}r[20];struct rnode{    int key;    int point;};main(){    void print(struct node a[20],int n);    int creat();    void shell(struct node a[20],int n);    int h
c++十大排序之计数排序（例题+代码+注释+讲解+动态图）
weixin_47067783的博客
02-26 817
特点： 1.通过计数而不是比较来进行排序 2.shi'yong'yu'fan'wei'jiao'xiao
C++实现十大排序算法：选择排序与冒泡排序解析
"本文主要介绍了三种经典的排序算法：选择排序、冒泡排序和快速排序，分别用C++语言实现，并探讨了它们的工作原理和效率。" 在计算机科学中，排序算法是数据处理的重要组成部分，特别是在大数据处理和算法竞赛中更...
十大经典排序算法(C++、Java实现)动图演示及代码解析-冒泡排序、选择排序、插入排序、快速排序、堆排序、希尔排序、归并排序、计数排序、桶排序、基数排序
SmallBottle-CGWLMX的博客
09-10 2982
和我的LeetCode系列源码放到一起。做IT行业，不管是测试、开发、运维等等，或简单或复杂的算法是必不可少的，也是大家面试工作中的必要环节，这个专栏开始和大家一起来研究著名的LeetCode，里边有上千种最常见的算法，面试工作出现几率很高，值得掌握研究，每次完成博客更新我会同步更新我的个人Github上的代码，每个算法都可以直接运行调试以供掌握，GitHub地址：https://github.c...
c++中常用排序方法
nice__xixi的博客
08-18 942
排序方法：（由小到大） 冒泡排序：即整个过程将最值像冒泡一样浮现。对于给定的n个记录，从第一个记录开始将相邻两个记录进行比较，如果前者大于后者，将他们交换位置（见红色部分），当i=0，j进行全体遍历后，可以获得这组记录的最大值，并将其处于最后数组的最后一个；i=1，j进行前n-i个遍历后，可以获得第二个最大值，即数组中第二大的数，将其放到倒数第二个位置.....以此类推，便能将数组中的记录进行小...
c++ 排序方法 汇总
最新发布
清梦的博客
08-14 1145
c++ 排序方法 汇总
C++十种排序方法（快速排序、冒泡排序等等）
热门推荐
weixin_41545534的博客
04-15 2万+
C++十种排序方法（快速排序、冒泡排序等等） 一、冒泡排序 1、概念及思路：冒泡排序顾名思义就是大的数沉下去，小的数浮上来，就跟气泡在水底浮上来一样；基本的思路很简单，就是相邻的两个数相比较，如果前面那个数比后面那个数大，则换位置，否则不需要换。以此循环下去（这里指的是从小到大排序，当然也可以从大到小） 2、代码演示： #include<iostream> using namespace std; int main() { int i; int arr[10] = { 1,5,2,3,6
【C++】十大排序算法（亲测有效！）
Hz731555093的博客
07-21 1382
十大排序算法（亲测有效！）
c++十大经典排序算法
客舟中
12-28 7930
代码 1 冒泡排序 冒泡排序是一种简单直观的入门排序算法。它的原理就是从第一个元素开始，与后面的元素逐个比较，如果顺序不对就交换，直到没有可比较的元素为止。 1 // 冒泡排序 2 void BublingSort(int *arr, int len) 3 { 4 if(len == 0) 5 { 6 return; 7 } 8 std::cout<<"冒泡排序"<<std::endl; 9 for(i
C++八种排序算法万字详解
我的博客
06-04 7668
哈喽，今天我来总结一下C++中的8中排序方法，这些排序在实际开发中能起到一些作用，也可以锻炼你的算法头脑。我也好长时间没上热榜了，这次准备做一个非常详细🔎的总结，看看能不能上热榜。既然叫排序算法，肯定要排序。我们要实现的效果是输入几个数，输出升序（或降序）排序后的结果，并找到时间复杂度最低的算法，应用到实际开发中。冒泡排序主要思路就是遍历数组，比较两个相邻的元素，也就是 arr[j] 和 arr[j+1] ，如果顺序错误就用 swap 函数或空杯交换，交换这两个元素。举个例子，数组是 a[5]={2,1,.
C++实现七种经典排序算法
森的博客
04-08 3387
利用C++实现七种常见的排序算法： 具体的排序方法如下所示： （1）冒泡排序 基本思想：比较相邻的两个数，如果前者比后者大，则进行交换。每一轮排序结束，选出一个未排序中最大的数放到数组后面。常见冒泡排序算法如下所示： void bubblesort(int *arr,int n) { for (int i = 0; i < n; i++) { for (int j = ...
常见的几种排序算法（c++）
low5252的博客
03-12 1万+
常见的几种排序算法（c++）一、冒泡排序二、插入排序三、选择排序四、归并排序五、希尔排序六、快速排序七、堆排序八、基数排序1.LSD(低位到高位的排序)2.MSD(高位到低位排序)算法比较 一、冒泡排序 1、算法思想 冒泡排序是一种简单的排序算法，通过循环遍历，将临近的两个元素进行比较，满足排序规则时，进行下一组元素对比，当不满足排序规则时，将两个元素交换位置，再继续进行下一组元素对比，确保最大的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值