排序算法（C语言）

最新推荐文章于 2022-12-27 09:18:59 发布
最新推荐文章于 2022-12-27 09:18:59 发布
阅读量720 收藏 8
点赞数 4
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LANGJ1/article/details/110937618
版权

冒泡排序

选择排序

插入排序

希尔排序

快速排序

计数排序

睡眠排序

猴子排序
 
 

冒泡排序

冒泡排序(Bubble Sort)，原理为从头（水底）开始，依次比较相邻元素的大小，若前一个元素比后一个大（以升序为例），则交换两个元素，直到把最大的元素放到尾部（浮出水面）；接下来，依次把第二大，第三大…的元素放在尾部，直到整个序列有序。
冒泡排序的优化：检测每一次排序是否有元素交换发生，若某次排序没有元素交换，证明序列已有序，可退出循环。

#include <stdio.h>

void swap(int* a, int* b);
void maopao(int *arr, int size);

int main()
{
    int size;
    scanf("%d", &size);
    int arr[1000];
    for(int i = 0; i < size; i++)
        scanf("%d", &arr[i]);
    maopao(arr, size);
    for(int i = 0; i < size; i++)
        printf("%d ", arr[i]);
}

void maopao(int *arr, int size)  
{  
    int tmp, change = 1;  
    for (int i = 0; i < size - 1 && change; i++)
    {
        change = 0;
        for (int j = 0; j < size - i - 1; j++) 
        {
            if (arr[j] > arr[j+1])//比较相邻的元素,如果第一个比第二个大，就交换它们两个
            {
                swap(&arr[j], &arr[j+1]);
            }
        }
    }
}

void swap(int *a, int *b)
{
    int tmp;
    tmp = *a;
    *a  = *b;
    *b  = tmp;
}
时间复杂度：O(N2)
稳定性：稳定

 
 

选择排序

选择排序（Selection Sort），原理为寻找最大元素（以升序为例），将其放置尾部，再寻找第二大元素，将其置于尾部…直至整个序列有序。

#include <stdio.h>

void swap(int *a, int *b);
void xuanze(int *arr, int size);

int main()
{
    int size;
    scanf("%d", &size);
    int arr[1000];
    for(int i = 0; i < size; i++)
        scanf("%d", &arr[i]);
    xuanze(arr, size);
    for(int i = 0; i < size; i++)
        printf("%d ", arr[i]);
}

void xuanze(int *arr, int size)
{
    int k, tmp;//k为待排序序列中最大值元素下标
    for (int i = 0; i < size - 1; i++) 
    {
        k = i;
        for (int j = i + 1; j < size; j++)
            if (arr[j] < arr[k])
                k = j;
        swap(&arr[i], &arr[k]);
    }
}

void swap(int *a, int *b)
{
    int tmp;
    tmp = *a;
    *a  = *b;
    *b  = tmp;
}
时间复杂度：O(N2)
稳定性：不稳定

 
 

插入排序

插入排序（Insertion Sort），原理为将一个个元素插入到有序列的合适位置，使得新的序列依然有序。

#include <stdio.h>

void charu(int *arr, int size);

int main()
{
    int size;
    scanf("%d", &size);
    int arr[1000];
    for(int i = 0; i < size; i++)
        scanf("%d", &arr[i]);
    charu(arr, size);
    for(int i = 0; i < size; i++)
        printf("%d ", arr[i]);
}

void charu(int *arr, int size)    
{    
    int tmp;    
    for (int i = 1; i < size; i++)//取未排序数列首位数
    {    
        if (arr[i] < arr[i-1])//若该数大于有序数列末位数，则不用移动位置，置于尾端即有序
        {    
            tmp = arr[i];//将该数存在tmp处
            for (int j = i - 1; j >= 0 && arr[j] > tmp; j--)//将数列由尾端向前扫描，找到该数正确位置
            {
                arr[j+1] = arr[j];
            }
            arr[j+1] = tmp;//插入该数
        }
    }
}
时间复杂度：O(N2)
稳定性：稳定

 
 

希尔排序

