排序

最新推荐文章于 2022-04-29 23:24:15 发布
最新推荐文章于 2022-04-29 23:24:15 发布
阅读量193 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 插入排序 快速排序 优化 三数取中法 冒泡排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kai29/article/details/79431395
版权

这里写图片描述

排序算法稳定性

如果在元素序列中有两个元素R[i]和R[j]，它们的排序码K[i] == k[j]，且
在排序之前，元素R[i]在R[j]的前面。如果在排序之后，元素R[i]仍在R[j]
之前，则称这个排序算法是稳定的，否则称这个排序算法是不稳定的。

内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序

1.直接插入排序

最优情况下，时间复杂度为O(N);(数组有序)
最坏情况下，时间复杂度为O(N^2);
空间复杂度为 O(1)，稳定

代码实现为：

void InsertSort(DataType* a, size_t n)
{
    assert(a);
    for (size_t i = 0; i<n - 1; ++i)//防止溢出，越界
    {
        int end = i;
        int tmp = a[end + 1];
        while (end >= 0 && a[end] > tmp)//循环开始条件
        {
            a[end + 1] = a[end];
            --end;
        }
        a[end + 1] = tmp;
    }

}

这里写图片描述

这里写图片描述

2.希尔排序

是对直接插入排序的优化
最优情况下，时间复杂度为O(N);(数组有序)
最坏情况下，时间复杂度为O(N^2);
空间复杂度为 O(1)，不稳定

希尔排序分为

  1. 预排序->使数组进入有序状态，按间距划分；
  2. 直接插入排序

代码实现为：

void ShellSort(DataType* a, size_t n)
{
    assert(a);
    int gap = n-1;//下标到n-1
    for (size_t i = 0; i < n - gap; ++i)//n-gap防止越界
    {


        gap = (gap/ 3) + 1;//加一为了保证最后一次进行直接插入排序
                //以下同插入排序
        int end = i;
        int tmp = a[end + gap];
        while (end >= 0 && a[end]>tmp)
        {
            a[end + gap] = a[end];
            end -= gap;
        }
        a[end + gap] = tmp;
    }

}

void TestShellSort()
{
    int a[] = { 2, 5, 4, 9, 8, 7, 6, 3, 1, 0 };
    printf("未排序之前：");
    ShellSort(a, sizeof(a) / sizeof(a[0]));
    printf("排序之后：");
    PrintSort(a, sizeof(a) / sizeof(a[0]));

}

过程见下图：
这里写图片描述

执行结果为同上

3.选择排序

时间复杂度为O（N^2）;
空间复杂度为O(1);
不稳定
优点是较为直观
直接插入排序，冒泡排序及选择排序三者最好的是直接插入排序，最差的是选择排序（从多个数里选择）；
代码实现为：

void SelectSort(DataType* a, size_t n)
{
    assert(a);
    int left = 0;
    int right = n-1;

    while (left < right)
    {
        size_t min = left;
        size_t max = right;
        for (size_t i = left; i <=right; ++i)
        {

            if (a[i]>a[max])
                max = i;
            if (a[i] < a[min])
                min = i;

        }
        Swap(&a[left], &a[min]);
        if (a[max] == a[left])//此步骤不可省略
            max = min;
        Swap(&a[right], &a[max]);
        left++;
        right--;
    }

}

思路为：
这里写图片描述

4.堆排序

升序用大堆，降序用小堆
时间复杂度为O(NlgN),
空间复杂度为O（1）；
不稳定

代码实现为：


