【C++】十大排序算法（亲测有效！）

于 2023-07-21 20:23:33 发布
阅读量735 收藏 5
点赞数 2
文章标签： c++ 排序算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hz731555093/article/details/131859376
版权

背景

        网上很多排序算法运行结果是错误的，本小白很苦恼，因此花了一些时间汇总了各个算法，并给出main函数调用方式，本文仅为了分享个人学习记录，如有错误，欢迎讨论！

        本文的代码均已在Visual Studio测试过，可放心ctrl C！具体每种算法的介绍与展开，后续有时间进行补充！

1.冒泡排序

void bubbleSort(int Array[], int ArraySize) {
    for (int i = 0; i < ArraySize - 1; i++) {
        for (int j = 0; j < ArraySize - 1 - i; j++) {
            if (Array[j] > Array[j + 1]) {
                int Temp = Array[j];
                Array[j] = Array[j + 1];
                Array[j + 1] = Temp;
            }
        }
    }
}

1.1.冒泡排序优化版

void bubbleSortAdvanced(int Array[], int ArraySize) {
    bool SwapFlag = false;
    for (int i = 0; i < ArraySize - 1; i++) {
        SwapFlag = false;
        for (int j = 0; j < ArraySize - 1 - i; j++) {
            if (Array[j] > Array[j + 1]) {
                swap(Array[j], Array[j + 1]);
                SwapFlag = true;
            }
        }
        if (SwapFlag == false) 
            break;
    }
}

2.选择排序

void selectSort(int Array[], int ArraySize) {
    for (int i = 0; i < ArraySize - 1; i++) {
        int Index = i;
        for (int j = i + 1; j < ArraySize; j++) {
            if (Array[j] < Array[Index]) 
                Index = j;
        }
        swap(Array[Index], Array[i]);
    }
}

3.插入排序

void insertSort(int Array[], int ArraySize) {
    for (int i = 1; i < ArraySize; i++) {
        for (int j = i; j > 0; j--) {
            if (Array[j - 1] > Array[j]) 
                swap(Array[j - 1], Array[j]);
            else
                break;
        }
    }
}

4.快速排序

void quickSort(int Array[], int ArraySize, int Left, int Right) {
    if (Left >= Right) return;
    int i = Left, j = Right, Base = Array[Left];
    while (i < j) {
        while (Array[j] >= Base && i < j) 
            j--;
        while (Array[i] <= Base && i < j) 
            i++;
        if (i < j) 
            swap(Array[i], Array[j]);
    }
    Array[Left] = Array[i];
    Array[i] = Base;
    quickSort(Array, ArraySize, Left, i - 1);
    quickSort(Array, ArraySize, i + 1, Right);
}

5.希尔排序

void shellSort(int Array[], int ArraySize) {
    for (int i = 0; i < ArraySize; i++) {
        for (int j = i - 1; j >= 0 && Array[j + 1] < Array[j]; j--) {
            swap(Array[j], Array[j + 1]);
        }
    }
}

6.归并排序

void mergeArray(int Array[], int ArraySize, int Left, int Middle, int Right) {
    int LeftSize = Middle - Left + 1, RightSize = Right - Middle;
    // 创建临时数组来保存左右两部分的数据
    vector<int> LeftTempArray(LeftSize), RightTempArray(RightSize);
    // 将数据复制到临时数组中
    for (int i = 0; i < LeftSize; ++i)
        LeftTempArray[i] = Array[Left + i];
    for (int j = 0; j < RightSize; ++j)
        RightTempArray[j] = Array[Middle + 1 + j];

    // 将临时数组中的数据按顺序合并到原始数组中
    int i = 0, j = 0, k = Left;
    while (i < LeftSize && j < RightSize) {
        if (LeftTempArray[i] <= RightTempArray[j]) {
            Array[k] = LeftTempArray[i];
            i++;
        }
        else {
            Array[k] = RightTempArray[j];
            j++;
        }
        k++;
    }
    // 将剩余的元素复制到原始数组中
    while (i < LeftSize) {
        Array[k] = LeftTempArray[i];
        i++; 
        k++;
    }
    while (j < RightSize) {
        Array[k] = RightTempArray[j];
        j++; 
        k++;
    }
}
static void mergeSort(int Array[], int ArraySize, int Left, int Right) {
    if (Left >= Right) 
        return;
    int Middle = Left + ((Right - Left) / 2);
    mergeSort(Array, ArraySize, Left, Middle);
    mergeSort(Array, ArraySize, Middle + 1, Right);
    mergeArray(Array, ArraySize, Left, Middle, Right);
}