希尔排序(Shell’s Sort)的核心是以某个增量h为步长跳跃分组（类似于按该增量报数，报相同数的元素为一组）进行插入排序。由于分组的步长h逐步缩小, 所以也叫“缩小增量排序”（Diminishing Increment Sort）。
希尔排序的时间复杂度是所取步长序列的函数, 该函数在数学上无确定的解, 所以一直以来SHELL算法的分析被认为是一个复杂的问题。下面，给出常见的shell增量。

  • 原始希尔序列：d(max)=N/2, d(i)=d(i+1)/2
  • Hibbard增量序列：d(k)=2^k-1
  • Sedgewick增量序列：{1, 5, 19, 41, 109…} 猜想：d(i)=9×4i- 9x2i +1或d(i)=4i-3x2i+1

有关shell增量的研究
下面的代码以原始希尔序列为例

#include <stdio.h>

void xier(int *arr, int size);

int main()
{
    int size;
    scanf("%d", &size);
    int arr[1000];
    for(int i = 0; i < size; i++)
        scanf("%d", &arr[i]);
    xier(arr, size);
    for(int i = 0; i < size; i++)
        printf("%d ", arr[i]);
}

void xier(int *arr, int size)
{
    int tmp, j, d;
    for (d = size/ 2; d > 0; d /= 2)//确定增量大小
    {
        for (int i = d; i < size; i++)//对每个子数列进行插入排序
        {
            tmp = arr[i];
            for (j = i - d; j >= 0 && tmp < arr[j]; j -= d)
            {
                arr[j + d] = arr[j];
            }
            arr[j + d] = tmp;
        }
    }
}
时间复杂度：
  • 原始希尔序列 Tworse=O(n2)
  • Hibbard增量序列 Tworse=O(n3/2)
  • Sedgewick增量序列 Tworse=O(n4/3)
稳定性：不稳定

 
 

快速排序

快速排序（Quick Sort）是对冒泡排序的一种改进。其原理为通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有元素都比另外一部分都要小，然后再按此方法对这两部分数据分别进行快速排序，直至整个序列有序。

#include<stdio.h>

void kuaisu(int *arr, int left, int right);

int main()
{
	int size;
	scanf("%d", &size);
	int arr[1000];
	for(int i = 0; i < size; i++)
		scanf("%d", &arr[i]);
	kuaisu(arr, 0, size-1);
	for(int i = 0; i < size; i++)
        printf("%d ", arr[i]);
}

void kuaisu(int arr[], int left, int right)
{
	if (left >= right) 
	{
		return;
	}
	int i = left;
	int j = right;
	int centre = arr[left];
	while (i < j)
	{
		while (i < j && centre <= arr[j])//从右向左依次搜索，找一个比中心数小的
		{
			j--;
		}
		arr[i] = arr[j];//把这个数放在左端
		while (i < j && arr[i] <= centre)//从左向右依次搜索，找一个比中心数大的
		{
			i++;
		}
		arr[j] = arr[i];//把这个数放在右端
	}
	arr[i] = centre;//更新中心数位置
	kuaisu(arr, left, i - 1);
	kuaisu(arr, i + 1, right);
}
时间复杂度：O(Nlog2N)
稳定性：不稳定

 
 

计数排序

计数排序（Counting Sort）是一种不基于比较的排序算法。其原理为对于序列中每一个元素，统计比它小（或大）的元素个数，以找到该元素的正确位置。

#include <stdio.h>

int max(int *arr, int size);
int min(int *arr, int size);
void countingSort(int *arr, int size, int range, int Min);

int main()
{
    int size;//元素个数
    scanf("%d", &size);
    int *arr = (int *)malloc(size*sizeof(int));
    //输入
    for(int i = 0; i < size; i++)
        scanf("%d", &arr[i]);
    int range;//元素值的范围
    range = max(arr,size) - min(arr,size) + 1;
    int Min = min(arr,size);
    countingSort(arr, size, range, Min);
    //输出
    for(int i = 0; i < size; i++)
        printf("%d ",arr[i]);
}

int max(int *arr, int size)
{
    int max = arr[0];
    for(int i = 1; i < size; i++)
        if(arr[i] > max) max = arr[i];
    return max;
}

int min(int *arr, int size)
{
    int min = arr[0];
    for(int i = 1; i < size; i++)
        if(arr[i] < min) min = arr[i];
    return min;
}

