十种排序代码拿走不谢

最新推荐文章于 2024-07-08 21:32:26 发布
最新推荐文章于 2024-07-08 21:32:26 发布
阅读量1.9k 收藏 11
点赞数 3
文章标签： c++ c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42248244/article/details/104870966
版权

最近重新学习了一遍排序算法,写了几种排序算法这里分享给大家

1.优化版的冒泡排序

#include<stdio.h>

void BubblseSort(int arr[],int nLength)
{
	if(arr == NULL || nLength <= 0)return;

	int i;
	int j;
	int nFlag;
	int nCount = 0;
	for(i = 0;i<nLength-1;i++)
	{
		nFlag = 0;
		for(j = 0;j<nLength-1-i;j++)
		{
			if(arr[j] > arr[j+1])
			{
				arr[j] = arr[j]^arr[j+1];
				arr[j+1] = arr[j]^arr[j+1];
				arr[j] = arr[j]^arr[j+1];
				nFlag = j+1;
			}
			nCount++;
		}

		if(nFlag == 0)
		{
			break;
		}

		i = nLength-nFlag-1;
	}
	printf("%d\n",nCount);
}



int main()
{
	int arr[] = {8,2,19,28,0,37,87,112,231};
	BubblseSort(arr,sizeof(arr)/sizeof(arr[0]));
	
	int i;
	for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		printf("%d ",arr[i]);
	}


	return 0;
}

2.选择排序

#include<stdio.h>

void SelectSort(int arr[],int nLength)
{
	if(arr == NULL || nLength <= 0)return;
	
	int i;
	int j;
	int nMin;
	for(i = 0;i<nLength-1;i++)
	{
		nMin = i;

		for(j = i+1;j<nLength;j++)
		{
			if(arr[j] < arr[nMin])
			{
				nMin = j;
			}
		}

		if(i != nMin)
		{
			arr[i] = arr[nMin]^arr[i];
			arr[nMin] = arr[nMin]^arr[i];
			arr[i] = arr[nMin]^arr[i];
		}
	}
}



int main()
{
	int arr[] = {8,2,19,28,0,37,87,112,231};
	SelectSort(arr,sizeof(arr)/sizeof(arr[0]));
	
	int i;
	for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		printf("%d ",arr[i]);
	}


	return 0;
}

3.插入排序

#include<stdio.h>

void InsertSort(int arr[],int nLength)
{
	if(arr == NULL || nLength <= 0)return;
	
	int i;
	int j;
	int temp;

	for(i = 1;i<nLength;i++)
	{
		j = i-1;//有序的最后位置
		temp = arr[i]; //无序的第一个元素

		//倒序遍历有序数组
		while(temp < arr[j] && j >= 0)
		{
			//向后移动
			arr[j+1] = arr[j];
			j--;
		}

		//无序元素放入
		arr[j+1] = temp;
	}
}



int main()
{
	int arr[] = {8,2,19,28,0,37,87,112,231};
	InsertSort(arr,sizeof(arr)/sizeof(arr[0]));
	
	int i;
	for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		printf("%d ",arr[i]);
	}


	return 0;
}

4.计数排序

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

void CountSort(int arr[],int nLength)
{
	if(arr == NULL || nLength <= 0)return;

	//找到最大值 最小值
	int i;
	int nMax;
	int nMin;
	nMax = arr[0];
	nMin = arr[0];

	for(i = 1;i<nLength;i++)
	{
		if(arr[i] > nMax)
		{
			nMax = arr[i];
		}
		if(arr[i] < nMin)
		{
			nMin = arr[i];
		}
	}

	//申请计数数组
	int *pCount = NULL;
	pCount = (int*)malloc(sizeof(int)*(nMax-nMin+1));
	memset(pCount,0,sizeof(int)*(nMax-nMin+1));

	//计数
	for(i = 0;i< nLength;i++)
	{
		pCount[arr[i]-nMin]++;
	}

	//排序
	int j = 0;
	for(i = 0;i<nMax-nMin+1;i++)
	{
		while(pCount[i] != 0)
		{
			arr[j] = i+nMin;
			j++;
			pCount[i]--;
		}
	}

	//释放
	free(pCount);
	pCount = NULL;
}