7.堆排序

void heapSort_MaxTree(int Array[], int StartIndex, int EndIndex) {
    int ParentIndex = StartIndex;           /* 父节点 */
    int ChildIndex = 2 * StartIndex + 1;    /* 子节点 */
    while (ChildIndex < EndIndex) {
        // 判断挑出 大的子节点 与 父节点 比较
        if (ChildIndex + 1 < EndIndex && Array[ChildIndex] < Array[ChildIndex + 1])       
            ChildIndex++;
        // 若父节点>子节点,则调整完毕.否则继续调整
        if (Array[ParentIndex] > Array[ChildIndex]) 
            return;
        else {
            // 交换父 子节点
            swap(Array[ParentIndex], Array[ChildIndex]);
            ParentIndex = ChildIndex;
            ChildIndex = 2 * ChildIndex + 1;
        }
    }
}
static void heapSort(int Array[], int ArraySize) {
    // 数组初始化:构建大顶堆
    for (int i = ArraySize / 2 - 1; i >= 0; i--) {
        heapSort_MaxTree(Array, i, ArraySize);// 从倒数一半的位置开始,后面的均为最底层树
    }
    // 依次排序并调整：从最后一个元素开始，不断缩小调整范围到第一个元素
    for (int i = ArraySize - 1; i > 0; i--) {
        // 交换Array[0]和Array[i]，交换后Array[i]是Array[0到i]中最大的
        swap(Array[0], Array[i]);
        // 调整Array[0......i]，使其仍为最大堆
        heapSort_MaxTree(Array, 0, i);
    }
}

8.桶排序

static int digitCount(long long Number) {
    int Counter = 1;
    while (Number /= 10) 
        Counter++;
    return Counter;
}
static void bucketSort(int Array[], int ArraySize) {
    // 获取最小值 最大值 确定桶的个数
    int MinValue = Array[0], MaxValue = Array[0];
    for (int i = 0; i < ArraySize; i++) {
        if (MinValue > Array[i]) 
            MinValue = Array[i];
        if (MaxValue < Array[i]) 
            MaxValue = Array[i];
    }
    // 根据位数来创建桶的个数
    int BucketNum = digitCount(MaxValue);
    double BucketRange = (double)(MaxValue - MinValue + 1) / BucketNum;
    vector<vector<int>> Buckets(BucketNum);
    // 初始化桶空间
    for (int i = 0; i < BucketNum; i++) {
        Buckets[i].reserve(ArraySize / BucketNum);
    }
    // 将元素放入对应的桶中
    for (int i = 0; i < ArraySize; ++i) {
        int BucketIndex = (int)((Array[i] - MinValue) / BucketRange);
        Buckets[BucketIndex].push_back(Array[i]);
    }
    // 对桶内的元素进行排序
    for (int i = 0; i < BucketNum; ++i) 
        sort(Buckets[i].begin(), Buckets[i].end());
    // 将桶中的元素按顺序合并得到排序结果
    int index = 0;
    for (int i = 0; i < BucketNum; ++i) {
        for (int j = 0; j < Buckets[i].size(); ++j) 
            Array[index++] = Buckets[i][j];
    }
}

9.计数排序

void countSort(int Array[], int ArraySize) {
    // 找出最大值与最小值
    int Min = Array[0], Max = Array[0];
    for (int i = 0; i < ArraySize; i++) {
        if (Min > Array[i]) 
            Min = Array[i];
        if (Max < Array[i]) 
            Max = Array[i];
    }
    // 根据最大值与最小值之间的元素个数开辟新数组
    vector<int> Count(Max - Min + 1, 0);
    for (int i = 0; i < ArraySize; i++) {
        // 统计相同元素出现的次数
        int OffSet = Array[i] - Min;
        Count[OffSet]++;
    }
    for (int i = 0, Position = 0; i < Count.size(); i++) {
        while ((Count[i]--) != 0) {
            Array[Position] = i + Min;
            Position++;
        }
    }
}