void countingSort(int *arr, int size, int range, int Min)
{
    int *counting = (int *)malloc(range*sizeof(int));
    //初始计数数组
    for(int i = 0; i < range; i++)
        counting[i] = 0;
    //计数数组开始计数
    for(int i = 0; i < size; i++)
        counting[arr[i]-Min]++;
    int d = 0;//用于遍历计数数组时，表示当前位置
    for(int i = 0; i < size; i++)
    {
        while(counting[d]==0) d++;
        arr[i] = d + Min;
        counting[d]--;
    }
}
时间复杂度：O(N+k) (k为元素值的范围，即arrmax - arrmin+1)
稳定性：稳定

 
 

睡眠排序

睡眠排序（Sleep Sort）：

通过为待排序的元素启动独立的任务，每个任务按照待排元素的key执行相对应的睡眠时间，然后及时的将序列中的元素收集到一起，达到排序的目的。

人话来讲：

睡眠排序主要是根据CPU的调度算法实现的，对一组数据进行排序，不能存在负数值，这个数是多大，那么就在线程里睡眠它的10倍再加10，不是睡眠和它的数值一样大的原因是，当数值太小时，误差太大，睡眠的时间不比输出的时间少，那么就会存在不正确的输出结果。

某dalao的代码

#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main(int c, char **v)
{
        while (--c > 1 && !fork());
        sleep(c = atoi(v[c]));
        printf("%d\n", c);
        wait(0);
        return 0;
}

 
 

猴子排序

猴子排序（Bogo Sort），望文生义 顾名思义，就是猴子的排序方法。
我们先介绍无限猴子定理：我们有一只会打字的猴子，不过这只猴子不识字，只会在键盘上乱敲（像极了写代码的我）。在无穷长的时间后，即使是随机打字的猴子也可以打出一些有意义的单词，比如，cat, dog。因此，可以类推，会有一个足够幸运的猴子或连续或不连续地打出一本书，即使其几率比连续抓到一百次同花顺还要低。但在足够长的时间（长到你数不清它的秒数有多少位）后，其发生是必定的。
于是，现在我们有一只会排序的猴子。它不懂算法，甚至看不懂数字，所以只会将数字随意排列。现有一无序数列，不断随机排列该数列元素的顺序，在无限长的时间内，该数列必定会变成有序的。我们只需在它变为有序时，停止随机排序，即可得到有序数列。

下面是伪代码：

#include <stdio.h>
#include "monkey.h"

int judge(int *arr, int size);

int main(int argc, char const *argv[])
{
    int size;
    scanf("%d",&size);
    int *arr = (int *)malloc(size*sizeof(int));
    while(judge(arr,size))
    {
        monkeysort(arr, size);
    }
    for(int i = 0; i < size; i++)
        printf("%d ",arr[i]);
}

int judge(int *arr, int size)
{
    for(int i=1;i<size;i++)
    {
        if(arr[i]<arr[i-1]) return 1;
    }
    return 0;
}

 
 

量子猴排

“其实我一直不知道这个怎么翻译比较好听，然后看到有人答了“量子猴排”觉得翻译得很好。猴子排序或者说Bogo sort肯定很多人都知道，但是它的问题很明显，太慢了。好在量子物理的发展，给了我们用这个方法解决问题的一线生机。
所谓量子猴排就是洗牌的时候，使用量子化随机排列（quantumly randomized）。这样的话，我们在观测这组数之前，这组数的状态是叠加的，参见Schrรถdinger’s cat。通过这种量子化随机排列，我们划分出来了个平行宇宙。接下来，在某个宇宙00729中，观测一下这组数，发现运气不好，没有排序好，那么我们就销毁掉这个宇宙。然后再看看其他宇宙的运气怎么样。终于，在一个宇宙04008中，发现刚好是排好序的数组。那么我们就保留宇宙04008。最后，没有被销毁的宇宙中，数组都是恰好一次被排好序的。
算法结束,我们来分析一下量子猴排的时间复杂度。嗯，O(N) ,看是不是快了很多。”
 
 

蠢猴排序

“了解了猴子排序和量子猴排，有的同学们可能并不会觉得慢或者麻烦。相反，说不定觉得其实猴子排序还是太快了呢？！所以就有了蠢猴排序。
蠢猴排序，就是先将一个元素猴子排序一下，这是最简单的。然后拷贝第二个元素进来，判断一下大小，如果顺序不对则对这两个元素猴子排序一下。接下里拷贝第三个元素进来，在判断一下这下顺序是不是错了，如果错了则再对这三个元素猴子排序一下……一直这么进行下去。

