数据结构-排序

最新推荐文章于 2022-11-05 20:04:49 发布
最新推荐文章于 2022-11-05 20:04:49 发布
阅读量162 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_36391198/article/details/88533508
版权

1.选择排序

思想：选择排序是一种最为基本的排序方式，很简单，比如要将10个数字从小到大进行排序的话，可以按照如下步骤进行操作。首先记录第一个位置的数字，然后依次与后面的数字进行比较，如果比记录的数字小，则进行交换。然后记录第二个位置的数字继续上述操作，直至最后一个数为止。

代码如下：

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

void SelectSort(int arry[],int nLength)
{
	int i,j;
	int temp = 0;
	if(arry == NULL || nLength < 0)
	{
		return ;
	}
	for(i = 0;i < nLength ;i++)
	{
		for(j = i+1;j < nLength ;j++)
		{
			if(arry[j] < arry[i])
			{
				temp = arry[i];
				arry[i] = arry[j];
				arry[j] = temp;
			}
		}
	}
}
int main()
{
	int arry[] = {5,874,5,12,87,9,62,4};
	int nLength = sizeof(arry)/sizeof(arry[0]);
	int i = 0;
	SelectSort(arry,nLength);
	for(i = 0;i < nLength;i++)
	{
		printf("%d ",arry[i]);
	}
	system("pause");
	return 0;
}

2.冒泡排序

思想：冒泡排序的思想也比比较简单。每次将相邻的两个数进行比较，判断后进行交换或者不变，就可以将数字顺序排好。比如 有10个数按照从小到大的顺序进行排序，可以按照如下方式进行排序。将第一个位置与第二个位置的数字进行比较，如果第一个位置的数字大于第二个位置的数字，则将这两个数字进行交换，否则不变。然后让第二个位置与第三个位置的数做如上操作，将所有数字数字比较一遍后。ni'h你会发现，最大的数字已经在末尾处。继续如上操作，将第二大的数放在倒数第二个位置，如此重复n-1遍，结束排序。

代码如下：

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

void BubbleSort(int arry[],int nLength)
{
	int i,j;
	int nFlag = 0;
	if(arry == NULL || nLength < 0)
	{
		return ;
	}
	for(i = 0;i < nLength-1;i++)
	{
		nFlag = 0;
		for(j = 0;j < nLength - nFlag - 1;j++)
		{
			if(arry[j] > arry[j+1])
			{
				arry[j] = arry[j] + arry[j+1];
				arry[j+1] = arry[j] - arry[j+1];
				arry[j] = arry[j] - arry[j+1];
				nFlag = j+1;
			}

		}
		//如果排好序了，就不用继续遍历
		if(nFlag == 0)
		{
			break;
		}
		//后面的数排好序的越多 nFlag越小 i的值越大 需要遍历的次数越少
		i = nLength - nFlag - 1;
	}
}
int main()
{
	int arry[] = {5,874,5,12,87,9,62,4};
	int nLength = sizeof(arry)/sizeof(arry[0]);
	int i = 0;
	BubbleSort(arry,nLength);
	for(;i < nLength;i++)
	{
		printf("%d ",arry[i]);
	}
	system("pause");
	return 0;
}

3.插入排序

思想：插入排序是是先部分有序，然后从后面的数中依次与有序部分进行比较，比较完后插入有序表中，扩大有序部分直至所有 数字都变为有序状态。

代码如下：

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

void InsertSort(int arry[],int nLength)
{
	int i,j;
	int nFlag = 0;
	if(arry == NULL || nLength < 0)
	{
		return ;
	}
	for(i = 1;i < nLength;i++)
	{
		nFlag = arry[i];
		//排好的数的末位位置
		j = i-1;
		while(j >= 0 && arry[j] > nFlag)
		{
			//向后移
			arry[j+1] = arry[j];
			j--;
		}
		//结束后j比所需要的下标小1
		arry[j+1] = nFlag;
	}

}
int main()
{
	int arry[] = {5,874,5,12,87,9,62,4};
	int nLength = sizeof(arry)/sizeof(arry[0]);
	int i = 0;
	InsertSort(arry,nLength);
	for(;i < nLength;i++)
	{
		printf("%d ",arry[i]);
	}
	system("pause");
	return 0;
}

4.快排

思想：选择1个数作为基准，然后将数字分类。比如数字{5,874,5,12,87,9,62,4}，则可以以5为基准，将其分为{4,5}，{874,5,12,87,9,62},两部分，再将各部分进行上述操作，直至无法在分割为止。