10.基数排序

int maxBit(int Array[], int ArraySize) {
    int MaxValue = Array[0];
    for (int i = 0; i < ArraySize; i++) {
        if (MaxValue < Array[i]) 
            MaxValue = Array[i];
    }
    int Counter = 1;    // 最大位数
    int Max = 10;
    while (MaxValue >= Max) {
        MaxValue /= 10;
        Counter++;
    }
    return Counter;
}
void radixSort(int Array[], int ArraySize) {
    // 十进制数，所以为10
    int MaxCounter = maxBit(Array, ArraySize);
    int *Temp = new int[ArraySize];
    int *Count = new int[10];   // 计数器
    int Radix = 1;
    // MaxCounter次排序
    for (int i = 1; i <= MaxCounter; i++) { 
        // 每次分配前清空计数器
        for (int j = 0; j < 10; j++) 
            Count[j] = 0;
        // 统计每个桶中的记录数
        for (int j = 0; j < ArraySize; j++) {
            int k = (Array[j] / Radix) % 10;
            Count[k]++;
        }
        // 将Temp中的位置依次分配给每个桶
        for (int j = 1; j < 10; j++) 
            Count[j] = Count[j - 1] + Count[j];
        // 将所有桶中记录依次收集到tmp中
        for (int j = ArraySize - 1; j >= 0; j--) {
            int k = (Array[j] / Radix) % 10;
            Temp[Count[k] - 1] = Array[j];
            Count[k]--;
        }
        // 将临时数组Temp的内容复制到Array中
        for (int j = 0; j < ArraySize; j++) 
            Array[j] = Temp[j];
        Radix = Radix * 10;
    }
}

AC代码：

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

/* 1.冒泡排序(稳定):相邻元素相等时,它们并不会交换位置;时间复杂度O(n^2) */
void bubbleSort(int Array[], int ArraySize) {
    for (int i = 0; i < ArraySize - 1; i++) {
        for (int j = 0; j < ArraySize - 1 - i; j++) {
            if (Array[j] > Array[j + 1]) {
                int Temp = Array[j];
                Array[j] = Array[j + 1];
                Array[j + 1] = Temp;
            }
        }
    }
}

/* 1.1.冒泡排序(优化):提升稳定性.有序时,时间复杂度为O(n) */
void bubbleSortAdvanced(int Array[], int ArraySize) {
    bool SwapFlag = false;
    for (int i = 0; i < ArraySize - 1; i++) {
        SwapFlag = false;
        for (int j = 0; j < ArraySize - 1 - i; j++) {
            if (Array[j] > Array[j + 1]) {
                swap(Array[j], Array[j + 1]);
                SwapFlag = true;
            }
        }
        if (SwapFlag == false) 
            break;
    }
}

/* 2.选择排序(不稳定):记录最大元素及下标,遍历后调换元素位置.时间复杂度为O(n^2) */
void selectSort(int Array[], int ArraySize) {
    for (int i = 0; i < ArraySize - 1; i++) {
        int Index = i;
        for (int j = i + 1; j < ArraySize; j++) {
            if (Array[j] < Array[Index]) 
                Index = j;
        }
        swap(Array[Index], Array[i]);
    }
}

/* 3.插入排序:循环比较,每发现1个数,就开始调位.时间复杂度为O(n^2)*/
void insertSort(int Array[], int ArraySize) {
    for (int i = 1; i < ArraySize; i++) {
        for (int j = i; j > 0; j--) {
            if (Array[j - 1] > Array[j]) 
                swap(Array[j - 1], Array[j]);
            else 
                break;
        }
    }
}

/* 4.快速排序:分为两半部分,进行递归.时间复杂度为O(nlogn) */
void quickSort(int Array[], int ArraySize, int Left, int Right) {
    if (Left >= Right) return;
    int i = Left, j = Right, Base = Array[Left];
    while (i < j) {
        while (Array[j] >= Base && i < j) 
            j--;
        while (Array[i] <= Base && i < j) 
            i++;
        if (i < j) 
            swap(Array[i], Array[j]);
    }
    Array[Left] = Array[i];
    Array[i] = Base;
    quickSort(Array, ArraySize, Left, i - 1);
    quickSort(Array, ArraySize, i + 1, Right);
}