int main()
{
	int arr[] = {8,2,9,8,0,3,8,2,3};
	CountSort(arr,sizeof(arr)/sizeof(arr[0]));
	
	int i;
	for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		printf("%d ",arr[i]);
	}


	return 0;
}

5.快速排序

#include<stdio.h>

int Sort(int arr[],int nLow,int nHigh)
{
	int temp;
	temp = arr[nLow];

	while(nLow < nHigh)
	{
		//从后向前找比标准值小的
		while(nHigh > nLow)
		{
			if(arr[nHigh] < temp)
			{
				//放前面的坑
				arr[nLow] = arr[nHigh];
				nLow++;
				break;
			}
			nHigh--;
		}

		//从前向后找比标准值大的
		while(nLow < nHigh)
		{
			if(arr[nLow] > temp)
			{
				//放后面的坑
				arr[nHigh] = arr[nLow];
				nHigh--;
				break;
			}
			nLow++;
		}
	}

	//标准值放入
	arr[nLow] = temp;
	return nLow;
}

int  Sort2(int arr[],int nLow,int nHigh)
{
	int nSmall = nLow-1;

	for(nLow ;nLow < nHigh;nLow++)
	{
		if(arr[nLow] < arr[nHigh])
		{
			//用小区间的下一位置和当前元素交换
			if(++nSmall != nLow)
			{
				arr[nSmall] = arr[nSmall]^arr[nLow];
				arr[nLow] = arr[nSmall]^arr[nLow];
				arr[nSmall] = arr[nSmall]^arr[nLow];
			}
		}
	}

	//标准值放入
	if(++nSmall != nHigh)
	{
		arr[nSmall] = arr[nSmall]^arr[nHigh];
		arr[nHigh] = arr[nSmall]^arr[nHigh];
		arr[nSmall] = arr[nSmall]^arr[nHigh];
	}

	return nSmall;
}
void QuickSort(int arr[],int nLow,int nHigh)
{
	if(arr == NULL || nHigh <= nLow)return;

	//找标准值位置
	int nStandard;
	nStandard = Sort2(arr,nLow,nHigh);

	//根据标准值位置 分成两部分
	QuickSort(arr,nLow,nStandard-1);
	QuickSort(arr,nStandard+1,nHigh);
}



int main()
{
	int arr[] = {8,2,19,28,0,37,87,112,231};
	QuickSort(arr,0,sizeof(arr)/sizeof(arr[0])-1);

	int i;
	for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		printf("%d ",arr[i]);
	}


	return 0;
}

6.希尔排序

#include<stdio.h>

void ShellSort(int arr[],int nLength)
{
	if(arr == NULL || nLength <= 0)return;
	
	int nGap;
	int i;
	int j;
	int k;
	int temp;

	for(nGap = nLength/2;nGap>=1;nGap/=2)
	{
		//组
		for(i =0;i<nGap;i++)
		{
			//各组之内插入排序
			for(j = i+nGap;j < nLength;j+=nGap)
			{
				k = j-nGap;//有序的最后一个
				temp = arr[j]; //无序元素

				while(temp < arr[k] && k>=i)
				{
					arr[k+nGap] = arr[k];
					k-=nGap;
				}

				//元素放入
				arr[k+nGap] = temp;
			}
		}
	}
}



int main()
{
	int arr[] = {8,2,19,28,0,37,87,112,231};
	ShellSort(arr,sizeof(arr)/sizeof(arr[0]));
	
	int i;
	for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		printf("%d ",arr[i]);
	}


	return 0;
}

7.归并排序

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

void Sort(int arr[],int nLow,int nHigh)
{
	int nBegin1;
	int nBegin2;
	int nEnd1;
	int nEnd2;

	nBegin1 = nLow;
	nEnd1 = nLow+(nHigh-nLow)/2;

	nBegin2 = nEnd1+1;
	nEnd2 = nHigh;

	int *pTemp = NULL;
	pTemp = (int*)malloc(sizeof(int)*(nHigh-nLow+1));
	int i = 0;

	//合并
	while(nBegin1 <= nEnd1 && nBegin2 <= nEnd2)
	{
		if(arr[nBegin2] < arr[nBegin1])
		{
			pTemp[i] = arr[nBegin2];
			i++;
			nBegin2++;
		}
		else
		{
			pTemp[i] = arr[nBegin1];
			i++;
			nBegin1++;
		}
	}

	//将有剩余的数组元素继续放
	while(nBegin1 <= nEnd1)
	{
		pTemp[i] = arr[nBegin1];
		i++;
		nBegin1++;
	}

	while(nBegin2 <= nEnd2)
	{
		pTemp[i] = arr[nBegin2];
		i++;
		nBegin2++;
	}

	//放回原数组
	for(i = 0;i<nHigh-nLow+1;i++)
	{
		arr[nLow+i] = pTemp[i];
	}

	//释放
	free(pTemp);
	pTemp = NULL;
}