代码如下：

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

void QuickSortUp(int arry[],int nPre,int nLast)
{
	int nSmall;
	int a,b;
	if(arry == NULL)
	{
		return ;
	}
	if(nPre >= nLast)
	{
		return;
	}
	nSmall = nPre - 1;
	a = nPre;
	b = nLast;
	//nLst作为标准 不变
	while(nPre != nLast)
	{
		//从nPre开始比较 如果小于标准
		if(arry[nPre] < arry[nLast])
		{
			//将nSmall加1
			nSmall++;
			//判断nSmall与nPre是否重合
			if(nSmall != nPre)
			{
				arry[nSmall] = arry[nPre] + arry[nSmall];
				arry[nPre] = arry[nSmall] - arry[nPre];
				arry[nSmall] = arry[nSmall] - arry[nPre];
			}
			nPre++;
		}else
		{
			//如果大于标准 只有nPre加1
			nPre++;
		}
	}
	nSmall++;
	if(nSmall != nLast)
	{
		arry[nSmall] = arry[nLast] + arry[nSmall];
		arry[nLast] = arry[nSmall] - arry[nLast];
		arry[nSmall] = arry[nSmall] - arry[nLast];
	}
	QuickSortUp(arry,a,nSmall - 1);
	QuickSortUp(arry,nSmall + 1,b);;
}
int main()
{
	int arry[] = {5,874,5,12,87,9,62,4};
	int nLength = sizeof(arry)/sizeof(arry[0]);
	int i = 0;
	QuickSortUp(arry,0,7);
	for(;i < nLength;i++)
	{
		printf("%d ",arry[i]);
	}
	system("pause");
	return 0;
}

5.堆排序

思想：堆排序是将数字构建成一颗二叉树，然后将调整这颗二叉树，比如大项堆就是将数字组成的堆进行调整，使得父节点都比 子节点的数大，注意是从从下往上调整的，且每次调整后倒要向下检查，看交换完当前值后是否还满足上述条件。每次取出时，将树的根元素与最后一个交换，弹出交换后的最后一个数字，然后重新调整堆。

代码如下：

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

#define  nLeft nRoot*2+1
#define  nRight nRoot*2+2
void Change(int arry[],int nRoot,int nLength)
{
	if(arry == NULL)
	{
		return ;
	}
	while(1)
	{
		if(nRight < nLength)
		{
			if(arry[nRight] > arry[nLeft])
			{
				if(arry[nRight] > arry[nRoot])
				{
					arry[nRoot] = arry[nRoot] + arry[nRight];
					arry[nRight] = arry[nRoot] - arry[nRight];
					arry[nRoot] = arry[nRoot] - arry[nRight];
					nRoot = nRight;
					continue;
				}
				break;
			}else
			{
				if(arry[nLeft] > arry[nRoot])
				{
					arry[nRoot] = arry[nRoot] + arry[nLeft];
					arry[nLeft] = arry[nRoot] - arry[nLeft];
					arry[nRoot] = arry[nRoot] - arry[nLeft];
					nRoot = nLeft;
					continue;
				}
				break;
			}
		}
		if(nLeft < nLength)
		{
			if(arry[nLeft] > arry[nRoot])
			{
				arry[nRoot] = arry[nRoot] + arry[nLeft];
				arry[nLeft] = arry[nRoot] - arry[nLeft];
				arry[nRoot] = arry[nRoot] - arry[nLeft];
				nRoot = nLeft;
				continue;
			}else
			{
				break;
			}
		}
		break;
	}
}


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

	for(i = nLength/2 - 1;i >= 0;i--)
	{
		Change(arry,i,nLength);
	}

	for(i = nLength - 1;i > 0;i--)
	{
		arry[i] = arry[i] + arry[0];
		arry[0] = arry[i] - arry[0];
		arry[i] = arry[i] - arry[0];
		Change(arry,0,i);
	}
}

int main()
{
	int arry[] = {5,874,5,12,87,9,62,4};
	int nLength = sizeof(arry)/sizeof(arry[0]);
	int i = 0;
	HeapSort(arry,nLength);
	for(;i < nLength;i++)
	{
		printf("%d ",arry[i]);
	}
	system("pause");
	return 0;
}

6.基数排序

思想：将所有数字按照个位数大小进行一遍排序，然后将其再按照十位数字排序，再按照百位数字排序，直至最大位为止。

