C++实现排序算法

最新推荐文章于 2025-07-08 15:45:50 发布
最新推荐文章于 2025-07-08 15:45:50 发布
阅读量486 收藏
点赞数 1
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zl_8577/article/details/82629142
本文详细探讨了C++中常见的排序算法，包括冒泡排序、选择排序、插入排序、快速排序和归并排序。通过实例代码解析每种排序算法的工作原理，助你深入理解C++排序算法的实现细节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

#pragma once
#include<iostream>
using namespace std;

//插入排序：时间复杂度：O（lg(N^2)）   空间复杂度：O（1）
//思路：将第i个元素插入到i-1个已排好序的数组中
void InsertSort(int array[], int size)
{
    int i = 0;
    int key = 0;//表示待插入位置的元素
    int end = 0;//表示第i-1个已排好序的最后一个元素
    for (i = 1; i < size; ++i)
    {
        end = i - 1;
        key = array[i];
        while (key < array[end]&&end >= 0)
        {
            array[end + 1] = array[end];
            end--;
        }
        array[end+1] = key;
    }
}

//折半查找法  对i-1个元素进行折半查找，找到第i各元素将要插入的位置
//时间复杂度为O（N^2）查找复杂度为O（nlog2(n)
void BinSort(int array[], int size)
{
    int i = 0;
    int low = 0;
    int high = 0;
    int mid = 0;
    int key = 0;
    for (i = 1; i < size; ++i)
    {
        key = array[i];
        low = 0;
        high = i - 1;
        while (low <= high)
        {
            mid = low + ((high - low) >> 2);
            if (key < array[mid])
                high = mid - 1;
            else 
                low = mid + 1;
        }
        //搬移元素
        for (int j = i; j > low; --j)
            array[j] = array[j - 1];
        array[low] = key;
    }
}


//希尔排序
//思路：1、先将N个元素划分成多个子序列，先对多个子序列进行插入排序，让整个序列接近有序
//      2、划分的序列逐渐减小，直到子序列的个数为一，此时序列才是有序的
//时间复杂度：O（n^1.5）  空间复杂度：O（1）  不稳定
void ShellSort(int array[], int size)
{
    int gap = size;
    int i = 0;
    int key = 0;//表示待插入位置的元素
    int end = 0;//表示第i-1个已排好序的最后一个元素
    while (gap>1)
    {
        gap = gap / 3 + 1;
        for (i = gap; i < size; ++i)
        {
            end = i - gap;
            key = array[i];
            while (key < array[end] && end >= 0)
            {
                array[end + gap] = array[end];
                end -= gap;
            }
            array[end + gap] = key;
        }
    }
}

//简单选择排序   
//每一次找到最大元素的下标，然后将最大元素与最后一个元素进行替换
//时间复杂度：O(n^2)   空间复杂度为O（1）
void SelectSort(int array[], int size)
{
    for (int i = 0; i < size-1; ++i)
    {
        int Maxpos = 0;
        for (int j = 1; j < size - i; ++j)
        {
            if (array[Maxpos]<array[j])//找最大的元素的下标
                Maxpos = j;
        }

        if (Maxpos!=size-i-1)
            swap(array[Maxpos], array[size - i - 1]);
    }
}

//选择排序的优化：一趟遍历过程中同时寻找最大和最小元素
//然后将最小的放在begin位置，最大的放在end的位置
//时间复杂度：O(n^2)      
//空间复杂度：O(1)
void SelectSort1(int array[], int size)
{
        int begin = 0, end = size - 1;
        while (begin < end)
        {
            int Maxpos = begin;
            int Minpos = begin;
            int j = begin + 1;
            while (j <= end)
            {
                if (array[Maxpos]<array[j])//找最大的元素的下标
                    Maxpos = j;
                if (array[j] < array[Minpos])//找最小的元素的下标
                    Minpos = j;
                j++;
            }
            if (Maxpos != end)
                swap(array[Maxpos], array[end]);

            if (Minpos == end)
                Minpos = Maxpos;

            if (Minpos != begin)
                swap(array[Minpos], array[begin]);
            begin++;
            end--;
        }
}