void MergeSort(int arr[],int nLow,int nHigh)
{
	if(arr == NULL || nLow >= nHigh)return;
	
	int nMid;
	nMid = nLow+(nHigh-nLow)/2;

	//分组
	MergeSort(arr,nLow,nMid);
	MergeSort(arr,nMid+1,nHigh);

	//合并
	Sort(arr,nLow,nHigh);
}



int main()
{
	int arr[] = {8,2,19,28,0,37,87,112,231};
	MergeSort(arr,0,sizeof(arr)/sizeof(arr[0])-1);
	
	int i;
	for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		printf("%d ",arr[i]);
	}


	return 0;
}

8.堆排序

#include<stdio.h>
#define LEFT 2*nRootID+1
#define RIGHT 2*nRootID+2

void Adjust(int arr[],int nLength,int nRootID)
{
	while(1)
	{
		//两个孩子
		if(RIGHT < nLength)
		{
			//比较两个孩子大小
			if(arr[LEFT] > arr[RIGHT])
			{
				//大的和父亲比较
				if(arr[LEFT] > arr[nRootID])
				{
					arr[LEFT] = arr[LEFT]^arr[nRootID];
					arr[nRootID] = arr[LEFT]^arr[nRootID];
					arr[LEFT] = arr[LEFT]^arr[nRootID];

					nRootID = LEFT;
					continue;
				}
				break;
			}
			else
			{
				if(arr[RIGHT] > arr[nRootID])
				{
					arr[RIGHT] = arr[RIGHT]^arr[nRootID];
					arr[nRootID] = arr[RIGHT]^arr[nRootID];
					arr[RIGHT] = arr[RIGHT]^arr[nRootID];

					nRootID = RIGHT;
					continue;
				}
				break;
			}
		}
		//一个孩子
		else if(LEFT < nLength)
		{
			if(arr[LEFT] > arr[nRootID])
			{
				arr[LEFT] = arr[LEFT]^arr[nRootID];
				arr[nRootID] = arr[LEFT]^arr[nRootID];
				arr[LEFT] = arr[LEFT]^arr[nRootID];

				nRootID = LEFT;
				continue;
			}
			break;
		}
		//无孩子
		else
		{
			break;
		}
	}
}

void HeapSort(int arr[],int nLength)
{
	if(arr == NULL || nLength <= 0)return;

	//建初始堆
	int i;
	for(i = nLength/2-1;i>=0;i--)
	{
		//调整
		Adjust(arr,nLength,i);
	}

	//排序
	for(i = nLength-1;i>0;i--)
	{
		//交换
		arr[0] = arr[0]^arr[i];
		arr[i] = arr[0]^arr[i];
		arr[0] = arr[0]^arr[i];

		//调整堆顶
		Adjust(arr,i,0);
	}
}


int main()
{
	int arr[] = {10,5,91,9,2,36,108,222,9100};
	HeapSort(arr,sizeof(arr)/sizeof(arr[0]));

	int i;
	for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		printf("%d ",arr[i]);
	}
	return 0;
}

9.桶排序

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

typedef struct bucket
{
	int nValue;
	struct bucket *pNext;
	struct bucket *pPre;
}Bucket;

void Sort(Bucket *pHead)
{
	if(pHead == NULL || pHead->pNext == NULL)return;

	Bucket *pSort = NULL;
	Bucket *pUnsort = NULL;

	int temp;

	pUnsort = pHead->pNext;
	
	while(pUnsort != NULL)
	{
		pSort = pUnsort->pPre;
		temp = pUnsort->nValue;

		while(pSort != NULL && pSort->nValue > temp)
		{
			pSort->pNext->nValue = pSort->nValue;
			pSort = pSort->pPre;
		}

		if(pSort == NULL)
		{
			pHead->nValue = temp;
		}
		else
		{
			pSort->pNext->nValue = temp;
		}

		pUnsort = pUnsort->pNext;
	}
}