代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
typedef struct MyStruct
{
	struct MyStruct * pNext;
	int nNum;
	int index;
}HashNode;
void LSD(int arry[],int nLength,int nNum)
{
	HashNode * pTemp = NULL;
	HashNode * * arr1 = NULL;
	HashNode * * arr2 = NULL;
	HashNode * p = NULL;
	HashNode * pj = NULL;
	HashNode * pDel = NULL;
	int nMax;
	int a,b,c;
	int i,j;
	if(arry == NULL)
	{
		return ;
	}
	nMax = arry[0];
	arr1 = (HashNode* *)malloc(sizeof(HashNode*)*(10));
	memset(arr1,0,sizeof(HashNode*)*(10));
	arr2 = (HashNode* *)malloc(sizeof(HashNode*)*(10));
	memset(arr2,0,sizeof(HashNode*)*(10));
	for(i = 1;i < nLength;i++)
	{
		if(arry[i] > nMax)
		{
			nMax = arry[i];
		}
	}

	for(i = 0;i < nLength;i++)
	{
		pTemp = (HashNode *)malloc(sizeof(HashNode));		
		pTemp->index = i;
		pTemp->pNext = NULL;
		pTemp->nNum = arry[i];
		b = arry[i]%10;
		if(arr1[arry[i]%10] == NULL)
		{
			arr1[arry[i]%10] = pTemp;
		}else
		{
			p = arr1[arry[i]%10];
			while(1)
			{
				if(p->pNext == NULL)
				{
					break;
				}
				p = p->pNext;
			}
			p->pNext = pTemp;
		}
	}
	j = 1;
	b = 1;
	while(nMax/(j * 10) != 0)
	{
		if(b%2 == 1)
		{
			for(a = 0;a < 10;a++)
			{
				pj = arr1[a];
				while(pj != NULL)
				{
					pTemp = (HashNode *)malloc(sizeof(HashNode));		
					pTemp->index = i;
					pTemp->pNext = NULL;
					pTemp->nNum = pj->nNum;
					c = pj->nNum/(10*j)%10;
					if(arr2[c] == NULL)
					{
						arr2[c] = pTemp;
					}else
					{
						p = arr2[c];
						while(1)
						{
							if(p->pNext == NULL)
							{
								break;
							}
							p = p->pNext;
						}
						p->pNext = pTemp;
					}
					pj = pj->pNext;
				}
			}
			for(a = 0;a < 10;a++)
			{
				p = arr1[a];
				while(p != NULL)
				{
					pDel = p->pNext;
					free(p);
					p = NULL;
					p = pDel;
				}
				arr1[a] = NULL;
			}
		}else
		{
			for(a = 0;a < 10;a++)
			{
				pj = arr2[a];
				while(pj != NULL)
				{
					pTemp = (HashNode *)malloc(sizeof(HashNode));		
					pTemp->index = i;
					pTemp->pNext = NULL;
					pTemp->nNum = pj->nNum;
					c = pj->nNum/(10*j)%10;
					if(arr1[c] == NULL)
					{
						arr1[c] = pTemp;
					}else
					{
						p = arr1[c];
						while(1)
						{
							if(p->pNext == NULL)
							{
								break;
							}
							p = p->pNext;
						}
						p->pNext = pTemp;
					}
					pj = pj->pNext;
				}
			}
			for(a = 0;a < 10;a++)
			{
				p = arr2[a];
				while(p != NULL)
				{
					pDel = p->pNext;
					free(p);
					p = NULL;
					p = pDel;
				}
				arr2[a] = NULL;
			}
		}
		j *= 10;
		b++;
	}
	i = 0;
	if(b%2 == 1)
	{
		for(a = 0;a < 10;a++)
		{
			p = arr1[a];
			while(p)
			{
				arry[i++] = p->nNum;
				p = p->pNext;
			}
		}
		for(a = 0;a < 10;a++)
		{
			p = arr1[a];
			while(p != NULL)
			{
				pDel = p->pNext;
				free(p);
				p = NULL;
				p = pDel;
			}
		}

	}else
	{
		for(a = 0;a < 10;a++)
		{
			p = arr2[a];
			while(p != NULL)
			{
				arry[i++] = p->nNum;
				p = p->pNext;
			}
		}
		for(a = 0;a < 10;a++)
		{
			p = arr2[a];
			while(p != NULL)
			{
				pDel = p->pNext;
				free(p);
				p = NULL;
				p = pDel;
			}
		}
	}
	
	return;
}
int main()
{
	int arry[] = {99,1,21,31,53,91,123,98,54,61,71,81,41,51,55,52};
	int nLength = sizeof(arry)/sizeof(arry[0]);
	int i = 0;
	LSD(arry,nLength,0);
	for(;i < nLength;i++)
	{
		printf("%d ",arry[i]);
	}
	system("pause");
	return 0;
}