//堆排序   大堆
//时间复杂度 O(nlog(n))   空间复杂度O(1)
void HeapAdjust(int array[], int size, int parent)//大堆  向下调整
{
    //默认左孩子比右孩子大
    int child = parent * 2 + 1;
    while (child < size)
    {
        //找左右孩子最大的元素
        if (child+1 < size && array[child + 1] > array[child])//右孩子大于左孩子
            child += 1;
        //用最大的孩子和其双亲进行比较
        if (array[parent] < array[child])
        {
            swap(array[parent], array[child]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
            return;
    }
}

void HeapSort(int array[], int size)
{
    //创建堆   升序---大堆    
    int root = (size - 2) >> 1;
    for (; root >= 0; --root)
        HeapAdjust(array, size, root);

    //排序：从最后一个元素一次与根节点的元素交换
    int end = size - 1;
    while (end>0)
    {
        swap(array[0], array[end]);
        HeapAdjust(array, end, 0);
        --end;
    }
}

//冒泡排序 
//思路：每一趟，两个相邻的元素进行比较，将最大的元素放在最后
//时间复杂度：O(n^2)
//空间复杂度：O(1)
void BubbleSort(int array[], int size)
{
    for (int i = 0; i < size-1; ++i)
    {
        int flag = 0;
        for (int j = 0; j < size - 1 - i; ++j)
        {
            if (array[j]>array[j + 1])
            {
                swap(array[j], array[j + 1]);
                flag = 1;
            }
        }
        if (flag == 0)
            break;
    }
}

//方法一
//快速排序：先找一个基准值，将比基准值小的元素放在基准值前面
//比基准值大的元素，放在基准值后面，然后返回基准值的下标，利用递归分别对基准值两遍的元素进行排序
//时间复杂度：O(nlog(n))   空间复杂度：空间复杂度:辅助空间*调用次数O(logN)  
int Pation(int array[], int left, int right)
{
    int begin = left,end = right-1;
    int key = array[end];
    while (begin<end)
    {
        while (begin < end&&array[begin] <= key)
            begin++;
        while (begin < end&&array[end] >= key)
            end--;
        if (begin<end)
            swap(array[begin], array[end]);
    }
    if (begin<right - 1)
        swap(array[begin], array[right-1]);
    return begin;
}
//快速排序
void QuickSort(int array[], int left,int right)
{
    if (right - left > 1)
    {
        int div = Pation(array, left, right);
        QuickSort(array, left, div);
        QuickSort(array, div + 1, right);
    }
}

//方法二
//快速排序：挖坑法
//时间复杂度：O(nlog(n))   空间复杂度：空间复杂度:辅助空间*调用次数O(logN)
int Pation1(int array[], int left, int right)
{
    int begin = left, end = right - 1;
    int key = array[end];
    while (begin<end)
    {
        while (begin < end&&array[begin] <= key)
            begin++;
        if (begin < end)
        {
            array[end] = array[begin];
            end--;
        }       
        while (begin<end&&array[end]>=key)
            end--;
        if (begin < end)
        {
            array[begin] = array[end];
            begin++;
        }
    }
    array[begin] = key;
    return begin;
}
//快速排序
void QuickSort1(int array[], int left, int right)
{
    if (right - left > 1)
    {
        int div = Pation1(array, left, right);
        QuickSort1(array, left, div);
        QuickSort1(array, div + 1, right);
    }
}


//方法三  前后指针
//快速排序：
//时间复杂度：O(nlogn)  空间复杂度:辅助空间*调用次数O(logN)
int Pation2(int array[], int left, int right)
{
    int last = left-1, fast = left;
    int key = array[right-1];
    while (fast < right)
    {
        if (array[fast] < key&&++last != fast)
        {
            swap(array[fast], array[last]);
        }
        fast++;
    }
    last++;
    if (last != right)
        swap(array[last], array[right - 1]);
    return last;
}
//快速排序
void QuickSort2(int array[], int left, int right)
{
    if (right - left > 1)
    {
        int div = Pation2(array, left, right);
        QuickSort2(array, left, div);
        QuickSort2(array, div + 1, right);
    }
}
zl_8577
关注
排序算法——C++实现
观则明的博客
10-05 1465
排序算法——C++实现
排序算法总结（C++实现）
aiya_aiya_的博客
03-09 453
这里用C++实现了前七大排序算法，还有三种线性时间排序以后加。 十大排序算法（python3实现） 代码说明： 1.每种算法都封装成void algorithm(int array[], int len)函数 2.数据输入采用STL容器vector以实现任意个数数据的输入 3.只支持int型数据排序，输入其他类型（敲入字符）即可结束数据输入 4.主函数main()加入了可选参...
C++十大排序详解（包括变种优化）
最新发布
7.15之前尽量一天一更，更新C++，Java的相关代码知识（基础）
07-08 883
冒泡排序优化 1. 提前终止优化（标志位优化） 原理： 在每一轮遍历中，若未发生任何元素交换，说明数组已有序，可直接终止排序，避免无效遍历。 优点： 对部分有序的数组效率显著提升（时间复杂度可降为O(n)）。 简单易实现，仅需增加一个标志位。 2. 双向冒泡排序（鸡尾酒排序，Cocktail Shaker Sort） 原理： 在传统单方向冒泡的基础上，增加从右到左的逆向扫描，将较小的元素逐步移到左侧。每轮交替进行双向扫描，减少遍历次数。 优点： 适用于反向有序的数组（如完全降序），效率优于传统冒泡排
C++实现十大排序算法（冒泡排序、选择排序、插入排序、希尔排序、归并排序、堆排序、快速排序、计数排序、桶排序和基数排序）
徐丨若木
09-22 1925
目录 0 概述 1 冒泡排序 2 选择排序 3 插入排序 4 希尔排序 5 归并排序 6 堆排序 7 快速排序 8 计数排序 9 桶排序 10 基数排序 本文为C++实现的十大排序算法及基于排序算法解决的一些常见问题，每一种算法均实际运行，确保正确无误。文中内容为自己的一些理解，如有错误，请大家指正。 0 概述 在十种排序算法中，前七种是比较类排序，后三种是非比较类排序，每种算法的最好、最坏、平均时间复杂度，空间复杂度以及稳定性如下表所示。稳定性是指排序前后相等的元素相对位置保.
排序算法c++实现
qq_45487715的博客
04-21 1283
排序算法 包括归并排序（2个版本，list和vector的），快速排序，堆排序，简单插入排序，选择排序，冒泡排序6种排序的c++代码，还没有整理。 #include <vector> #include <iostream> #include <list> using namespace std; //list非递归版的归并排序，STL中list的merge函数实现方式 void merge(list<int>& list){ list<
Verilog/C++实现排序算法：Verilog/C++实现排序算法：冒泡排序、选择排序、并行全比较排序、串行全比较排序
06-27
在`array_sort`这个项目中，可能包含了实现这些排序算法的C++源代码文件和Verilog模块。通过阅读和分析这些代码，可以深入理解各种排序算法的内部工作原理，以及如何在不同层面（软件和硬件）实现它们。同时，这也为...
C++快速排序算法详解与实现
m0_66371692的博客
06-22 1381
快速排序（Quick Sort）是一种高效的排序算法，由英国计算机科学家东尼·霍尔（Tony Hoare）于 1960 年发明。本文将详细讲解快速排序算法的原理和实现，并通过 C++ 语言展示其代码实现。
【C++】排序算法
phoenixFlyzzz的博客
03-11 1719
冒泡排序、插入排序、选择排序、希尔排序、堆排序、归并排序、快速排序、计数排序、基数排序、桶排序、外排序
C++实现希尔、快速、堆排序、归并排序算法
01-21
本文将详细介绍C++中实现的希尔排序、快速排序、堆排序和归并排序这四种经典排序算法。 希尔排序，由Donald Shell于1959年提出，是一种改进的插入排序。它的基本思想是通过设置一个增量序列，将待排序的元素按照...
C++实现常用排序算法
07-15
C++实现常用排序算法，包括冒泡、选择、插入、归并、快排和堆排。代码完整可运行。
C++实现快速排序算法
WHEgqing的专栏
09-17 638
快速排序采用的是分治法，其平均时间复杂度为O（nlogn） 一趟快速排序的算法是[1]： 　　1）设置两个变量I、J，排序开始的时候：I=0，J=N-1； 　　2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]； 　　3）从J开始向前搜索，即由后开始向前搜索（J=J-1即J--），找到第一个小于key的值A[j]，A[j]与A[i]交换；
C++实现常见排序算法
思考，思考，再思考~
10-04 1021
本程序参考了网上各位大牛和数据结构中的程序，VS2005运行通过，如有问题，请各位大牛指正。 实现的排序有：直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、选择排序、堆排序等等 #include using namespace std; const int l
C/C++实现经典排序算法
xzengwei1313的博客
07-28 328
C/C++实现经典排序算法（重要性：快速排序 > 归并排序 > 选择排序） 1、快速排序：采用分治思想，时间O(nlogn) 空间O(logn) 不稳定 交换位置的次数不恒定(次数受原序列是否有序的限制，越有序越快) void quick_sort(int arr[],int left,int right){ if(left > right) re...
C++实现经典排序算法
青阳的博客
08-10 325
经典的排序算法是面试必备，数量掌握尤其重要。下面笔者将从算法思想、算法时间空间复杂度、算法实现、动图进行逐个展开，最后以表格总结 一、冒泡排序 1.1 基本思想 (1) 比较相邻的元素。如果第一个比第二个大，就交换；（冒泡策略） (2) 对每一对相邻元素作（1）的步骤，从开始第一对到结尾的最后一对，这样在最右端元素就会是最大的数； (3) 针对所有的元素重复以上的步骤，除了最后一个； (4) 重复...
【10种排序算法 (C++实现)】
QTSYlyt的博客
07-19 1283
算法学习中, 这里给出了常用的10种排序算法的C++代码.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值