void BucketSort(int arr[],int nLength)
{
	if(arr == NULL || nLength <= 0)return;
	
	//找最大值 最小值
	int nMin;
	int nMax;

	nMax = arr[0];
	nMin = arr[0];

	int i;
	for(i = 1;i<nLength;i++)
	{
		if(arr[i] > nMax)
		{
			nMax = arr[i];
		}
		if(arr[i] < nMin)
		{
			nMin = arr[i];
		}
	}

	//计算位数
	int nCount = 1;
	int nNum = nMin;
	
	while(nNum)
	{
		nCount*=10;
		nNum/=10;
	}

	nCount/=10;

	int nMinIndex;
	int nMaxIndex;
	nMinIndex = nMin/nCount;
	nMaxIndex = nMax/nCount;

	//桶
	Bucket **pBucket = (Bucket**)malloc(sizeof(Bucket*)*(nMaxIndex-nMinIndex+1));
	memset(pBucket,0,sizeof(Bucket*)*(nMaxIndex-nMinIndex+1));

	//入桶
	Bucket *pTemp = NULL;
	int nIndex;

	for(i = 0;i<nLength;i++)
	{
		pTemp = (Bucket*)malloc(sizeof(Bucket));
		pTemp->nValue = arr[i];
		pTemp->pNext = NULL;
		pTemp->pPre = NULL;

		nIndex = arr[i]/nCount - nMinIndex ;

		//添加
		pTemp->pNext = pBucket[nIndex];

		if(pBucket[nIndex] != NULL)
		{
			pBucket[nIndex]->pPre = pTemp;
		}

		pBucket[nIndex] = pTemp;
	}

	//各桶之内排序
	for(i = 0;i<nMaxIndex-nMinIndex+1;i++)
	{
		Sort(pBucket[i]);
	}
	
	//元素放回原数组
	int j = 0;
	for(i = 0;i<nMaxIndex-nMinIndex+1;i++)
	{
		pTemp = pBucket[i];
		while(pTemp)
		{
			arr[j] = pTemp->nValue;
			j++;
			pTemp = pTemp->pNext;
		}
	}

	//释放
	Bucket *pDel = NULL;
	for(i = 0;i<nMaxIndex-nMinIndex+1;i++)
	{
		pTemp = pBucket[i];
		while(pTemp)
		{
			pDel = pTemp;
			pTemp = pTemp->pNext;
			
			free(pDel);
			pDel = NULL;
		}
	}

	free(pBucket);
	pBucket = NULL;
}


int main()
{
	int arr[] = {104,335,961,922,452,736,108,222,910};
	BucketSort(arr,sizeof(arr)/sizeof(arr[0]));

	int i;
	for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		printf("%d ",arr[i]);
	}
	return 0;
}

10.基数排序

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

typedef struct radix
{
	int nValue;
	struct radix *pNext;
}Radix;


void Sort(int arr[],int nLoopTimes,Radix **pRadix,int nBegin)
{
	int nBase = 1;

	//计算被除基数
	while(nBegin > 1)
	{
		nBase*=10;
		nBegin--;
	}
	
	Radix *pTemp = NULL;
	int nIndex;
	int i;
	Radix *pNode = NULL;
	for(i = 0;i<nLoopTimes;i++)
	{
		nIndex = arr[i]/nBase%10;

		pTemp = (Radix*)malloc(sizeof(Radix));
		pTemp->nValue = arr[i];
		pTemp->pNext = NULL;

		//尾添加
		if(pRadix[nIndex] == NULL)
		{
			pRadix[nIndex] = pTemp;
		}
		else
		{
			pNode = pRadix[nIndex];
			while(pNode->pNext != NULL)
			{
				pNode = pNode->pNext;
			}
			pNode->pNext = pTemp;
		}
	}

	//数据放回原数组
	int j = 0;
	for(i = 0;i<10;i++)
	{
		pTemp = pRadix[i];
		while(pTemp)
		{
			arr[j] = pTemp->nValue;
			j++;
			pTemp = pTemp->pNext;
		}
	}

	//释放小链表
	for(i = 0;i<10;i++)
	{
		pTemp = pRadix[i];
		while(pTemp)
		{
			pNode = pTemp;
			pTemp = pTemp->pNext;
			free(pNode);
			pNode = NULL;
		}
	}

	//清空表头
	memset(pRadix,0,sizeof(Radix*)*10);
}



