C语言--数组实现--各种排序算法个人总结

最新推荐文章于 2023-12-21 09:55:43 发布
最新推荐文章于 2023-12-21 09:55:43 发布
阅读量3k 收藏 24
点赞数 11
分类专栏： C语言 文章标签： 排序算法 C语言 数组实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Michel_W/article/details/77198666
版权

C语言--数组实现--排序算法：插入排序；希尔排序；冒泡排序；快速排序1；快速排序2；堆排序；归并排序；基数排序；选择排序；计数排序；

各种算法的相关分析如下：

排序法

最差时间分析

平均时间复杂度

稳定度

空间复杂度

冒泡排序

O(n2)

O(n2)

稳定

O(1)

快速排序

O(n2)

O(n*log2n)

不稳定

O(log2n)~O(n)

选择排序

O(n2)

O(n2)

稳定

O(1)

二叉树排序

O(n2)

O(n*log2n)

不一顶

O(n)

插入排序

O(n2)

O(n2)

稳定

O(1)

堆排序

O(n*log2n)

O(n*log2n)

不稳定

O(1)

希尔排序

O

O

不稳定

O(1)














个人总结的各种排序算法，分享给初学者，欢迎指正批评！

// 用数组实现各种排序算法
#include <stdio.h>
#include <stdlib.h>

#define LeftChild( i ) ( 2 * ( i ) +1 )//堆排序--由于数组和堆的序号的差别，数组表示时左孩子应这样表示
#define Cutoff ( 3 )//快速排序--截至范围 

void InsertionSort( int *, int );//插入排序// 第二个参数为数组的长度

void ShellSort( int *, int );//希尔排序

void PercDown( int *, int i, int N );//最大二叉堆建立
void HeapSort( int *, int N );//堆排序
void Swap( int *, int * );//元素互换

void MergeSort( int *, int );//归并排序驱动程序
void MSort( int *, int *, int , int );//归并排序递归例程
void Merge( int *, int *, int, int, int );//归并排序合并例程

void QuickSort( int *, int );//快速排序驱动程序--数据结构与算法书上
int Median3( int *, int, int );//实现三数中值分割法的程序
void QSort( int *, int, int );//快速排序主例程

void QuickSort2( int *, int, int );//快速排序--郝斌视频
int FindPos(int *, int, int );//找位置

void BubSort( int *, int );//冒泡排序

void SelectionSort( int *, int );//选择排序

void CountSort( int *, int );//计数排序

int GetNumInPos( int, int );
void RadixSort( int *, int );//基数排序

int main ( void )
{
	int i;
	int A[ 20 ] = { 23,56,15,48,12,26,45,23,45,17,3,6,5,48,59,65,47,15,35,64 };

	//InsertionSort( A, 20 );//插入排序
	//ShellSort( A, 20 );//希尔排序
	//HeapSort( A, 20 );//堆排序
	//MergeSort( A, 20 );//归并排序
	//QuickSort( A, 20 );//快速排序
	//QuickSort2( A, 0, 19 );//快速排序2
	//BubSort( A, 20 );//冒泡排序
	//SelectionSort( A, 20 );//选择排序
	//CountSort( A, 20 );//计数排序
	RadixSort( A, 20 );//基数排序

	for ( i = 0; i < 20; i++ )
		printf ( "%d ", A[ i ] );
	printf ( "\n" );

	return 0;
}

void InsertionSort( int A[ ], int N )//插入排序
{
	int j, P;
	int Tmp;
	for ( P = 1; P < N; P++ )
	{
		Tmp = A[ P ];
		for ( j = P; j > 0 && A[ j - 1 ] > Tmp; j-- )
			A[ j ] = A[ j - 1 ];
		A[ j ] = Tmp;
	}
}

void ShellSort( int A[ ], int N )//希尔排序
{
	int i, j, Increament;
	int Tmp;

	for ( Increament = N / 2; Increament > 0; Increament /= 2 )
	{
		for ( i = Increament; i < N; i++ )
		{
			Tmp = A[ i ];
			for ( j = i; j >= Increament; j -= Increament )
				if ( Tmp < A[ j - Increament ] )
					A[ j ] = A[ j - Increament ];
				else
					break;
			A[ j ] = Tmp;
		}
	}
}