/* 5.希尔排序(非稳定):插入排序的改进,循环比较,每发现一个数,就开始调位.时间复杂度为O(n^2) */
void shellSort(int Array[], int ArraySize) {
    for (int i = 0; i < ArraySize; i++) {
        for (int j = i - 1; j >= 0 && Array[j + 1] < Array[j]; j--) {
            swap(Array[j], Array[j + 1]);
        }
    }
}

/* 6.归并排序(稳定):递归将1个数组分成2部分分别排序.时间复杂度O(nlogn) */
void mergeArray(int Array[], int ArraySize, int Left, int Middle, int Right) {
    int LeftSize = Middle - Left + 1, RightSize = Right - Middle;
    // 创建临时数组来保存左右两部分的数据
    vector<int> LeftTempArray(LeftSize), RightTempArray(RightSize);
    // 将数据复制到临时数组中
    for (int i = 0; i < LeftSize; ++i)
        LeftTempArray[i] = Array[Left + i];
    for (int j = 0; j < RightSize; ++j)
        RightTempArray[j] = Array[Middle + 1 + j];

    // 将临时数组中的数据按顺序合并到原始数组中
    int i = 0, j = 0, k = Left;
    while (i < LeftSize && j < RightSize) {
        if (LeftTempArray[i] <= RightTempArray[j]) {
            Array[k] = LeftTempArray[i];
            i++;
        }
        else {
            Array[k] = RightTempArray[j];
            j++;
        }
        k++;
    }
    // 将剩余的元素复制到原始数组中
    while (i < LeftSize) {
        Array[k] = LeftTempArray[i];
        i++; 
        k++;
    }
    while (j < RightSize) {
        Array[k] = RightTempArray[j];
        j++; 
        k++;
    }
}
void mergeSort(int Array[], int ArraySize, int Left, int Right) {
    if (Left >= Right) 
        return;
    int Middle = Left + ((Right - Left) / 2);
    mergeSort(Array, ArraySize, Left, Middle);
    mergeSort(Array, ArraySize, Middle + 1, Right);
    mergeArray(Array, ArraySize, Left, Middle, Right);
}

/* 7.堆排序(不稳定):近似完全二叉树,子节点的键值或索引总<（>）其父节点 */
void heapSort_MaxTree(int Array[], int StartIndex, int EndIndex) {
    int ParentIndex = StartIndex;           /* 父节点 */
    int ChildIndex = 2 * StartIndex + 1;    /* 子节点 */
    while (ChildIndex < EndIndex) {
        // 判断挑出 大的子节点 与 父节点 比较
        if (ChildIndex + 1 < EndIndex && Array[ChildIndex] < Array[ChildIndex + 1]) 
            ChildIndex++;
        // 若父节点>子节点,则调整完毕.否则继续调整
        if (Array[ParentIndex] > Array[ChildIndex]) 
            return;
        else {
            // 交换父 子节点
            swap(Array[ParentIndex], Array[ChildIndex]);
            ParentIndex = ChildIndex;
            ChildIndex = 2 * ChildIndex + 1;
        }
    }
}
void heapSort(int Array[], int ArraySize) {
    // 数组初始化:构建大顶堆
    for (int i = ArraySize / 2 - 1; i >= 0; i--) {
        heapSort_MaxTree(Array, i, ArraySize);// 从倒数一半的位置开始,后面的均为最底层树
    }
    // 依次排序并调整：从最后一个元素开始，不断缩小调整范围到第一个元素
    for (int i = ArraySize - 1; i > 0; i--) {
        // 交换Array[0]和Array[i]，交换后Array[i]是Array[0到i]中最大的
        swap(Array[0], Array[i]);
        // 调整Array[0......i]，使其仍为最大堆
        heapSort_MaxTree(Array, 0, i);
    }
}