void AdjustDown(DataType* a, size_t n, size_t parent)
{
    assert(a);
    size_t child = parent * 2 + 1;
    while (child < n)
    {
        if (child + 1 < n&&a[child + 1] > a[child])
        {
            ++child;
        }
        else if (a[child ]>a[parent])
        {
            Swap(&a[child ], &a[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }

    }
}

//把堆顶a[0]元素和当前堆的最后一个元素交换,堆元素个数减1
void HeapSort(DataType* a, size_t n)
{
    //升序采用大堆
    assert(a);
    int i = (n - 2) / 2;
    for (; i < n; --i)
    {
        AdjustDown(a, n, i);//建堆
    }
    int end = n - 1;
    while (end>0)
    {
        Swap(&a[0], &a[end]);
        AdjustDown(a, end, 0);
        --end;
    }

}

**

5. 冒泡排序

**

最好情况时间复杂度O(n)；
最坏情况下时间复杂度O(n*n)
空间复杂度O(1) ；
冒泡排序是一种稳定的排序算法

//冒泡排序
void BubbleSort(DataType* a, size_t n)
{
    assert(a);
    int flag = 0;
    for (size_t i = 0; i < n - 1; i++)
    {
        flag = 0;
        for (size_t j = 0; j < n - i - 1; ++j)
        {
            if (a[j] >a[j + 1])
            {
                flag = 1;
                Swap(&a[j], &a[j + 1]);
            }
        }
        if (flag == 0)
        {
            break;
        }
    }
}
void TestBubbleSort()
{
    int a[] = { 2, 5, 4, 9, 8, 7, 6, 3, 1, 0 };
    BubbleSort(a, sizeof(a) / sizeof(a[0]));
    PrintSort(a, sizeof(a) / sizeof(a[0]));
}

6. 快速排序

其基本思想为：任取待排序元素序列中的某元素作为key，按照该排序码将
待排序集合分割成两子序列，左子序列中所有元素均小于key，右子序
列中所有元素均大于key，然后最左右子序列重复该过程，直到所有元
素都排列在相应位置上为止。

快排最优时间复杂度 O（NlogN）
最差时间复杂度 O(N*N)
空间复杂度为 O（lgN）,理想情况下划分类似二叉树
快速排序不稳定

//方法1
//左右指针法
//[left,right]
int PartSort1(DataType* a, int left, int right)
{
    assert(a);
    int begin = left;
    int end = right;
    int key = a[right];
    while (begin < end)
    {
        //key左边小于key,key右边大于key
        while (begin < end && a[begin] <= key)
            ++begin;
        while (begin < end&&a[begin] >= key)
            --end;

        Swap(&a[begin], &a[end]);
        Swap(&a[begin], &a[right]);//交换key与a[begin]
    }
    return end;
}

这里写图片描述

如果end=right-1,一个有序数组经过排序后将变为无序数组。
while(begin<end && a[begin]<=key)
若此处为小于，在两数相等时，自身交换，陷入死循环。
//方法2
//挖坑法
int PartSort2(DataType* a, int left, int right)
{
    assert(a);
    DataType key = a[right];
    int begin = left;
    int end = right;
    while (begin<end)
    {
        while (begin<end&&a[begin] <= key)
            ++begin;
        a[end] = a[begin];
        while (begin<end&&a[end] >= key)
            --end;
        a[begin] = a[end];
        a[end] = key;
    }
    return end;

}

void QuickSort(DataType* a,int left,int right)
{
    if (left > right)
    {
        return;
    }
    int div = PartSort2(a,left,right);
    QuickSort(a, left, div-1);
    QuickSort(a, div+1 , right);


}

这里写图片描述

//方法3
//前后指针法
int PartSort3(DataType* a, int left, int right)
{
    assert(a);
    int cur = left;
    int prev = left - 1;

    while (cur<right)
    {
        if (a[cur]<a[right] && ++prev!= cur)
        {
            Swap(&a[prev], &a[cur]);
            ++cur;
        }
    }
    Swap(&a[++prev], &a[right]);
    return prev;
}

void QuickSort(DataType* a,int left,int right)
{
    if (left >= right)
    {
        return;
    }
    int div = PartSort3(a,left,right);
    QuickSort(a, left, div-1);
    QuickSort(a, div+1 , right);


}

这里写图片描述

常见的优化方案有：

 1. 随机数法//这里不进行描述，采用随机数的方式
 2. 三数取中（回避快排最差情况）
 3. 小区间优化法
//三数取中法
//三数取中法
//取首元素和尾元素及其中间元素中不大不小的数作为key值
int GetMidNum(DataType* a, int left, int right)
{
    assert(a);
    int mid = left + ((right - left) >> 1);//防止溢出
    if (a[left] < a[right])
    {
        if (a[right] < a[mid])
        {
            return right;
        }
        else if (a[left] < a[mid])
        {
            return mid;
        }
        else
        {
            return left;
        }
    }
    else
    {
        if (a[left]< a[mid])
        {
            return left;
        }
        else if (a[right] < a[mid])
        {
            return mid;
        }
        else
        {
            return right;
        }
    }
}

int PartSort3(DataType* a, int left, int right)
{
    assert(a);
    //每次取较居中的位置
    int midindex = GetMidNum(a, left, right);
    //保证key在数组的右边
    Swap(&a[midindex], &a[right]);

    int cur = left;
    int prev = left - 1;

    while (cur<right)
    {
        if (a[cur]<a[right] && ++prev != cur)
        {
            Swap(&a[prev], &a[cur]);

        }
        ++cur;
    }
    Swap(&a[++prev], &a[right]);
    return prev;
}
void QuickSort(DataType* a,int left,int right)
{
    if (left >= right)
    {
        return;
    }
    int div = PartSort3(a,left,right);
    QuickSort(a, left, div-1);
    QuickSort(a, div+1 , right);


}

//小区间优化法
void QuickSort(DataType* a,int left,int right)
{
    if (left >= right)
    {
        return;
    }
    if (right - left > 10)
    {
        int div = PartSort3(a, left, right);
        QuickSort(a, left, div - 1);
        QuickSort(a, div + 1, right);
    }
    else
    {
        InsertSort( a + left, right - left + 1);//插入排序
    }

}

快速排序非递归

//借助栈实现
void QuickSort1(DataType* a,int left,int right)
{
    Stack s;
    StackInit(&s);
    StackPush(&s, left);
    while (StackEmpty(&s) != 0)
    {
        int end = StackTop(&s);
        StackPop(&s);
        int begin = StackTop(&s);
        StackPop(&s);
        int div = PartSort2(a, begin, end);
        if (begin < div - 1)//begin--div-1
        {
            StackPush(&s, begin);
            StackPush(&s, div - 1);
        }
        if (div + 1 < end)//div+1--end
        {
            StackPush(&s, div + 1);
            StackPush(&s, end);
        }
    }
}

各种排序算法比较：

这里写图片描述

归并排序下篇再续！

最后在此献上

视觉感受各排序算法
http://blog.jobbole.com/11745/
各排序算法比较
http://dsqiu.iteye.com/blog/1707423

写的不好，请多指教啦！欢迎留言哦

kookie29
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
各种排序算法的实现和比较
09-04 126
算法的稳定性 如果待排序表中有两个元素 Ri和 Rj，其对应的关键字keyi= keyj，注意是关键字相等，且在排序前Ri排在Rj前面，如果使用某一算法排序后，Ri仍在 Rj前面，则称这个算法是稳定的，否则是不稳定的。 在排序过程中，根据元素是否完全在内存中，可以将排序算法分为两类：内部排序是指在排序期间元素全部存放在内存中的排序：外部排序是指在排...
六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
热门推荐
HanMeng的博客
07-24 57万+
文章目录：1. 插入排序2.希尔排序 1. 插入排序 步骤： 1.从第一个元素开始，该元素可以认为已经被排序 2.取下一个元素tem，从已排序的元素序列从后往前扫描 3.如果该元素大于tem，则将该元素移到下一位 4.重复步骤3，直到找到已排序元素中小于等于tem的元素 5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置 6.重复步骤2~5 动图演示如下： 思路：   在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个
十大排序算法详解（一）冒泡排序、选择排序、插入排序、快速排序、希尔排序
HK的博客
06-27 18万+
冒泡排序、选择排序、插入排序、快速排序、希尔排序
C++ sort()排序详解
晴空๓
05-05 40万+
本文对C++中的sort()做了一个比较详细的说明，包括为什么选择使用sort()、sort()函数的实现原理、sort()的使用方法等等。
C语言——冒泡排序
记录学习点滴
03-13 43万+
冒泡排序的原理是：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。 以从小到大排序为例，第一轮比较后，所有数中最大的那个数就会浮到最右边；第二轮比较后，所有数中第二大的那个数就会浮到倒数第二个位置……就这样一轮一轮地比较，最后实现从小到大排序。 代码如下 #include<stdio.h> void BBsort(int arr[], int size) { int j,i,tem; for (i = 0; i ..
常用十大排序算法
qq_51664685的博客
04-26 13万+
列举了常见的十大内部排序算法：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序，计数排序，桶排序。
快速排序详解
LiangXiay的博客
11-19 11万+
1.什么是快速排序 我们知道排序有很多种，常见的如希尔排序，插入排序，选择排序，堆排序等等，而快速排序也是排序家族中的一员。因为其在大多数情况下有着优秀的综合性能，快速排序的快速也算是实至名归，接下来就为大家讲解快速排序的思想与实现。 2.快速排序的核心思想 快速排序通过多次比较与交换来完成排序。而这个过程又被分为了多次重复单趟排序，接下来我们先从每一趟的排序讲起。 快速排序的单趟排序思想是： 在一个无序数组中取一个数key，每一趟排序的最终目的是：让key的左边的所有数小于key，key的右边都
【数据结构】八大排序(超详解+附动图+源码)
Edward_Asia的博客
11-21 8万+
前言 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 生活中各种地方都需要用到排序，所以学好排序算法是非常重要的。 排序分为 内部排序 和 外部排序。 内部排序：数据元素全部放在内存中的排序。外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。 这部分主要是内部排序。排序讲解都以升序为例。 常见的排序算法： // 排序实现的接口 // 插入排序 void InsertSort(int* arr..
C语言冒泡排序
小S的博客
04-29 8万+
冒泡排序？不难，这篇就够了！ for(int i=0;i
C语言的5种简单排序算法
Finecsr的博客
04-27 5万+
基本概要： 本文主要介绍五种简单常用的排序算法：冒泡排序，快速排序，插入排序，选择排序，希尔排序，包括它们的基本思想和代码实现。值得一说的是：插入排序，冒泡排序，选择排序平均情况下的时间复杂度为，因此在排序数据较少的情况下较好；而希尔排序和快速排序的平均时间复杂度为，因此在排序数据较多的情况下较好，但是对于快速排序而言，数据基本有序时反而不好，接下来会详细阐述。 1.冒泡排序（Bubble Sort） 基本思想： 冒泡排序是一个非常好理解的排序，顾名思义——冒泡，此时将要排序的数据从上至下排列，从最
排序查询
12-14
排序查询按单个字段排序按表达式 / 别名排序按函数排序按多个字段排序 排序查询：SELECT 查询列表 FROM 表 WHERE 筛选条件 ORDER BY 排序列表(ASC/DESC) AEC/DESC = 升序/降序，默认为升序 ORDER BY 支持单个字段、...
帆软：排序问题（通过帆软设置或者sql排序）
02-26
在数据分析和报表制作的过程中，排序是一项基础且至关重要的任务。帆软报表作为一款强大的报表工具，提供了多种排序方式，既能通过界面配置实现，也能通过SQL查询语句进行控制。本篇将详细介绍如何在帆软中处理排序...
排序动画一
02-12
选择排序是一种不稳定的排序算法，它的基本思想是在未排序的序列中找到最小（或最大）元素，放到排序序列的起始位置，然后再从剩余未排序的元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。...
排序算法（直接插入排序、折半排序、直接选择排序、快速排序与归并排序）
04-04
提供五种排序算法的C++实现方法，输入（待排序元素个数、排序码上界（采用随机生成数组方式）），可选择输出（原始数组、排序后数组、原始数组有序度和无序度、排序过程中数据比较次数与数据移动次数、数组中出现...
关键字排序
06-02
多关键字排序
校园导航
@柠檬少年
08-01 3万+
问题描述 问题描述 设计你的学校的平面图，至少包括10个以上的景点（场所），每两个景点间可以有不同的路，且路长也可能不同，找出从任意景点到达另一景点的最佳路径（最短路径）。 要求： （1）以图中顶点表示校园内各景点，存放景点名称、代号、简介等信息；以边表示路径，存放路径长度等有关信息。 （2）为来访客人提供图中任意景点相关信息的查询。 （3）为来访客人提供...
时间复杂度及空间复杂度
@柠檬少年
12-13 379
一. 时间复杂度时间复杂度实际就是一个函数，该函数计算的是执行基本操作的次 数，而不是程序执行时间。1.在实际中通常关注的是算法的最坏运行情况。 一个算法的最坏情况的运行时间是在任意输入下的运行时间上界。 一般情况下使用O渐进表示法来计算算法的时间复杂度。 2.书写方式： 用常数1取代运行时间中的所有加法常数 在修改后的运行次数函数中，只保留最高阶项 如果最高阶项系数存在且不是1，则去除与这
二叉搜索树应用
@柠檬少年
02-27 374
1.判断一个单词是否拼写正确(递归) //key模型 typedef char* KeyType; typedef char* ValueType; typedef struct BSTreeNode { struct BSTreeNode* _left; struct BSTreeNode* _right; KeyType _key; ValueType _...
（无头）单链表的插，删，查，改及相关测试用例
@柠檬少年
01-03 289
SList.h typedef int DataType; typedef struct SListNode { struct SListNode* _next; DataType _data; }SListNode; SListNode* BuySListNode(DataType x); void SListPrint(SListNode* pHead); void ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值