void PercDown( int A[ ], int i, int N )//最大二叉堆建立
{
	int Child;
	int Tmp;

	for ( Tmp = A[ i ]; LeftChild( i ) < N; i = Child )
	{
		Child = LeftChild( 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-- )//BuildHeap
		PercDown( A, i, N );
	for ( i = N - 1; i > 0; i-- )
	{
		Swap( &A[ 0 ], &A[ i ] );//DeleteMax
		PercDown( A, 0, i );
	}
}
void Swap( int *a, int *b )
{
	int t;
	t = *a;
	*a = *b;
	*b = t;
}

void MergeSort( int A[ ], int N )//归并排序驱动程序
{
	int * TmpArray;

	TmpArray = ( int * )malloc( N * sizeof( int ) );
	if ( NULL != TmpArray )
	{
		MSort( A, TmpArray, 0, N - 1 );
		free( TmpArray );
	}
	else
		printf( "No space for tmp array!!!\n" );
}
void MSort( int A[ ], int TmpArray[ ], int Left, int Right )//归并排序递归例程
{
	int Center;

	if ( Left < Right )
	{
		Center = ( Left + Right ) / 2;
		MSort( A, TmpArray, Left, Center );
		MSort( A, TmpArray, Center + 1, Right );
		Merge( A, TmpArray, Left, Center + 1, Right );
	}
}
void Merge( int A[ ], int TmpArray[ ], int Lpos, int Rpos, int RightEnd )//归并排序合并例程
{
	int i, LeftEnd, NumElements, TmpPos;

	LeftEnd = Rpos - 1;
	TmpPos = Lpos;
	NumElements = RightEnd - Lpos + 1;

	/* main loop */
	while( Lpos <= LeftEnd && Rpos <= RightEnd )
	{
		if( A[ Lpos ] <= A[ Rpos ] )
			TmpArray[ TmpPos++ ] = A[ Lpos++ ];
		else
			TmpArray[ TmpPos++ ] = A[ Rpos++ ];
	}
	while( Lpos <= LeftEnd )//copy rest of first half
		TmpArray[ TmpPos++ ] = A[ Lpos++ ];
	while( Rpos <= RightEnd )//copy rest of second half
		TmpArray[ TmpPos++ ] = A[ Rpos++ ];

	/* copy TmpArray back */
	for( i = 0; i < NumElements; i++, RightEnd-- )
		A[ RightEnd ] = TmpArray[ RightEnd ];
}

void QuickSort( int A[ ], int N )//快速排序驱动程序
{
	QSort( A, 0, N - 1 );
}
/* Return median of Left, Center, and Right */
/* Order these and hide the pivot */
int Median3( int A[ ], int Left, int Right )//实现三数中值分割法的程序
{
	int Center = ( Left + Right ) / 2;

	if( A[ Left ] > A [ Center ] )
		Swap( &A[ Left ], &A[ Center ] );
	if( A[ Left ] > A[ Right ] )
		Swap( &A[ Left ], &A[ Right ] );
	if( A[ Center ] > A[ Right ] )
		Swap( &A[ Center ], &A[ Right ] );

	/* Invariant: A[ Left ] <= A[ Center ] <= A[ Right ] */

	Swap( &A[ Center ], &A[ Right - 1 ] );//Hide pivot
	return A[ Right - 1 ];// Return pivot
}
void QSort( int A[ ], int Left, int Right )//快速排序主例程
{
	int i, j;
	int Pivot;

	if( Left + Cutoff <= Right )
	{
		Pivot = Median3( A, Left, Right );
		i = Left;
		j = Right - 1;
		for( ; ; )
		{
			while( A[ ++i ] < Pivot ){ }
			while( A[ --j ] > Pivot ){ }
			if( i < j )
				Swap( &A[ i ], &A[ j ] );
			else
				break;
		}
		Swap( &A[ i ], &A[ Right - 1 ] );//Restore pivot

		QSort( A, Left, i - 1 );
		QSort( A, i + 1, Right );
	}
	else //Do an insertion sort on the subarray
		InsertionSort( A + Left, Right - Left + 1 );
}

void QuickSort2( int A[ ], int low, int hight )//快速排序2
{
	int pos;

	if( low < hight )
	{
		pos = FindPos( A, low, hight );
		QuickSort2( A, low, pos - 1 );
		QuickSort2( A, pos + 1, hight );
	}
}
int FindPos(int A[ ], int low, int hight )
{
	int val = A[ low ];
	while( low < hight )
	{
		while( low < hight && A[ hight ] >= val )
			--hight;
		A[ low ] = A[ hight ];

		while( low < hight && A[ low ] <= val )
			++low;
		A[ hight ] = A[ low ];
	}//终止while循环之后low和high一定是相等的
	A[ low ] = val;
	return hight;//或者low， low = hight
}

void BubSort( int A[ ], int N )//冒泡排序
{
	int i, j, t;

	for( i = 0; i < N - 1; i++ )
	{
		for( j = 0; j < N - i - 1; j++ )
		{
			if( A[ j ] > A[ j + 1 ] )
			{
				t = A[ j ];
				A[ j ] = A[ j + 1 ];
				A[ j + 1 ] = t;
			}
		}
	}
}

void SelectionSort( int A[ ], int N )//选择排序
{
	int i = 0;
	int min = 0;
	int j = 0;
	int tmp = 0;

	for( i = 0; i < N - 1; i++ )
	{
		min = i;//每次将min置成无序组起始位置元素下标
		for( j = i; j < N; j++ )//遍历无序组，找到最小元素
		{
			if( A[ min ] > A[ j ] )
				min = j;
		}
		if( min != i )//若最小元素不是无序组起始位置元素，则与起始元素交换位置
		{
			tmp = A[ min ];
			A[ min ] = A[ i ];
			A[ i ] = tmp;
		}
	}
}

void CountSort( int A[ ], int N )//计数排序
{
	int i;
	int *SortedArr = ( int * )malloc( sizeof( int ) * N );
	int *CountArr = ( int * )malloc( sizeof( int ) * 100 );//0-99共100个数

	for( i = 0; i < 100; i++ )
		CountArr[ i ] = 0;//初始化计数数组
	for( i = 0; i < N; i++ )
		CountArr[ A[ i ] ]++;//统计i的次数
	for( i = 1; i < 100; i++ )
		CountArr[ i ] += CountArr[ i - 1 ];//对所有的计数累加
	for( i = N; i > 0; i-- )//根据计数将A中的元素排序并放入SortArr中
	{
		SortedArr[ CountArr[ A[ i -1 ] ] -1 ] = A[ i - 1 ];
		CountArr[ A[ i - 1 ] ]--;
	}
	for( i = 0; i < N; i++ )//将SortArr中的元素复制到A中
		A[ i ] = SortedArr[ i ];
	free( SortedArr );
	free( CountArr );
}

int GetNumInPos( int num, int pos )//找到num的从低到高的第pos位的数据
{
	int temp = 1;
	for( int i = 0; i < pos - 1; i++ )
		temp *= 10;
	return ( num / temp ) % 10;
}
void RadixSort( int pDataArray[], int iDataNum )//基数排序
{
	int *radixArrays[ 10 ];//分别为0-9的序列空间
	for( int i =0; i < 10; i++ )
	{
		radixArrays[ i ] = ( int * )malloc( sizeof( int ) * ( iDataNum + 1 ) );
		radixArrays[ i ][ 0 ] = 0;//index为0处记录这组数据的个数
						//之前没有初始化为0，导致下面A处index的值非法，进而导致B赋值编译错误
	}
	for( int pos = 1; pos <= 31; pos++ )//从个位开始到第31位
	{
		for( int i = 0; i < iDataNum; i++ )//分配过程
		{
			int num = GetNumInPos( pDataArray[ i ], pos );
			int index = ++radixArrays[ num ][ 0 ];//A
			radixArrays[ num ][ index ] = pDataArray[ i ];//B
		}
		for( int i = 0, j = 0; i < 10; i++ )//收集
		{
			for( int k = 1; k <= radixArrays[ i ][ 0 ]; k++ )
				pDataArray[ j++ ] = radixArrays[ i ][ k ];
			radixArrays[ i ][ 0 ] = 0;//复位
		}
	}
	//free( radixArrays );/加上这句会报错，报错信息为：data structure.exe 已触发了一个断点。
						  //原因： 内存越界，比如“数组越界”、“释放已经释放掉的内存”、
						  //“共享内存引发的问题”、“释放野指针的问题”等。
						  //此处的原因可能为：释放已经释放掉的内存。
	//更新纠正：真正原因为free的参数错误；free（radixArrays）但，radixArrays是一个数组，不是指针。
	for ( int i = 0; i < 10; i++)
	{
		free( radixArrays[ i ] );
		radixArrays[ i ] = NULL;
	}


}


wmx0513
关注
专栏目录
C语言---数组排序
mqs580的博客
03-19 1万+
1、冒泡排序（从后往前） 1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。 2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应 该会是最大的数。 3.针对所有的元素重复以上的步骤，除了最后一个。 4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 代码： 2、直接选择排序 每一次从待排序的数据元素中选出最小(或最大)的...
c语言指针实现数组排序算法,C语言实现数组快速排序算法
weixin_33700405的博客
05-21 1324
C语言实现数组快速排序算法 快速排序算法，顾名思义，是迄今为止发现的速度最快的排序算法。快速排序算法采用分治的思想，首先在要排序的序列{5,8,7,6,4,3,9}中选取一个基准数(一般选取序列的第一个，其实选取哪个是无关紧要的)，将序列分成两部分，其中基准数的左边全是小于基准数的数，基准数右边是大于或者等于基准数的数。这样，基准数的位置在序列中的位置就固定了，然后将基准数两边的序列进行相同的处理...
C语言数组排序法
热门推荐
Albinzhiyu的专栏
07-13 3万+
很多朋友是以谭浩强老师编的《c语言教程》作为学习C语言的入门教程的。书中涉及排序问题一般都以“冒泡法”和“选择法”实现。为了扩大视野，增加学习编程的兴趣，我参阅了有关书籍，整理了几种排序法，写出来同大家共勉让我们先定义一个整型数组a[n],下面用五种方法对其从小到大排序。 （1）
【C语言】数组排序方法总结
m0_51064412的博客
01-25 2万+
一.冒泡排序 相邻元素两两比较，按照要求交换位置，n个元素一共要比较n-1趟，每趟要两两比较未排序元素个数-1次。 #include<stdio.h> void bubble_sort(int* p, int len)//函数实现 { int i = 0; int j = 0; for (i = 0; i < len - 1; i++)//需要进行len-1趟 { int flag = 1;//flag=1，说明已经排好序 for (j = 0; j < len -
数组排序(C语言）
choose_heart的博客
07-22 1360
以下就是常见基本的排序方式1、冒泡排序2、选择排序3、插入排序4、希尔排序5、归并排序6、快速排序7、堆排序8、计数排序该处的排序原理，讲的其实十分细致。这里着重介绍下，快速排序和归并排序。
排序算法 C语言实现 总结
Chris_秦的博客
03-14 454
个人在学习算法时总结的部分代码头文件Sort.h#ifndef _SORT_H_ #define _SORT_H_#include <stdio.h> #include "time.h" #include "stdlib.h" #include "ASSERT.h" #include "arithmetic.h"typedef int TYPE; void insertionSor
c语言基础-c语言编程基础之数组操作示例-两个数组的交集.zip
03-17
C语言没有内置的排序函数，但可以使用快速排序、冒泡排序或插入排序等算法。这里以快速排序为例： ```c void quickSort(int arr[], int left, int right) { // 快速排序代码... } ``` 2. 排序后，使用双指针法找...
C语言第07章-一维数组和二维数组1完整.pptx
11-14
在编程中，数组也可以用来实现各种算法和数据结构，例如排序算法、查找算法和栈等。 数组是C语言中的一种基本数据结构，用于存储一组具有相同数据类型的数据。数组可以分为一维数组和二维数组两种形式，一维数组是...
C语言--数组作为函数参数--实现冒泡排序函数
羟基与苯的博客
01-19 1468
文章目录前言1 冒泡排序函数的错误设计2 数组名是什么？3 冒泡排序函数的正确设计 前言 往往我们在写代码的时候，会将数组作为参数传个函数，比如，此处要实现一个冒泡排序函数：将一个整形数组排序。 提示：以下是本篇文章正文内容，下面案例可供参考 1 冒泡排序函数的错误设计 //方法1： #include <stdio.h> void bubble_sort(int arr[]) { int sz = sizeof(arr)/sizeof(arr[0]);//这样对吗？ int i
排序算法-基于C语言实现的排序算法之MergeSort实现.zip
最新发布
03-27
在C语言中，实现各种排序算法是学习编程基础的重要环节。这个压缩包提供了基于C语言实现的排序算法，特别是MergeSort（归并排序）的实例。 **归并排序(Merge Sort)** 归并排序是一种采用分治法(Divide and Conquer...
c语言数组选择法排序
03-07
使用c语言写的数组选择法排序的程序代码，有详细注释。
【C语言】详解C语言常用的五种数组排序方式
weixin_50111954的博客
12-21 1万+
给大家分享一下数组的各种常用的五种排序算法：选择排序、冒泡排序、交换排序、插入排序、折半排序。图文代码结合超简单一看就懂，建议收藏！
C语言数组排序小结
Codingkid
01-31 418
（1）“冒泡法” 冒泡法大家都较熟悉。其原理为从a[0]开始，依次将其和后面的元素比较,若a[0]>a[i]，则交换它们，一直比较到a[n]。同理对a[1],a[2],...a[n-1]处理，即完成排序。下面列出其代码： void bubble(int *a,int n) /*定义两个参数：数组首地址与数组大小*/ { int i,j,temp; for(i=0;ifo
c语言任一数组排序,C语言一维数组排序
weixin_36170766的博客
05-26 265
交换排序1.冒泡排序算法思想1.将所有元素放入数组中；2.从第一个元素开始，依次将相邻的两个元素比较，若前者大于后者则交换；3.重复第2步，直到没有交换为止。程序实现void sort(int *a, int n){int i, j, t, ok;for(i=0; iok=1;for(j=0; jif(a[j]>a[j+1]){t=a[j];a[j]=a[j+1];a[j+1]=t;ok=0...
C语言：数组排序
qq_54127452的博客
07-29 4237
//定义一个数组，for循环排列 #include <stdio.h> int main(int argc,char const *argv[]) { int a; printf(“请输入数组长度：”); scanf("%d",&a); int arr[a]; for (int k = 0; k < sizeof(arr) / sizeof(int); ++k) { scanf("%d",&arr[k]); } //int arr[] = {1,3,4,7,4,2,4};/
C语言 数组排序 – 选择法排序 - C语言零基础入门教程
猿说编程
08-17 1630
目录 一.简介 二.数组选择法排序原理 三.数组选择法排序实战 四.猜你喜欢 零基础 C/C++ 学习路线推荐 : C/C++ 学习目录 >> C 语言基础入门 一.简介 经过前面的学习，我们已经学会了数组遍历，在开发中，我们经常回碰到对数组进行排序，例如：学习成绩排序，身高排序，年龄排序等等；在 C 语言中常见的数组排序一共有四种： 1.冒泡法排序 2.选择法排序 3.插入法排序 4.快速法排序 二.数组选择法排序原理 将要排序的数组分成两部分，一部分是从大到小已经排好序的，一部分
C语言 数组选择法排序
weixin_74287172的博客
04-03 1395
利用选择法对n个数（100以内正整数）进行排序。选择法排序的过程是：将第1个元素作为最小元素，与后面n-1个元素比较找出最小元素，记录其下标，与第1个元素互换；然后，将第2个元素作为最小元素，与后面n-2个元素比较找出最小元素，记录其下标，与第2个元素互换；依次类推，直到第n-1个元素完成同样过程为止。提示：数组长度定义为100，根据输入的n值使用前面的n个元素。4）打印排序后结果，每个元素输出格式为“%4d”。
用C语言完整实现12种排序方法
weixin_42617375的博客
12-14 4290
排序方法（升序）： 1.冒泡排序 2.插入排序 3.折半插排序 4.希尔排序 5.选择排序 6.鸡尾酒排序 7.堆排序 8.快速排序 9.归并排序 10.计数排序 11.桶排序 12.基数排序 1.冒泡排序 思路：比较相邻的两个数字，如果前一个数字大，那么就交换两个数字，直到有序。 时间复杂度O(n^2)，稳定性：这是一种稳定的算法。 代码实现： void bubble_sort(int arr[...
C语言基础-数组，排序，函数
qq_52902991的博客
04-05 2348
计算数组内元素的个数，利用sizeof求出整个数组的内存空间大小和一个元素的内存空间大小，两数相除即可得出数组内元素的个数。生命周期，被调用时才为形式参数申请内存，调用结束，内存被系统释放。（编程便捷，但是有风险，所有函数都可以操作，多线程）在对全部数据赋值时，中括号内的元素个数可以省略不写(如下代码，5即可不写)-由整数赋值给小数时，需要强转，强转类型写在括号内。1、首先定义三个方法函数，输入成绩，打印成绩，计算平均值。三、一维数组作为函数的参数，数组值传递的问题（难点）-参数列表中数组传递的是。
Objective-C实现冒泡排序算法
"Objective-C 冒泡排序案例展示了如何在 iOS 或 macOS 开发中实现经典的冒泡排序算法。" 冒泡排序是一种简单的排序算法，它重复地遍历待排序的列表，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值