算法大总结之----10大经典排序算法(从小到大排列)

最新推荐文章于 2022-01-10 18:13:36 发布
最新推荐文章于 2022-01-10 18:13:36 发布
阅读量1w 收藏 56
点赞数 9
分类专栏： c/c++ 算法 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tjw316248269/article/details/105207710
版权

目录

1. 冒泡排序

冒泡排序，顾名思义，就是出头的被排序。其算法复杂度为O( n 2 n^{2} n2)，空间复杂度为O( 1 1 1)。

1.1. 算法讲解

  • 将第j个元素和后面的元素依次对比，如果大于序列为j+1的元素，就进行交换。
  • 作为对比的基础元素j取值范围为"0 => size - 2"。因为j + 1不可超过size - 1。因而，需要进行对比的j有size - 1个，这个组别用字母i表示。
  • 当排序到第i组元素时候，需要做对比的就只需size - i - 1个。以第一次对比为例子，从第一个到最后一个元素都和相邻的两两对比交换，因此这组所有数中最大的已经交换到了最后一位。所以下一次，就不需要考虑它了。第二次，这一组最大的交换到了倒数第二位…。因此需要做对比的就只需size - i - 1个。

1.2. 代码实现

void BubbleSort(int a[], int size)
{
    for (int i = 0; i < size - 1; i++)
    {
        for (int j = 0; j < size - i - 1; j++)
        {
            int temp = 0;
            if (a[j] > a[j + 1])
            {
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
}

2. 选择排序

选择排序也是非常直观的，唯一的好处可能就是不占用额外的内存空间。算法复杂度为O( n 2 n^{2} n2)，空间复杂度为O( 1 1 1)。

2.1. 算法讲解

  • 选择排序认为前i个元素是排序好的，因此将后面的元素排序即可。i的取值范围为0 => size - 1。
  • 对排序第i个元素的那一组，将i的下标暂存(MIN)，并认为这个元素是最小的(a[MIN])。如果后面的元素有比次元素小得，将**a[MIN]**更新为更小的元素，并将所记录的最小元素下标(MIN)也更新。
  • 在这一组遍历结束，如果MIN不是初始值0了，意味着这一组的第一个元素不是最小的，那么将这个最小的元素和第一个元素做交换，以保证从开头到这个元素的这一段是已经排序好的。
  • 将第2步，第3步重复进行直至所有。

2.2. 代码实现

void SelectSort(int a[], int size)
{
    int MIN = 0;
    for (int i = 0; i < size - 1; i++)
    {
        MIN = i;
        for (int j = i + 1; j < size; j++)
        {
            if (a[j] < a[MIN])
            {
                MIN = j;
            }
        }
        if (MIN != i)
        {
            int temp = 0;
            temp = a[i];
            a[i] = a[MIN];
            a[MIN] = temp;
        }
    }
}

3 插入排序

插入排序就好像打扑克牌整理牌组一样，从后面看起，如果此牌小于前面整理好的牌，就插入前面，因而前面整理好的牌，在被插入的后面的，依次后移一位。
可以说插入排序是远离最直观的，算法复杂度为O( n 2 n^{2} n2) ，空间复杂度为O( 1 1 1)。

2.1. 算法讲解

  • 排序分为若干组进行，其中的一组为从第i个元素开始，直到最后一个元素为止。
  • 由于每进行一次排序，前面的都已经排序完成，因此只需对比这第i个元素是不是比前面i-1个元素小就行。
  • 若第i个元素小于前面i-1个元素中的第j个元素，就首先将这第i个元素记录下来，然后把从第j个元素到第i-1个元素依次后移，最后再把记录下来的元素，插入第j个位置。
  • 将此步骤进行循环即可。

2.2. 代码实现

void InsertSort(int a[], int size)
{
    int i, j, temp;
    for (i = 1; i < size; i++)
    {
        if (a[i] < a[i - 1])
        {
            temp = a[i];
            for (j = i - 1; j >= 0 && a[j] > temp; j--)
            {
                a[j + 1] = a[j];
            }
            a[j + 1] = temp;
        }
    }
}

4 希尔排序

2.1. 算法讲解

2.2. 代码实现

void ShellSort(int a[], int size)
{
    for (int gap = size / 2; gap > 0; gap /= 2)
    {
        for (int i = gap; i < size; i++)
        {
            int temp = a[i];
            int j = 0;
            for (j = i - gap; j >= 0 && a[j] > temp; j -= gap)
            {
                a[j + gap] = a[j];
            }
            if (j != 0)
                a[j + gap] = temp;
        }
    }
}

5 归并排序

归并排序是要将元素先分组，分到两两一组，然后再合并，合并时候，按大小合并。其算法复杂度为O( n l o g 2 n nlog_2n nlog2​n)，空间复杂度为O( n n n)。

2.1. 算法讲解

2.2. 代码实现

void MergeSort(int a[], int left, int right)
{
    if (left >= right)
        return;

    int Len = right - left + 1;
    int mid = (right + left) / 2;
    int start1 = left;
    int end1 = mid;
    int start2 = mid + 1;
    int end2 = right;
    MergeSort(a, start1, end1);
    MergeSort(a, start2, end2);

    int i = 0;
    int *temp = (int *)malloc(Len * sizeof(int));
    while (start1 <= end1 && start2 <= end2)
    {
        temp[i++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
    }
    while (start1 <= end1)
        temp[i++] = a[start1++];
    while (start2 <= end2)
        temp[i++] = a[start2++];

    for (int k = left, i = 0; k <= right; k++, i++)
        a[k] = temp[i];

    free(temp);
}

6 快速排序

快速排序和归并排序都是分治的思想，归并排序是相邻元素两两分组最后按大小合并，而快速排序则是选定一个基准元素，小于此基准的放在左侧，大于的放在右侧(相同的随意)。依据这样的原理实现分而治之的思想。其算法复杂度为O( n l o g 2 n nlog_2n nlog2​n)，空间复杂度为O( n l o g 2 n nlog_2n nlog2​n)。

6.1. 算法讲解

  • 下面程序是一个递归的解法，首先要确定low < high。
  • 将数组依次寻找基准元素，分而治之，迭代的目的就是运行QucikPartition函数，实现在组内，将小于基准元素的放在左侧，大于的放在右侧。
  • 这个基准元素我选用的是a[high]，选用其它的，比如a[low]也可以，但要注意，需保持一定的规律性。
  • 将a[high]作为基准元素pivot
  • 预先保存下标low作为增量，并从low开始遍历
  • 当遍历元素小于基准，则和a[i]进行交换
  • 最后a[i]再和基准元素a[high]交换

第一次遍历

  • 光看描述肯定有人不清楚，我以第一次选基准分组过程列出来，很明显可以看到，随着i，j增加，和数次的交换，使得小于6的交换到了左侧，大于6的交换到了右侧。
  • 这样的步骤循环进行，知道low >= high结束，快速交换就完成了。

6.2. 代码实现

void swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

int QuickPartition(int a[], int low, int high)
{
    int pivot = a[high];
    int i = low;
    for (int j = low; j < high; j++)
    {
        if (a[j] < pivot)           
        {
            swap(&a[i], &a[j]);
            i++;
        }
    }
    swap(&a[i], &a[high]);
    return i;
}

void QuickSort(int a[], int low, int high)
{
    if (low < high)
    {
        int pivot = QuickPartition(a, low, high);
        QuickSort(a, low, pivot - 1);
        QuickSort(a, pivot + 1, high);
    }
}

7 堆排序

2.1. 算法讲解

通过建立大顶堆或小顶堆来进行排序。在排序过程中，不停的调整堆顶元素和堆尾元素。

我是看的这个：堆排序-C语言实现

2.2. 代码实现

#include<stdio.h>
typedef int ElementType;
int arr1[11]={0,2,87,39,49,34,62,53,6,44,98};
#define LeftChild(i) (2 * (i) + 1)

void Swap(int* a,int* b)
{
    int temp=*a;
    *a=*b;
    *b=temp;
}


void PercDown(int  A[], int i, int N)
{
    int child;
    ElementType Tmp;

    for (Tmp = A[i]; 2*i+1 < N; i = child){
        child = 2*i+1; //注意数组下标是从0开始的，所以左孩子的求发不是2*i
        if (child != N - 1 && A[child + 1] > A[child])
            ++child;                //找到最大的儿子节点
        if (Tmp < A[child])
            A[i] = A[child];
        else
            break;
    }
    A[i] = Tmp;
}

void HeapSort(int A[], int N)
{
    int i;
    for (i = N / 2; i >= 0; --i)
        PercDown(A, i, N);    //构造堆
    for(i=N-1;i>0;--i)
    {
        Swap(&A[0],&A[i]);        //将最大元素（根）与数组末尾元素交换，从而删除最大元素，重新构造堆
        PercDown(A, 0, i);
    }
}

void Print(int A[],int N)
{
    int i;
    for(i=0;i<N;i++)
    {
        printf(" %d ",A[i]);
    }
}
int main()
{
    int arr[10]={2,87,39,49,34,62,53,6,44,98};
    Print(arr,10);
    printf("\n");
    HeapSort(arr,10);
    Print(arr,10);
    printf("\n");
    return 0;
}

8 计数排序

2.1. 算法讲解

2.2. 代码实现

void CountSort(int a[], int size)
{
    int MAX = 0;
    for (int i = 0; i < size; i++)
        MAX = a[i] > MAX ? a[i] : MAX;
    MAX++;   //容器的数量为最大元素值+1(因为从0开始)
    
    int *sort = (int *)malloc(size * sizeof(int));  //排序好的数组
    int *container = (int *)malloc(MAX * sizeof(int));  //容器
    memset(sort, 0, size * sizeof(int));
    memset(container, 0, size * sizeof(int));

    for (int j = 0; j < size; j++)
        container[a[j]]++;

    for (int k = 1; k < MAX; k++)
        container[k] += container[k - 1];

    for (int m = size; m > 0; m--)
        sort[--container[a[m - 1]]] = a[m - 1];

    for (int n = 0; n < size; n++)
        a[n] = sort[n];

    free(sort);
    free(container);
}

9 桶排序

桶排序，顾名思义，就是对桶来排序，并且桶内盛放一定元素。因而，桶排序可以宏观上分为两个步骤：桶内元素的排序和桶的排序。
桶内元素的排序可以是冒泡排序，可以是快速排序，也可以是其他排序，甚至可以是递归的桶排序，是否稳定以及空间时间复杂度，很大程度取决于桶内元素的排序方式。
桶排序其实可以看作是计数排序的进阶版，只不过，计数排序相当于每个桶只放相同的元素，而桶排序是桶内放入处于一定区间的元素。

2.1. 算法讲解

2.2. 代码实现

10 基数排序

2.1. 算法讲解

之后再写吧

2.2. 代码实现

附录

1. 10大经典排序算法性能分析

2. C/C++的内置排序函数

其实平时写程序，用到排序是很多的，不多平时都是调用 sort函数(c++)/qsort 函数(c语言)函数了，调用函数对做项目是很好的，可也不要忘了怎么实现的，基础知识不能丢。
这里顺便给不清楚 sort函数(c++)/qsort函数(c语言) 的朋友说下。

2.1. c++的sort函数

2.1.1. 函数简述

头文件中函数定义为：

template <class _RanIt, class _Pr>
void sort(const _RanIt _First, const _RanIt _Last, _Pr _Pred) { // order [_First, _Last), using _Pred
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    _Sort_unchecked(_UFirst, _ULast, _ULast - _UFirst, _Pass_fn(_Pred));
}

简单版本的定义：sort(begin, end, cmp)
参数：

  • _First(start)：起始元素指针位置
  • _Last(end)：终止元素指针位置
  • _Pr_pred(cmp)：排序规则，这是函数指针，回调函数的简单运用
2.1.2. cmp叙述

这是一个函数指针，回调函数的运用。
最简单的单元素大小：

bool cmp(int a,int b)
{
    return a > b;
}

结构体排序:

typedef struct _stu
{
	int age;
	string name;
}stu;

bool cmp(stu a, stu b)
{
	return a.age < b.age;
}
2.1.3. 代码实现

对结构体的排序做一次代码示例

#include <iostream>
#include <algorithm>
#include <time.h>
using namespace std;

typedef struct _stu
{
	int age;
	string name;
}stu;

bool cmp(stu a, stu b)
{
	return a.age < b.age;
}

int main()
{
	stu student[10];
	for (int i = 0; i < 10; i++)
	{
		srand(i);  //随机数种子
		student[i].age = rand() % 20;  //生成不大于20的随机数
		student[i].name = "LiLei";
	}
	for (int i = 0; i < 10; i++)
	{
		cout << "The " << i << "th student age=" << student[i].age << " name=" << student[i].name << endl;
	}
	sort(student, student + 10, cmp);
	//student是结构体其实元素指针位置，student + 10是终止元素位置
	cout << "*********************************" << endl;
	for (int i = 0; i < 10; i++)
	{
		cout << "The " << i << "th student age=" << student[i].age << " name=" << student[i].name << endl;
	}
	return 0;
}

2.2 c语言的qsort函数

2.1.1. 函数简述

函数原型和**C++**类似，为：void qsort(void *base, size_t nitems, size_t size, int (*cmp)(const void *, const void*)))。
参数：

  • base: 指向要排序的数组的第一个元素的指针。
  • nitems: 由 base 指向的数组中元素的个数。
  • size: 数组中每个元素的大小，以字节为单位。
  • cmp: 用来比较两个元素的函数，即函数指针（回调函数）
2.1.2. cmp叙述

注意和**C++**的cmp区别
对整数数组

int cmp(const void *a,const void *b)
{
	return *(int*)a - *(int*)b;
}

对结构体

typedef struct _stu
{
	int age;
	char name[10];
}stu;

int cmp(const void* a, const void* b)
{
	stu* A = (stu*)a;
	stu* B = (stu*)b;
	return A->age - B->age;
}

C语言中的cmp是将指针转为void指针的。

2.1.3. 代码实现

对结构体的排序做一次代码示例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct _stu
{
	int age;
	char name[10];
}stu;

int cmp(const void* a, const void* b)
{
	stu* A = (stu*)a;
	stu* B = (stu*)b;
	return A->age - B->age;
}

int main()
{
	stu student[10];
	for (int i = 0; i < 10; i++)
	{
		srand(i);
		student[i].age = rand() % 20;
		strcpy(student[i].name, "LiLei");
	}
	for (int i = 0; i < 10; i++)
	{
		printf("The %dth student age=%d, name=%s\n", i, student[i].age, student[i].name);
	}
	qsort(student, 10, sizeof(stu), cmp);  //注意这里和sort的区别
	printf("*********************************\n");
	for (int i = 0; i < 10; i++)
	{
		printf("The %dth student age=%d, name=%s\n", i, student[i].age, student[i].name);
	}
	return 0;
}
FrankJT
关注
专栏目录
排序算法（从小到大排序）
m0_61005197的博客
02-16 1723
排序算法
排序算法--选择排序实现从小到大排列（使用函数和指针）
weixin_45541789的博客
08-12 1833
选择排序的时间复杂度是O(N^2) //选择排序实现从小到大排序 #include<stdio.h> void swap(int *a,int *b){ int temp; temp=*a; *a=*b; *b=temp; }; int main(){ int n,i,j,minIndex; while(~scanf("%d",&n)){ int a[n]; for(i=0;i<n;i++){ scanf("%d",&a[i]); } f
从小到大排序
Saber1378418070的专栏
04-16 638
#include int main () { int i,j,t; int a[10]; printf("请输入一串数:"); for(j=0;j scanf("%d",&a[j]); for(i=0;i { for(j=0;j { if(a[j] { t = a[j]; a[j] = a[j-1]; a[j-1] = t; } } } for(j=0;j
十种常见的排序算法
weixin_30920091的博客
08-03 4140
1.常见算法分类 十种常见排序算法一般分为以下几种： （1）非线性时间比较类排序：交换类排序（快速排序和冒泡排序）、插入类排序（简单插入排序和希尔排序）、选择类排序（简单选择排序和堆排序）、归并排序（二路归并排序和多路归并排序）； （2）线性时间非比较类排序：计数排序、基数排序和桶排序。 总结： （1）在比较类排序中，归并排序号称最快，其次是快速排序和...
NYOJ41 - 三个数从小到大排序
weixin_30693183的博客
01-25 140
描述： 现在要写一个程序，实现给三个数排序的功能 输入： 输入三个正整数 输出： 给输入的三个正整数排序 样例输入： 20 7 33 样例输出： 7 20 33 #include<stdio.h> int main(){ int a,b,c,t; scanf("%d%d%d",&a,&b,&c...
算法学习（3）十大经典排序算法动画
a83025273的博客
12-05 339
排序算法是《数据结构与算法》中最基本的算法之一。 排序算法可以分为内部排序和外部排序。 内部排序是数据记录在内存中进行排序。 而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。 用一张图概括： 关于时间复杂度： 平方阶 (O(...
排序方法总结(从小到大)
Gamedev
07-03 6811
1. 简单排序简单排序的思路很简单，即：用两重循环，从数组最开始依次取一个数，并将其和它后面的的所有数比较，通过交换 依次得到数组中最小的数、次小的数…知道外层循环遍历完，数组排序完成。这个算法可以优化，见第三类。for(i=0;i<n-1;i++) for(j=i+1;j<n;j++) if(a[i]>a[j]){ temp=a[min];
ti-idf算法，实现对英文文档的检索，把多篇文档中的词（英文单词），按照权值从小到大进行排列...
07-08
TI-IDF（Term Frequency-Inverse Document Frequency）算法是一种在信息检索和自然语言处理领域广泛应用的统计方法，用于评估一个词在文档集中的重要性。它结合了词频（Term Frequency, TF）和逆文档频率（Inverse ...
排序算法--冒泡排序实现从小到大排列（使用函数和指针）
weixin_45541789的博客
08-11 2730
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
排序算法--插入排序实现从小到大排列（使用函数和指针）
weixin_45541789的博客
08-12 869
插入排序的时间复杂度最低为O(N),最高为O(N^2) //插入排序（工作可能用到）实现从小到大排序 #include<stdio.h> void swap(int *a,int *b){ int temp; temp=*a; *a=*b; *b=temp; } int main(){ int n,i,j; while(~scanf("%d",&n)){ int a[n]; for(i=0;i<n;i++){ scanf("%d",&a[i]);
从小到大排序的程序 c++
08-22
这是一个自己编的大小顺序 排序的程序，自己可以决定输入几个数，并输出大小结果
Go语言-排序算法：冒泡排序-综合文档
05-14
**冒泡排序**是计算机科学中一种基础且经典的排序算法，它通过重复遍历待排序的元素列表，比较相邻元素并根据需要交换它们的位置来逐步将列表中的元素按顺序排列。在Go语言中，实现冒泡排序同样简单易懂，这使得它...
算法系列15天速成——第二天 七大经典排序【中】
weixin_34049032的博客
11-16 147
首先感谢朋友们对第一篇文章的鼎力支持，感动中.......    今天说的是选择排序，包括“直接选择排序”和“堆排序”。   话说上次“冒泡排序”被快排虐了，而且“快排”赢得了内库的重用，众兄弟自然眼红，非要找快排一比高下。 这不今天就来了两兄弟找快排算账。   1.直接选择排序：  先上图：   说实话，直接选择排序最类似于人的本能思想，比如把大小不一的玩具让三岁小毛孩对...
排序算法，从大到小
追求专业
11-11 315
1、得到list中最大的那个值 public OppoSiteInfo getMaxMatch(List&lt;OppoSiteInfo&gt; list){ float maxScore = 0; int index = 0; for(int i=0;i&lt;list.size();i++){ if(list.get(i).getMatchScore() &gt; ...
排序集合
不死之心
08-20 517
排序方法        平均情况        最好情况        最坏情况        辅助空间        稳定性 冒泡排序         O(n^2)           O(n)              O(n^2)            O(1)                稳定 选择排序         O(n^2)          O(n^2)      
七种排序算法
m0_62292821的博客
01-10 853
本期博客来讲述常见的几种排序算法 那么，什么是排序？ 排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。有了排序，可以让代码呈现的内容更加明了，格式更容易吸引他人眼球。对一组数据进行有序地排列是经常需要做的事情，所以掌握几种甚至更多的排序算法是绝对有必要的 话不多说，正文开始： 1.冒泡排序 冒泡排序适合数据规模很小的时候，因为这种算法的效率比较低。冒泡排序的核心思想是两两比较，将符合某一条件的一者升上去，遍历一次后最小的到了最上面，然后再继续遍历，让剩余最小的继
python从小到大排序不用sort_python怎么从小到大排列
最新发布
06-09
你可以使用 Python 内置的 sorted() 函数来进行从小到大的排序。以下是一个例子： ```python numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] sorted_numbers = sorted(numbers) print(sorted_numbers) ``` 输出: ``` [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9] ``` 在上面的例子中，我们将一个包含一些数字的列表传递给了 sorted() 函数。函数返回一个新的排好序的列表，我们将其存储在 sorted_numbers 变量中，并将其打印出来。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值