/* 8.桶排序:将待排序数组映射到不同的桶内,保证桶内有序,再反向输出 */
int digitCount(long long Number) {
    int Counter = 1;
    while (Number /= 10) Counter++;
    return Counter;
}
void bucketSort(int Array[], int ArraySize) {
    // 获取最小值 最大值 确定桶的个数
    int MinValue = Array[0], MaxValue = Array[0];
    for (int i = 0; i < ArraySize; i++) {
        if (MinValue > Array[i]) 
            MinValue = Array[i];
        if (MaxValue < Array[i]) 
            MaxValue = Array[i];
    }
    // 根据位数来创建桶的个数
    int BucketNum = digitCount(MaxValue);
    double BucketRange = (double)(MaxValue - MinValue + 1) / BucketNum;
    vector<vector<int>> Buckets(BucketNum);
    // 初始化桶空间
    for (int i = 0; i < BucketNum; i++) {
        Buckets[i].reserve(ArraySize / BucketNum);
    }
    // 将元素放入对应的桶中
    for (int i = 0; i < ArraySize; ++i) {
        int BucketIndex = (int)((Array[i] - MinValue) / BucketRange);
        Buckets[BucketIndex].push_back(Array[i]);
    }
    // 对桶内的元素进行排序
    for (int i = 0; i < BucketNum; ++i) 
        sort(Buckets[i].begin(), Buckets[i].end());
    // 将桶中的元素按顺序合并得到排序结果
    int index = 0;
    for (int i = 0; i < BucketNum; ++i) {
        for (int j = 0; j < Buckets[i].size(); ++j) 
            Array[index++] = Buckets[i][j];
    }
}

/* 9.计数排序:开辟新的数组;原数组值映射为新数组的键值,原数组值的个数为新数组的数值 */
void countSort(int Array[], int ArraySize) {
    // 找出最大值与最小值
    int Min = Array[0], Max = Array[0];
    for (int i = 0; i < ArraySize; i++) {
        if (Min > Array[i]) 
            Min = Array[i];
        if (Max < Array[i]) 
            Max = Array[i];
    }
    // 根据最大值与最小值之间的元素个数开辟新数组
    vector<int> Count(Max - Min + 1, 0);
    for (int i = 0; i < ArraySize; i++) {
        // 统计相同元素出现的次数
        int OffSet = Array[i] - Min;
        Count[OffSet]++;
    }
    for (int i = 0, Position = 0; i < Count.size(); i++) {
        while ((Count[i]--) != 0) {
            Array[Position] = i + Min;
            Position++;
        }
    }
}

/* 10.基数排序（稳定）:将数字按个十百分开,每位进行比较 */
int maxBit(int Array[], int ArraySize) {
    int MaxValue = Array[0];
    for (int i = 0; i < ArraySize; i++) {
        if (MaxValue < Array[i]) 
            MaxValue = Array[i];
    }
    int Counter = 1;    // 最大位数
    int Max = 10;
    while (MaxValue >= Max) {
        MaxValue /= 10;
        Counter++;
    }
    return Counter;
}
void radixSort(int Array[], int ArraySize) {
    // 十进制数，所以为10
    int MaxCounter = maxBit(Array, ArraySize);
    int *Temp = new int[ArraySize];
    int *Count = new int[10];   // 计数器
    int Radix = 1;
    // MaxCounter次排序
    for (int i = 1; i <= MaxCounter; i++) { 
        // 每次分配前清空计数器
        for (int j = 0; j < 10; j++) 
            Count[j] = 0;
        // 统计每个桶中的记录数
        for (int j = 0; j < ArraySize; j++) {
            int k = (Array[j] / Radix) % 10;
            Count[k]++;
        }
        // 将Temp中的位置依次分配给每个桶
        for (int j = 1; j < 10; j++) 
            Count[j] = Count[j - 1] + Count[j];
        // 将所有桶中记录依次收集到tmp中
        for (int j = ArraySize - 1; j >= 0; j--) {
            int k = (Array[j] / Radix) % 10;
            Temp[Count[k] - 1] = Array[j];
            Count[k]--;
        }
        // 将临时数组Temp的内容复制到Array中
        for (int j = 0; j < ArraySize; j++) 
            Array[j] = Temp[j];
        Radix = Radix * 10;
    }
}

template<typename T_Whz>
void myPrintf(T_Whz Array[], T_Whz ArraySize) {
    for (int i = 0; i < ArraySize; i++) {
        cout << Array[i] << ' ';
    }
    cout << endl;
}