关于蠢猴排序的时间复杂度
有的人说是 O（ n×(n!)n ） ,
有的人说是 O（ (n!)n-k ）,
有的人说是 O（ (n!)n! ）…

反正大家大致的意思是，用蠢猴排序来对一个稍微长点的乱序数组进行排序的话，就有可能一直运行到宇宙的热寂（Heat death of the universe）都不会结束。”

浪极
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C/C++ Bogo Sort猴子排序算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-04 7105
Bogo Sort，也称为猴子排序算法，是一种无脑且低效的排序算法。它的原理是将待排序的元素随机打乱，然后检查是否已经排好序，如果没有，就再次随机打乱，重复这个过程直到排序完成。
排序算法——猴子排序
私のBookShelf
12-16 6856
猴子排序 让一群猴子在打印机前昼夜不停地敲打键盘，最终有可能能输入一部莎士比亚作品集——尽管概论微乎其微。 同理，把一堆扑克牌扔到天上，等它们落下来的时候有概率会刚刚好从小到大排成一列。 现在有一个无序的数组，我们让一只猴子来帮我们进行排序： #include <stdio.h> #include <stdlib.h> #include <time.h> #include <stdbool.h> #include <string.h> #defi
C++实现猴子排序（简单易懂）
qq_46458478的博客
12-27 521
闲来无事随手写了一个猴子排序，可以手动输入需要排序的数进行排序。
猴子排序代码
11-14
经典算法（猴子排序）.cpp
C#猴子排序
qq_43640534的博客
05-18 459
世界顶级排序之猴子排序，速度可能比所以算法都快，也可能宇宙爆炸都没排好，好了，接下来，咱们看代码： 下面展示一些 内联代码片。 class Program { static void Main(string[] args) { int count = 0; int[] arr = { 8, 5, -5, 1, 0, 9, 3 }; while (!isOK(arr)) {
睡眠排序算法c语言实现,并发服务器（四）：libuv
weixin_42466857的博客
05-23 361
这是并发网络服务器系列文章的第四部分。在这一部分中，我们将使用 libuv 再次重写我们的服务器，并且也会讨论关于使用一个线程池在回调中去处理耗时任务。最终，我们去看一下底层的 libuv，花一点时间去学习如何用异步 API 对文件系统阻塞操作进行封装。本系列的所有文章：第一节 - 简介(http://www.linuxdiyf.com/linux/32842.html)第二节 - 线程(http...
常用排序算法C语言实现
03-10
本资源"常用排序算法C语言实现"提供了一个实践平台，帮助学习者将理论知识转化为实际代码。 首先，让我们探讨几种常见的排序算法及其C语言实现： 1. **冒泡排序（Bubble Sort）**：冒泡排序是最基础的排序方法，...
快速排序算法c语言.md
12-21
快速排序算法c语言
C-paixu.zip_排序算法C语言
09-21
C语言作为基础且高效的编程语言，是实现各种排序算法的理想选择。本资料"C-paixu.zip"包含了一份关于C语言排序算法的PDF文档，旨在详细讲解和演示这些算法。** 在计算机科学中，排序算法用于对一系列数据进行排列，...
选择排序算法C语言源程序.zip
07-18
综上所述，选择排序算法是一种基础的排序方法，通过C语言源程序实现，虽然效率不高，但易于理解和实现，适用于学习排序算法的基本原理。在实际应用中，尤其是在大数据处理时，通常会考虑使用更高效的排序算法。
快速排序算法 C语言.md
最新发布
06-24
快速排序是一种高效的排序算法，使用分治法策略来把一个序列分为较小和较大的两个子序列，然后递归地排序两个子序列。 代码首先定义了swap函数，用于交换两个整数的值。quickSort是快速排序的递归函数，它调用...
C/C++ 10种排序法
03-06
10种排序法(冒泡、选择、插入、希尔、归并、快速、堆、拓扑、基数、锦标赛排序)
睡眠排序算法c语言实现,Linux 进程必知必会
weixin_31556371的博客
05-23 469
只是简单的描述了一下 Linux 基本概念，通过几个例子来说明 Linux 基本应用程序，然后以 Linux 基本内核构造来结尾。那么本篇文章我们就深入理解一下 Linux 内核来理解 Linux 的基本概念之进程和线程。系统调用是操作系统本身的接口，它对于创建进程和线程，内存分配，共享文件和 I/O 来说都很重要。我们将从各个版本的共性出发来进行探讨。基本概念Linux 一个非常重要的概念就是进...
实验二各种有趣的排序（2.3猴子排序，2.4算珠排序，2.5面条排序）
田田的博客
04-07 947
（1）问题描述 （以下都是题目老师可能怕我们看不懂详细的就差给我们写出来了） 一只猴子一直在打印机上胡乱打字，只要有无限的时间，总有一天可以恰好打印出一部莎士比亚的著作。这个理论同样可以用在排序上面。如果我们给数组随机排列顺序，每一次排列之后验证数组是否有序，只要次数足够多，总有一次数组刚好被随机成有序数组。 这样的排序算法和猴子用打印机打出莎士比亚著作的理论很相似，所以被称为“猴子排序”。 （...
【经典算法】:猴子排序
热门推荐
阳光心态，健康人生的博客
04-14 3万+
猴子排序是一种什么样子的排序呢？ 猴子代表乱的意思，猴子排序的意思就是乱排序，直到有序为止。这个真实的含义就是把一个无序的数组进行乱排序，然后看其是否会有序，这是个概率性事件，有可能一次之后就有序了，也有可能很多次后依然无序。实现方法如下： 1，定义数组 2，数组随机 3，检验数组是否有序，无序继续，有序了就停止就是如此简单的实现思路，但是却要用到随机化的知识和标志变量的实现技巧代码如下：
睡眠排序、面条排序、猴子排序...........................
全栈空间
11-23 4977
内容整编自多个网友的文章,外加上自己的一些感想,链接太多就不一一列举了:) 1. 睡眠排序（Sleep Sort） 睡眠排序也称为硬件排序, 充分利用硬件计时器的资源实现拟态算法(逃 这个事件起源于一个屌丝发表了一个时间复杂度为O(n)的排序算法，睡眠排序的主要逻辑是构造n个线程，它们和这n个数一一对应。初始化后，线程们开始睡眠，等到对应的那么多个时间单位后各自醒来，然后输出对应的数。这...
c++猴子排序
Xuhuanshen的博客
07-22 622
c++代码】c++猴子排序。
C++笔记：奇葩排序之猴子排序、珠排序、面条排序
weixin_50545743的博客
03-17 1487
2021-3-17C++笔记：奇葩排序之猴子排序、珠排序、面条排序 奇葩排序猴子排序（佛系排序）珠排序面条排序完整源代码(实验作业结果，未修改) 猴子排序（佛系排序） 随机打乱数组，检查是否排好序，若是，则输出，否则再次打乱，再检查…最佳情况O(n)，平均O(n*n!)，最坏可执行直到世界的尽头。 无限猴子定理 ：一只猴子随机敲打打字机键盘，如果时间足够长，总是能打出特定的文本，比如莎士比亚全集。 如果数据太多，排序时长完全看运气。 以下是准备好的源码，可以直接看着用，阅读顺序： monkeySort_ma
猴子排序
Tizzi的博客
06-27 1227
猴子排序-------O(n) 一、定义 猴子本身不易驯服,多动、爱玩和调皮,猴子排序精髓就在一个字乱,所以我们只需要对需要排序的数组进行"随心所欲"的乱排序即可. 二、实现 1.待排序的数组arr. 2.保存已排序的数据的数组res. 3.辅助数组help用来记录arr的那个位置已经进行了使用. 代码: import java.util.*; public class 猴子排序 { publ...
快速排序算法c语言算法
10-24
快速排序算法是一种基于交换排序思想的排序算法，它通过递归的方式调用单趟排序，每次调用后都以基准值为界，将数组分为两个子序列，继续排序。快速排序算法的执行效率比冒泡排序算法更高。在C语言中，快速排序算法可以通过递归实现或非递归实现。其中，递归实现是最常见的实现方式。在递归实现中，我们需要先选择一个基准值，然后将数组分为两个子序列，分别对左右子序列进行排序，最终将两个有序子序列合并成一个有序序列。在非递归实现中，我们使用栈来模拟递归过程，从而实现快速排序算法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值