7.希尔排序

思想：设置步长，将数组中相隔相同步长的设为一组进行排序，缩小步长，重复上述步骤，直至步长为1.

代码如下：

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

void ShellSort1(int arr[],int nLength)
{
	int gap; //步长
	int i;//组
	int j;
	int temp;//保存当前值
	int k;

	if(arr == NULL || nLength <=0)return;

	//计算步长
	for(gap = nLength/2;gap >0;gap /=2)
	{
		//根据步长分组
		//每组内部进行插入排序
		for(j = gap;j<nLength;j++)
		{
			k = j-gap;
			temp = arr[j];

			while(temp < arr[k] && k>=0)
			{
				arr[k+gap] = arr[k];
				k-=gap;
			}
			arr[k+gap] = temp;
		}
	}
}
void ShellSort(int arry[],int nLength)
{
	int nGroup ;
	int nDex;
	int i;
	int nFlag;
	if(arry == NULL)
	{
		return ;
	}
	nDex = 0;
	nGroup = nLength;
	while(nGroup = nGroup/2 > 0 && nDex < nLength)
	{
		for(nDex = 1;nDex < nLength;nDex += nGroup)
		{
			nFlag = arry[nDex];
			//将排好的数的末位
			i = nDex-1;
			while(i >= 0 && arry[i] > nFlag)
			{
				//向后移
				arry[i+nGroup] = arry[i];
				i-=nGroup;
			}
			//结束后j比所需要的下标小1
			arry[i+1] = nFlag;
		}
	}
}
int main()
{
	int arry[] = {5,874,5,122,87,9,62,4};
	int nLength = sizeof(arry)/sizeof(arry[0]);
	int i = 0;
	ShellSort1(arry,nLength);
	for(;i < nLength;i++)
	{
		printf("%d ",arry[i]);
	}
	system("pause");
	return 0;

}

 