int main() {
    int Array[] = { 9,1,5,8,3,7,4,6,2 };
    int ArraySize = sizeof(Array) / sizeof(Array[0]);
    cout << "Before Sort:" << endl;
    myPrintf(Array, ArraySize);

    radixSort(Array, ArraySize);
    cout << "After Sort:" << endl;
    myPrintf(Array, ArraySize);

    mergeSort(Array, ArraySize, 0, ArraySize - 1);
    cout << "After quickSort:" << endl;
    myPrintf(Array, ArraySize);

    system("pause");
    return 0;
}

颜值国家队
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
常见的几种排序算法（c++）
low5252的博客
03-12 8580
常见的几种排序算法（c++）一、冒泡排序二、插入排序三、选择排序四、归并排序五、希尔排序六、快速排序七、堆排序八、基数排序1.LSD(低位到高位的排序)2.MSD(高位到低位排序)算法比较 一、冒泡排序 1、算法思想 冒泡排序是一种简单的排序算法，通过循环遍历，将临近的两个元素进行比较，满足排序规则时，进行下一组元素对比，当不满足排序规则时，将两个元素交换位置，再继续进行下一组元素对比，确保最大的...
C++的排序
摸鱼中......
04-14 7785
C++十大排序1.快速排序2.插入排序3.选择排序4.冒泡排序5.归并排序6.堆排序7.计数排序8.桶排序9.基数排序10.希尔排序11.补充 稳定排序（排序前后两个相等的数的相对位置不变）：归并排序、冒泡排序、插入排序、基数排序； 非稳定排序：希尔排序、堆排序、选择排序、快速排序。 1.快速排序 快速排序采用分而治之的思想，选取基准值，第一次排序之后将小于等于基准值的值都放在该值前面，将大于等于基准值的值都放在该值后面，接下来对前面的和后面的再次进行快速排序，分而治之直到无法再“分”为止。 #incl
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++十大经典排序算法
客舟中
12-28 5667
代码 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 7316
哈喽，今天我来总结一下C++中的8中排序方法，这些排序在实际开发中能起到一些作用，也可以锻炼你的算法头脑。我也好长时间没上热榜了，这次准备做一个非常详细🔎的总结，看看能不能上热榜。既然叫排序算法，肯定要排序。我们要实现的效果是输入几个数，输出升序（或降序）排序后的结果，并找到时间复杂度最低的算法，应用到实际开发中。冒泡排序主要思路就是遍历数组，比较两个相邻的元素，也就是 arr[j] 和 arr[j+1] ，如果顺序错误就用 swap 函数或空杯交换，交换这两个元素。举个例子，数组是 a[5]={2,1,.
C++十大排序算法代码
08-09
C++十大排序算法代码
十大排序算法c++实现_fish.rar
05-06
十大排序算法c++实现，建议结合下面这篇文章看 ...
C++选择排序算法实例
09-04
主要介绍了C++选择排序算法实例,本文先是介绍了什么是选择排序,然后给出了实现代码,需要的朋友可以参考下
十大排序算法的c++程序实现
05-26
十大排序算法的c++程序实现
C++堆排序算法的实现方法
12-26
本文实例讲述了C++实现堆排序算法的方法，相信对于大家学习数据结构与算法会起到一定的帮助作用。具体内容如下：  首先，由于堆排序算法说起来比较长，所以在这里单独讲一下。堆排序是一种树形选择排序方法，它的...
C++实现五种常见排序算法
weixin_39318565的博客
06-20 4682
排序算法在工作和面试中都经常用到这里是常见的几种算法的C++实现
经典排序算法C++实现（10种）
weixin_42023936的博客
08-27 1833
C++实现经典排序算法插入排序希尔排序（缩小增量排序）选择排序堆排序冒泡排序冒泡排序的原理：快速排序合并排序折中排序新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章U...
十大经典排序算法
nmslqwq的博客
10-10 624
排序算法是《数据结构与算法》中最基本的算法之一。 排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括： 关于时间复杂度 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接...
C++之五种排序方法总结
热门推荐
yszdzjt的博客
08-10 7万+
 模板函数sort( ) sort是一个模板函数:sort( ),括号里可以接受两个或三个参数。这里先说一下两个参数的，因为三个参数的还没研究好，哈哈。 使用sort( )时需要添加头文件&lt;algorithm&gt;,这个英文单词的意思是“ 运算法则”。 接受两个参数时默认的排序方式是升序，添加第三个参数是为了实现降序。第一个参数是所要排序的数列的首地址，而第二个参数是该数列的最后...
C++实现十大排序算法
liuzuoping的博客
12-03 9287
今天我们来用C++实现一下经典的十大排序算法 具体代码与文件可访问我的GitHub地址获取 https://github.com/liuzuoping/Algorithms PS：欢迎star 1 冒泡排序 冒泡排序无疑是最为出名的排序算法之一，从序列的一端开始往另一端冒泡（你可以从左往右冒泡，也可以从右往左冒泡，看心情），依次比较相邻的两个数的大小（到底是比大还是比小也看你心情）。 （无序区...
C++实现七种经典排序算法
森的博客
04-08 3157
利用C++实现七种常见的排序算法： 具体的排序方法如下所示： （1）冒泡排序 基本思想：比较相邻的两个数，如果前者比后者大，则进行交换。每一轮排序结束，选出一个未排序中最大的数放到数组后面。常见冒泡排序算法如下所示： void bubblesort(int *arr,int n) { for (int i = 0; i < n; i++) { for (int j = ...
C++ 常用的八种排序方法
qq_43587345的博客
05-03 6980
C++ 常用的八种排序方法 稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同 插入排序： 思想： （类似打扑克时的排序方法） 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。） 优点：稳定，快 ...
十大排序算法（C++）
沉默、凝视的博客
02-21 567
十大排序算法（C++） 1、冒泡排序 原理：比较相邻两个元素，如果前一个比后一个大则交换二者位置（以升序为例），每进行一轮比较则可以把最大的元素放到相对最后的位置。每进行一轮比较就会有一个元素变为有序。循环对每轮越来越少的元素进行比较则最终变为有序序列。 如果序列元素初始时为有序，则一轮则可进行排序完毕，最好时间复杂度为O(n)；如果序列元素初始时是逆序，则需要n-1轮比较，且每轮要进行n-i次比较，最坏时间复杂度为O(n²)，平均时间复杂度为O(n²)。 // 冒泡排序 void SortBubblin
用C++实现十大经典排序算法
billy的博客
01-04 7858
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
十大排序算法的实现c++
最新发布
08-31
对于十大排序算法中的堆排序、选择排序和冒泡排序算法的C语言实现，可以参考如下代码： 堆排序： ```c void heapify(int *vec, int i, int len) { int left = i * 2 + 1; int right = i * 2 + 2; int largest = i; if (left < len && vec[left > vec[largest]) { largest = left; } if (right < len && vec[right > vec[largest]) { largest = right; } if (largest != i) { int temp = vec[i]; vec[i = vec[largest]; vec[largest = temp; heapify(vec, largest, len); } } void heapSort(int *vec, int len) { for (int i = len / 2 - 1; i >= 0; i--) { heapify(vec, i, len); } for (int j = len - 1; j > 0; j--) { int temp = vec = vec[j]; vec[j = temp; heapify(vec, 0, j); } } ``` 选择排序： ```c void selectionSort(int *vec, int len) { for (int i = 0; i < len - 1; i++) { int minIndex = i; for (int j = i + 1; j < len; j++) { if (vec[j < vec[minIndex]) { minIndex = j; } } if (minIndex != i) { int temp = vec[i]; vec[i = vec[minIndex]; vec[minIndex = temp; } } } ``` 冒泡排序： ```c void bubbleSort(int *vec, int len) { for (int i = 1; i < len; i++) { for (int j = 0; j < len - i; j++) { if (vec[j > vec[j + 1]) { int temp = vec[j]; vec[j = vec[j + 1]; vec[j + 1 = temp; } } } } ``` 这些代码分别实现了堆排序、选择排序和冒泡排序算法，可以通过传入一个整型数组和数组长度来对数组进行排序。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [用C++实现十大经典排序算法](https://blog.csdn.net/qq_34139994/article/details/128217009)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.239^v12^insert_chatgpt"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

颜值国家队

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值