void RadixSort(int arr[],int nLength)
{
	if(arr == NULL || nLength <= 0)return;
	
	//最大值
	int i;
	int nMax;
	nMax = arr[0];

	for(i  =1;i<nLength;i++)
	{
		if(arr[i] > nMax)
		{
			nMax = arr[i];
		}
	}

	//计算最大值位数
	int nLoopTimes = 0;
	while(nMax)
	{
		nMax/=10;
		nLoopTimes++;
	}
	
	Radix **pRadix = (Radix**)malloc(sizeof(Radix*)*10);
	memset(pRadix,0,sizeof(Radix*)*10);

	//按照各位进行入桶
	for(i = 1;i<=nLoopTimes;i++)
	{
		Sort(arr,nLength,pRadix,i);		
	}

	//释放
	free(pRadix);
	pRadix = NULL;
}


int main()
{
	int arr[] = {10,5,91,9,2,36,108,222,9100};
	RadixSort(arr,sizeof(arr)/sizeof(arr[0]));

	int i;
	for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		printf("%d ",arr[i]);
	}
	return 0;
}

 

我爱宝贝双
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
冒泡排序和快速排序
cjydsg123的博客
08-23 398
排序算法中重要的两种排序
各类排序代码实现
啊奥的博客
07-23 5190
以下各种排序算法是我自己跟着算法描述写的（有参考其他人的），直接贴到VS里就能用，如果要看懂的话还是需要了解一下各种排序算法的实现原理 先随手总结一下各种排序的时间复杂度以及稳定性 排序算法 时间复杂度 辅助空间 稳定性 冒泡排序(交换排序类) O(n^2) ...
常见的八种基本排序的代码
tingzs111的博客
07-05 4270
简单的介绍了一下常见的七种排序以及一种非比较排序中的计数排序。
排序及其代码详解~
m0_64028711的博客
09-25 1100
有七大重要排序及其代码详解~ 此处end表示一组数据有序序列的最后一位，用 i 控制，tmp则表示有序数据之后的一位数据，也就是我们需要插入有序数列中的数。
简单排序算法代码
xiaosutongxue的博客
05-03 1131
以下内容是对所学算法的一个整理 参考了 Runoob与OI WiKi 如有错误 烦请指正！ 插入排序 将无序子序列的元素依次通过比较插入有序子序列中 适用于基本正向有序/n较小的情况 选择排序 第i次选择时 “选择”序列中第i小的记录，并把该记录放到序列的第i个位置上 相当于每一趟都扫描剩余的序列元素 并将最小值放到剩余序列的第一个位置 已选择过的元素不再进行扫描 适用于地址排序 算法稳定性 ​ 假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即
c语言排序系统代码怎么写,排序概述（c语言）(示例代码)
weixin_42124497的博客
05-25 808
排序问题可以说是算法入门中的入门了，可尽管如此，算法这个东西还是让许多初学者伤透了脑筋(such as me~)。But，然而，但是，排序小结来了(基于c语言)，希望能给读者包括笔者本身带来理解上的新体验。1.冒泡排序。所谓冒泡排序，从字面就可大体了解，对一系列数，对满足条件的数，让其依次“冒泡浮出”。其基本思路是：每次将相邻两个数进行比较，将小的数(或大的数，看你需要逆序还是顺序)调到前头去。这...
快速排序(代码通俗易懂，干净整洁)
qq_50723277的博客
03-21 2万+
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、快速排序思路二、快速排序代码三、读入数据总结 前言 快速排序的特点 1、快速排序是对冒泡算法的改进。 2、快速排序的基本思想是对要排序的数组进行划分，使左边的小于某个数，右边的大于某个数。重复执行以上划分，直到有序为止。(这里主要针对递增排序) 提示：以下是本篇文章正文内容，下面案例可供参考 一、快速排序思路 (1)定义两个变量low、high分别标识数组的第一个元素下标和最后一个元素下标。 (2)定义变量key先存储.
十种排序的Java代码实现
02-06
本资源提供了十种不同的排序算法的Java代码实现，这有助于开发者深入理解各种算法的工作原理，并在实际项目中根据需求选择合适的排序方式。 1. 冒泡排序（Bubble Sort）：冒泡排序是一种简单的排序算法，通过重复...
js冒泡排序两种排序代码
06-28
本文件编辑了两种js冒泡排序代码，亲测可用，bblSort(arr)， bubbleSort(arr)，传入排序数组，然后就可以调用函数就可以以冒泡排序对数组进行排序，欢迎大家的下载实用，如有问题可以给我发送邮箱china_zdw202308...
C语言几种排序代码
07-07
本主题聚焦于C语言实现的排序算法，其中包括了十种不同的排序方法，每一种都有其独特的应用背景和效率特点。下面我们将详细探讨这些排序算法的原理、步骤以及它们在C语言中的实现。 1. **冒泡排序**：这是一种简单...
几种排序代码
11-17
（1）直接插入排序算法验证。 （2）快速排序算法验证。 （3）直接选择排序算法验证。 几种简单的排序算法代码
java冒泡排序代码
08-06
java冒泡排序代码，亲测能用，控制台输入数据，自动排序
常见的排序算法及其代码实现（C++）
oreo的博客
09-29 907
最近学习了几种常见的排序算法，再回过头梳理这些算法的时候，发现某些排序算法虽然思想不同，但是有着很多相似的特点。因此，在此对其进行整理和梳理。本文的排序算法按照时间复杂度分为O（n2）以及O（nlog(n)）级别的排序算法，如下述表格所示，下面会针对每个算法进行简单的介绍。 O（n2） O（nlog(n)） 冒泡排序 归并排序 选择排序 快速排序 插入排序
10种排序算法及代码实现
weixin_45548912的博客
05-27 2038
十大经典排序算法 0、算法概述 0.1 算法分类 十种常见排序算法可以分为两大类： 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。 0.2 算法复杂度 0.3 相关概念 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b
数据结构 常用八大排序算法及代码实现
热门推荐
海吹的技术博客
08-13 3万+
一、排序的介绍 1. 排序的分类 按照排序过程中所依据的原则的不同可以分类为: ►插入排序：直接插入排序 希尔排序 ►交换排序：冒泡排序 快速排序 ►选择排序：简单选择排序 堆排序 ►归并排序 ►基数排序 2. 排序算法比较 排序方法 最好时间 平均时间 最坏时间 ...
8种排序算法(有代码)
NotePad
03-13 1262
 1.简单的选择排序 代码:bool selectionsort(int *array,int n)     //array为存储数据的数组,n为数组元素个数{int k,temp;        //k用来存储,临时最小数据的位置for(int i=0;i{   k=i;          for(int j=i+1;jif(array[j]k=j;   if(k!=i)    //
用C语言实现常见的几个排序方法
写自己的代码，让别人去看吧
11-20 1万+
//排序方法通过 （函数调用） 的方式实现 //(1)直接插入排序 /* #include #define N 100 void Insertsort(int data[],int n)  //实现插入排序方法： { int i,j,temp; for(i=1;i { /* if(data[i] { data[0]=data[i]; data[i]=data
排序思想，代码实现和优缺点比较
Ferlan的博客
06-14 580
void insert_sort(int *a, int size) { //插入排序： //每一步将一个待排序的元素，插入到前面已经有序的一组元素中， //直到元素排完为止。 assert(a); assert(size&amp;amp;amp;amp;amp;amp;amp;gt;0); for (int i = 1;i &amp;amp;amp;amp;amp;amp;amp;lt; size;i++) {
初始C++
最新发布
2302_81016149的博客
07-08 623
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
c 排序源代码 大全
04-02
快速排序是一种常用且高效的排序算法，通过不断地将数组分割成较小的子数组，并按照基准值进行排序，最终实现整个数组的排序。其基本思想是选择一个基准值，然后将数组分为两部分，小于基准值的放在左边，大于基准值...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值