天才狂想者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何将数组中的数字按照从小到大的顺序排列？？？
weixin_34203832的博客
06-25 2585
经过视频的学习，总结了一下，大神们请指教。。。。 如果要将数组中的数字按照从小到大的顺序排列。 完成思路：将最小的数字放在数组的第一项，将第二小的数组放在第二项，一直重复，知道完成。 那么如何将最小的数字放在数组索引为0的位置呢？ 示例： for（int j = i+1；j < arrays.Length;j++） { if (arrays[0] > a...
数据结构-排序整理 md版
03-15
主要是CSDN上广告太多啦，给大家提供md文档，简洁美观。完全是那篇博客的版本喔。
将数组元素按照从小到大的顺序排列
12-23
1、 在main方法中创建一个含有10个元素的int型数组，进行以下操作：（1）将数组元素按照从小到大的顺序排列；（2）对排好序的数组使用折半查找（使用递归和非递归两种形式分别实现）查找某一个int元素。
数据结构与算法之反转排序
weixin_42340416的博客
03-26 171
反转排序 把数组的内容进行反转 public class ReverseSortedArray { private int[] array = new int[]{1,2,3,4,5,6,7,8}; public void sortedArray(int[] arr){ int temp; if (arr.length == 0) { ret...
如何将倒序改为正序C语言,快速排序（正序+倒序）C语言版
weixin_39965881的博客
05-19 775
正序#include void sort(int *, int, int);void sort(int arr[], int left, int right){// 如果数组(子数组)只有1个元素时直接返回if (left == right) {return;}// i为左向右移动位置指针,j为右向左移动位置指针int i, j, tmp;// 第1个元素作为本轮排序的参考值i = left + ...
结构体数组，按照某一个结构体变量排序的简单方法
weixin_44313771的博客
08-12 4838
对于结构体数组如果要按某个结构体变量来从大到小，或者从小到大排序的简便方法，就是用sort来排序，除此之外sort如果想要按从大到小排序，我下面的代码也一样能实现 #include<stdio.h> #include<string.h> #include<algorithm> using namespace std; struct edge { int u; ...
数据结构-排序.ppt
07-11
数据结构-排序.ppt该文档详细且完整，值得借鉴下载使用，欢迎下载使用，有问题可以第一时间联系作者~
数据结构-排序(包括常用的插入排序，选择排序，冒泡排序等)
最新发布
01-11
数据结构-排序(包括常用的插入排序，选择排序，冒泡排序等)
数据结构--排序--思维导图.pdf
08-29
"数据结构--排序--思维导图" 数据结构中排序是指将一组无序的记录序列按照一定的规则排列成有序的序列，排序的目的是为了提高数据的存储和检索效率。排序算法的稳定性是指在排序过程中，如果待排序表中有两个元素Ri...
数据结构-排序算法对比
08-06
数据结构——排序算法对比
【数据结构与算法】排序问题
SunYutong_1234的博客
01-30 419
九种常见排序方法总结
反转排序算法（Reverse Sort）
脚踏实地，慢慢来
07-10 6762
反转排序算法的java代码实现。
数据结构之线性表的顺序存储（一）——初始化和倒序输出
掩扉Blog
10-27 2774
线性表之顺序存储初始化倒序输出   顺序表，全名顺序存储结构，是线性表的一种。“具有 ‘一对一’ 逻辑关系的数据按照次序连续存储到一整块物理空间上”的存储结构就是顺序存储结构。   我们就可以把线性表的顺序存储理解为是数组的拓展，物理空间上都是依次连续的这样一种用于存储数据的结构。首先是顺序表的初始化 初始化   我们首先需要了解到，循序表的结构是由一个基地址，一个当前存储长度和最大存储长度这三部分组成。我们可以先定义出一个顺序表的结构。   然后就是初始化了，我们需要对基地址先初始化，申请相应大小的动态
三种方法教你如何把数值类型的数组按从小到大的顺序排序
SuBaijiu的博客
11-05 8231
三种方法教你如何把数值类型的数组按从小到大的顺序排序
多种方法进行数组从小到大排序
lmdbhf的博客
07-27 1万+
数组排序： 一、使用Arrays工具类中的sort方法从小到大排序。 二、使用冒泡排序方法从小到大排序。 三、使用选择排序方法从小到大排序。
数组排序：给定一个数组，将数组中的元素从小到大排序
热门推荐
shutingzao的博客
10-19 5万+
代码思路：1.从数组中首元素开始和其他元素逐个比较，若其中一个元素比其小（或大），就交换首元素与其位置。 代码：#include<stdio.h> int sortArray(int *array,int account){ int temp; for(int i = 0;i < account;i++){ for(int j = i + 1;j < account;j++){ if(array[
数据结构——顺序表
TTTSEP9TH2244的博客
01-16 1346
一、实验目的 理解和掌握线性表的类型定义方法。 掌握顺序表中的基本运算，包括顺序表的创建、元素的添加、删除，判空及判满等基本操作。 二、实验要求 【项目1 – 验证性实验：顺序表的基本运算】 建立顺序表运算的算法库 算法库包括两个文件： 头文件：list.h，包含定义顺序表数据结构的代码、宏定义、要实现算法的函数的声明； 源文件：list.cpp，包含实现各种算法的函数的定义； 请采用程序的多文件组织形式，建立如上的两个文件，另外再建立一个源文件，编写main函数，完成相关的测试工作： 为了简单，Ele
将数组的数字按照从小到大的顺序进行排序
weixin_44164504的博客
08-12 3996
#include<stdio.h> #include<math.h> main() { int i,a[5]={2,4,1,3,6},temp; for(i=0;i<5;i++) { for(int j=i;j<5;j++) { if(a[i]>a[j]) { temp=a[j]; a[j]=a[i]; a[i]=temp; } } printf("%d",a[i]); } }
C语言—数组元素按大小排序
m0_62475462的博客
03-04 3万+
1.方法思想 数组在C语言中即为数据类型相同的一组数，将一组无规则数按大小依次排序并输出，可以采取冒泡排序的思想，所谓冒泡排序就是数字像汽水中的气泡一样总是向某个方向前进，最终到达最终点。 假设我们定义了一组数组，从左到右 a[0] ~ a[9] 共10个数组元素，将a[0]与a[1]对比，如果a[0]大于等于a[1]，就将二者的数对换（注意这里是将两者代表的数交换大小，而不是将1和0交换，a[1]和a[0]相当于两个容器，是用来装数字的），这样大的数就处于右边，否则不做...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值