10种排序算法总结-（c语言实现与动画演示）

已于 2024-06-12 13:29:39 修改
阅读量570 收藏 3
点赞数 19
文章标签： 排序算法 算法
于 2024-05-29 12:36:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37040743/article/details/139289356
版权

算法分类

十种常见排序算法可以分为两大类：

比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。

a7cc47d731874c83835128a1efa170bf.png

36b90d4e95cb4262848af0c8b53eaae2.png

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。

不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。

 

 

1.冒泡排序：

773bf28ef0ce4a56b316d47b4d0766ef.gif

#include<stdio.h>
#include<malloc.h>
void BubbleSort(int *arr,int size)
{
    int i = 0;
    int j = 0;
    for(i=0;i<size-1;i++)
	{
        for(j=0;j<size-i-1;j++)
		{
            if(arr[j]>arr[j+1])
			{
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
    }
}
int main()
{
	int a[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
	int  len=sizeof(a)/sizeof(a[0]);
	BubbleSort(a,len);

	for(int i=0;i<len;i++)
	printf("%d--",a[i]);
	
}

2.选择排序

691cfb26f68e4102956de7925bfef055.gif

#include<stdio.h> 
void swap(int* a,int* b)//交换函数 
{
	int tem=*a;
	*a=*b;
	*b=tem;
}

void selectionSort(int *arr, int n) //选择排序函数 
{
    for (int i = 0; i < n - 1; i++) 
	{
        int minIndex = i;
        for (int j = i + 1; j < n; j++)
		{
            if (arr[j] < arr[minIndex]) 
			{
                minIndex = j;
            }
        }
        swap(&arr[minIndex],&arr[i]);
    }
}

int main()
{
	int arr[] = {3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
    int n = sizeof(arr) / sizeof(arr[0]);
    selectionSort(arr, n);
    for(int i=0;i<n;i++)
    printf("%d--",arr[i]);
}

3.插入排序

852dd62a491040cba5b7fb5aad48d045.gif

#include<stdio.h>
#include<stdlib.h>
void swap(int* a,int* b)
{
	int tem=*a;
	*a=*b;
	*b=tem;
}
void InsertSort(int *arr,int n)
{
	for(int i=1;i<n;i++)
	{
	if(arr[i]<arr[i-1])
	{
		swap(&arr[i],&arr[i-1]);
		for(int j=i-1;j>0&&arr[j]<arr[j-1];j--)
		{
			swap(&arr[j],&arr[j-1]);
		}
	}
	}
}
int main()
{
	int arr[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
	int n = sizeof(arr) / sizeof(arr[0]);
	InsertSort(arr,n);
	for(int i=0;i<n;++i)
	{
		printf("%d--",arr[i]);
	}
 }

4.希尔排序

ba25037508f14e5999973f918600000b.gif

#include<stdio.h>
//希尔排序
void ShellSort(int *arr,int n){
	int d,i,j,temp;
	for(d=n/2;d>=1;d=d/2){
		for(i=d;i<n;i++){//增量 
			if(arr[i]<arr[i-d]){
				temp=arr[i];
				for(j=i-d;j>=0&&temp<arr[j];j-=d){
					arr[j+d]=arr[j];
				}
				arr[j+d]=temp;
			}
		}
	}
}

int main()
{
	int arr[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
	int n = sizeof(arr) / sizeof(arr[0]);
	ShellSort(arr,n);
	for(int i=0;i<n;++i)
	{
		printf("%d--",arr[i]);
	}
 }

5.归并排序

ab013dbb616a45b9b6ac76ef6bf4e4f6.gif

#include<stdio.h>
void merge(int arr[], int left[], int size_left, int right[], int size_right) 
{  
    int i = 0, j = 0, k = 0;  
    while (i < size_left && j < size_right) 
	{  
        if (left[i] <= right[j])
		{  
            arr[k++] = left[i++];  
        } 
		else 
		{  
            arr[k++] = right[j++];  
        }  
    }  

    // 复制剩余的元素  
    while (i < size_left)
    {  
        arr[k++] = left[i++];  
    }  
    while (j < size_right) 
    {  
        arr[k++] = right[j++];  
    }  
}  

// 归并排序  
void mergeSort(int *arr, int n) {  
    if (n <= 1) return;  
    int mid = n / 2;  
    int left[mid];  
    int right[n - mid];  

  
    // 复制数据到临时数组  
    for (int i = 0; i < mid; i++) 
	{  
        left[i] = arr[i];  
    }  

    for (int i = mid; i < n; i++) 
	{  
        right[i - mid] = arr[i];  
    }  
    // 递归排序左半部分和右半部分  
    mergeSort(left, mid);  
    mergeSort(right, n - mid);  
    
    // 合并两个已排序的数组  
    merge(arr, left, mid, right, n - mid);  

}  

int main()
{
	int arr[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
	int n = sizeof(arr) / sizeof(arr[0]);
	mergeSort(arr, n);  
	for(int i=0;i<n;++i)
	{
		printf("%d--",arr[i]);
	}
}

6.快速排序

20c66bbf10d747ce9fe7f6b2e1e18a66.gif

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

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


int Partition(int* arr,int low ,int high)
{
	int pk=arr[low];
	while(low<high)
	{
		while(low<high&&arr[high]>=pk)
		high--;
		arr[low]=arr[high];
		while(low<high&&arr[low]<pk)
		low++;
		arr[high]=arr[low];
	}
	arr[low]=pk;
	return low;
}
void QuickSort(int* arr,int low,int high)
{
	if(low<high)
	{
		int pkloc=Partition(arr,low,high);//找到分界线 
		QuickSort(arr,low,pkloc-1);
		QuickSort(arr,pkloc+1,high); 
	}
}
int main()
{
	int arr[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
	int n = sizeof(arr) / sizeof(arr[0]);
	QuickSort(arr,0,n-1);
	for(int i=0;i<n;++i)
	{
		printf("%d--",arr[i]);
	}
 }

7.堆排序

952a5e8a84fe4d25bfed3faa2c9a6958.gif

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
void siftDown(int* heap,int n,int p);
void swap(int* a,int* b)
{
	int tem=*a;
	*a=*b;
	*b=tem;
}
int RemoveMinKey(int* heap,int n)
{
	int key =heap[0];
	heap[0]=heap[n];
	siftDown(heap,n,0);
	return key;
}
void siftDown(int* heap,int n,int p)
{
	int i=p;//i
	int j=2*i+1;//左子树 
	while(j<n)//不超出范围 
	{
		if(j<n-1&&heap[j]>heap[j+1])//j为左子树，+1为右子树 
		j++;
		if(heap[i]<=heap[j])
		break;
		else
		{
			swap(&heap[j],&heap[i]);
			i=j;
			j=2*i+1;
		}
	}
}
void HeapSort(int* arr,int n) 
{
	int *heap=(int*)malloc(sizeof(int)*n);
	for(int i=0;i<n;++i)
	{
		heap[i]=arr[i];
	}
	int curpos=n/2-1;
	while(curpos>=0)
	{
		siftDown(heap,n,curpos);
		curpos--;
	}
	for(int i=0;i<n;++i)
	{
		//printf("%d  ",heap[i]);
		arr[i]=RemoveMinKey(heap,n-i-1);
		
	}
	//printf("\n");
	free(heap);
	heap=NULL;
	
}

int main()
{
	int arr[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
	int n = sizeof(arr) / sizeof(arr[0]);
	HeapSort(arr,n);
	for(int i=0;i<n;++i)
	{
		printf("%d--",arr[i]);
	}
 }

8.计数排序

6445a1b0867144ec8963072b81ba1b73.gif

#include <stdio.h>  
#include<malloc.h>
// 计数排序函数  
void countingSort(int arr[], int n) 
{  
    // 找到数组中的最大值  
    int max = arr[0];  
    for (int i = 1; i < n; i++)
	{  
        if (arr[i] > max) 
		{  
            max = arr[i];  
        }  
    }  

    // 初始化计数数组  
    int *count = (int *)malloc(sizeof(int) * (max + 1));
	for(int i=0;i<=max;i++)
		count[i]=0; 
		
    // 计算每个元素的计数  
    for (int i = 0; i < n; i++) 
	{
        count[arr[i]]++; 
    }  
	
	int output=0;//计数 
	for(int i=0;i<=max;i++)//循环每个计数盘子 
	{
		while(count[i]>0)//当盘子中数的个数大于0时，赋值到arr，并减少一个 
		{
		arr[output++]=i;//赋值给arr 
		count[i]--;
		}	
	}
    free(count);  
}  

int main()
{
	int arr[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
	int n = sizeof(arr) / sizeof(arr[0]);
	countingSort(arr,n);
	for(int i=0;i<n;++i)
	{
		printf("%d--",arr[i]);
	}
 }

9.基数排序

f449a38cce924af19f1f4732a9d34ec9.gif

#include <stdio.h>  
#include<malloc.h>
//基数排序
void RadixSort(int* arr, int n)
{
	int max = arr[0];
	int base = 1;

	//找出数组中的最大值
	for (int i = 0; i < n; i++)
	{
		if (arr[i] > max)
		{
			max = arr[i];
		}
	}

	//临时存放数组元素的空间
	int* tmp = (int*)malloc(sizeof(int)*n);

	//循环次数为最大数的位数
	while (max / base > 0)
	{
		//定义十个桶，桶里面装的不是数据本身，而是每一轮排序对应（十、白、千...）位的个数
		//统计每个桶里面装几个数
		int bucket[10] = { 0 };
		for (int i = 0; i < n; i++)
		{
			//arr[i] / base % 10可以取到个位、十位、百位对应的数字
			bucket[arr[i] / base % 10]++;
		}
		//循环结束就已经统计好了本轮每个桶里面应该装几个数


		//将桶里面的元素依次累加起来，就可以知道元素存放在临时数组中的位置
		for (int i = 1; i < 10; i++)
		{
			bucket[i] += bucket[i - 1];
		}
		//循环结束现在桶中就存放的是每个元素应该存放到临时数组的位置


		//开始放数到临时数组tmp
		for (int i = n - 1; i >= 0; i--)
		{
			tmp[bucket[arr[i] / base % 10] - 1] = arr[i];
			bucket[arr[i] / base % 10]--;
		}

		//把临时数组里面的数拷贝回去
		for (int i = 0; i < n; i++)
		{
			arr[i] = tmp[i];
		}
		base *= 10;
	}
	free(tmp);
}


int main()
{
	int arr[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
	int n = sizeof(arr) / sizeof(arr[0]);
	RadixSort(arr,n);
	for(int i=0;i<n;++i)
	{
		printf("%d--",arr[i]);
	}
 }

参考：https://www.cnblogs.com/onepixel/p/7674659.html

 

赵药师
关注
10大排序算法（C语言实现）
m0_51607644的博客
02-05 537
大一刚放寒假期间，回想一下马上进入大学时的心情，记得在暑假时加了一个学校acm战队的群，当时感觉很美好，想开学的时候努力一下进入校队的acm。可是自己又特别喜欢渗透，于是就把acm这个想法放下了，这几天把SQLlabs干完了，出于闲想看看算法。记得当时写C课设的时候，冒泡排序也把我整一段时间才迷糊过来。好，废话不多说，记录一下自己的学习成果。 写在前面 这些总结是根据菜鸟教程上的知识，加上自己的实验和思考的成果。 十大经典排序算法.在这里我先说一下：下边所有的算法排序结果都从大到小 1.冒泡排序 算法思路：
c语言十大经典算法排序,十大经典排序算法，作为程序员一定要知道！（详细解析）...
weixin_39699070的博客
05-24 1136
十大排序算法可以说是每个程序员都必须得掌握的了，花了一天的时间把代码实现且整理了一下，为了方便大家学习，我把它整理成一篇文章，每种算法会有简单的算法思想描述，为了方便大家理解，我还找来了动图演示；这还不够，我还附上了对应的优质文章，看完不懂你来砍我，如果不想砍我就给我来个好看。术语铺垫有些人可能不知道什么是稳定排序、原地排序、时间复杂度、空间复杂度，我这里先简单解释一下：1、稳定排序：如果 a 原...
利用C语言实现十大经典排序算法的方法
嵌入式技术开发
06-12 1307
算法分析：插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。快速排序的基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。（2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数。（1）在未排序序列中找到最小（大）元素，存放到排序序列的起始位置；
【C语言】快速排序——动图演示
最新发布
Eraser的博客
09-09 824
快排的时间复杂度是On∗lognO(n*logn)On∗logn递归版本有缺陷，就是在建立太多栈帧情况，不能及时返回就会栈溢出。非递归就能解决该问题，效率上二者差不多。快排的三种实现方法（hoare版（左右指针法），挖坑法，前后指针法）和两种优化（三数取中、小区间优化），非递归都详细的说明了，请大家还是要多多画图和调试，走读代码才能更加牢固的掌握。
【C语言】——十大排序算法
weixin_73807021的博客
03-17 4532
学了算法之后相信大家还需要整理一份关于算法的笔记，希望这篇文章能给大家带来一些启发和帮助。学习算法就是学习解决问题思想，在面对一个问题要利用算法的思维来思考会对解题有很大的帮助。本小白的此次分享就到这里结束啦，欢迎各位佬多多指正。
十大排序算法C语言实现
qwer1234mnbv_的博客
05-23 393
一、插入排序
程序员面试必备——动画详解十大经典排序算法（C语言版）
FiTeen's Blog
02-18 1980
博客原文地址 排序算法是程序员必备的基础知识，弄明白它们的原理和实现很有必要。本文中将通过非常细节的动画展示出算法的原理，配合代码更容易理解。 概述 由于待排序的元素数量不同，使得排序过程中涉及的存储器不同，可将排序方法分为两类：一类是内部排序，指的是待排序列存放在计算机随机存储器中进行的排序过程；另一类是外部排序，指的是待排序的元素的数量很大，以致内存一次不能容纳全部记录，在排序过程中尚需对...
啥?十大排序算法，来这看看-基本思想+动画演示+C语言实现
热门推荐
北北北
05-03 1万+
十大排序算法基本思想，动画演示及其C语言实现，不要再找了，我看了好多博客里面都是有问题的。本文代码手打，已经过测试，不涉及算法复杂度以及优化，仅供理解概念。
各类排序算法汇总及动画演示(C语言)
weixin_45394002的博客
04-11 2277
(一)插入排序 插入排序可形象理解为打扑克时理牌的一个过程，具体分为直接插入、折半插入排序、希尔排序三种； ①直接插入排序 void InsertSort(int a[],int n) //n为数据的个数 { int i,j,temp; //i作为已排序好的元素的下标,j存放进行比较的元素的下标 for(i=0;i<n-1;i++) { temp=a[i+1]; //temp把要...
C语言课设--实现数据排序算法（冒泡、选择、插入）的动画效果（课设报告+源码）
08-18
1、实现数据排序算法（冒泡、选择、插入）的动画效果。 2、供用户输入选择进行哪一种排序效果演示，用ege自带的输入框供用户进行输入排序前的序号。对用户的界面友好，添加一些提示（例如输入错误不合法等等），操作...
几种简单算法的C语言源代码和演示页面（插入排序，冒泡排序等）.zip
09-12
总结，这个压缩包不仅提供了C语言实现的基本排序算法，还结合了生动的HTML动画，为初学者提供了一个全面了解和实践这些算法的平台。通过实际操作和观察动画，学习者可以更加深入地理解排序算法的逻辑和效率。
c实现十种排序算法
08-27
里面包含十种排序算法例如冒泡、堆排序、桶排序、快速排序、选择排序等等，部分排序还有优化的实现在里面，用c实现的，还有部分解释，相信大家可以学到东西
排序算法演示软件（C语言版）
12-23
内容：设计一个比较实用的排序算法演示软件。 要求： 实现初始队列的建立，输入元素数量，排序过程的动态演示功能。 1) 自动构造数据结构，能保存数据。 2) 实现动态演示，界面美观大方。 3) 能提供单步，连续功能，可选多种算法。 本算法系本人所作，如有需要，可留言
C语言经典排序方法及动图演示
06-26
动图演示对于理解这些排序算法的运作过程非常有帮助，因为它们直观地展示了数据如何在排序过程中移动和变化。STM8S_sort这个文件可能包含了一组示例代码和相应的动态图像，可以帮助学习者更好地掌握这些排序方法的...
经典的十种排序算法 C语言版
Johnny-He的博客
03-18 1万+
简要的介绍几种排序算法
常见八大排序（C语言实现）及动图演示
qq_43041053的博客
11-25 2151
0.简介 排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。 内部排序：数据元素全部放在内存中的排序。 外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
C语言实现八大排序（动画演示）
Mesar的博客
03-31 2091
本文介绍了八大排序算法，并用C语言实现各类排序。运用了初阶的数据结构，与各类排序思想结合实现了高效的排序效率。本文篇幅较长，细节满满，干货多多，动画辅助演示各类排序的过程，帮助读者更好理解，希望本文对大家有所帮助。
十大经典排序算法及其C语言实现--带动图展示
Lyajpunov的博客
04-11 1087
排序算法大概算起来有以下十种。
"直接插入排序与希尔排序动画演示PPT
本资源是博文【数据结构】手撕排序NO.2----直接插入排序与希尔排序的配套演示资料，通过PPT展示了直接插入排序和希尔排序的动画演示，以及对两种排序算法的复杂度进行了分析。在直接插入排序中，首先对有序序列进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

赵药师

嘿嘿嘿

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

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

打赏作者

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

抵扣说明：

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

余额充值