蓝桥杯 BASIC-13 数列排序

问题描述
  给定一个长度为n的数列,将这个数列按从小到大的顺序排列。1<=n<=200
输入格式
  第一行为一个整数n。
  第二行包含n个整数,为待排序的数,每个整数的绝对值小于10000。
输出格式
  输出一行,按从小到大的顺序输出排序后的数列。
样例输入
5
8 3 6 4 9
样例输出
3 4 6 8 9

冒泡排序

冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。
它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果他们的顺序(如从大到小、首字母从A到Z)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换,也就是说该元素已经排序完成。

实质:把小(大)的元素往前(后)调

冒泡排序算法的原理如下:

  1. 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
  2. 对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
  3. 针对所有的元素重复以上的步骤,除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
    蓝桥杯 BASIC-13 数列排序_第1张图片
    代码
#include
int main()
{
	unsigned int n,i,j,t;
	scanf("%d",&n);
	int P[n];
	for(i=0;i<=n-1;i++)
	{
		scanf("%d",&P[i]);
	}
	for(j=n;j>=1;j--)
	{
		for(i=0;iP[i+1])
		{
			t=P[i+1];
			P[i+1]=P[i];
			P[i]=t;
		}
	}
		for(i=0;i<=n-1;i++)	
		{
		printf("%d",P[i]);
		printf(" ");
		}
	return 0;
}

选择排序
选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。

思想
n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果:

  1. 初始状态:无序区为R[1…n],有序区为空。
  2. 第1趟排序第1趟排序,在无序区R[1…n]中选出关键字最小的记录R[k],将它与无序区的第1个记录R[1]交换,使R[1…1]和R[2…n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。……
  3. 第i趟排序第i趟排序
    第i趟排序开始时,当前有序区和无序区分别为R[1…i-1]和R(i…n)。该趟排序从当前无序区中选出关键字最小的记录 R[k],将它与无序区的第1个记录R交换,使R[1…i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
    注意:选择排序法的第一层循环从起始元素开始选到倒数第二个元素,主要是在每次进入的第二层循环之前,将外层循环的下标赋值给临时变量,接下来的第二层循环中,如果发现有比这个最小位置处的元素更小的元素,则将那个更小的元素的下标赋给临时变量,最后,在二层循环退出后,如果临时变量改变,则说明,有比当前外层循环位置更小的元素,需要将这两个元素交换.

蓝桥杯 BASIC-13 数列排序_第2张图片
代码

#include
int main()
{
    int i,j,n,a[205],t,temp;
    scanf("%d",&n);
    for(i=0;ia[j])
            {
              a[i]=a[j];
              t=j;
            }
        }
        
        if(t

插入排序

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据,算法适用于少量数据的排序,时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分:第一部分包含了这个数组的所有元素,但将最后一个元素除外(让数组多一个空间才有插入的位置),而第二部分就只包含这一个元素(即待插入元素)。在第一部分排序完成后,再将这个最后元素插入到已排好序的第一部分中。
插入排序的基本思想是:每步将一个待排序的记录,按其关键码值的大小插入前面已经排序的文件中适当位置上,直到全部插入完为止。包括:直接插入排序,二分插入排序(又称折半插入排序)。

  • 直接插入排序
    直接插入排序是一种简单的插入排序法,其基本思想是:把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中,直到所有的记录插入完为止,得到一个新的有序序列。
    直接插入排序算法思路
    (1) 设置监视哨r[0],将待插入记录的值赋值给r[0];
    (2) 设置开始查找的位置j;
    (3) 在数组中进行搜索,搜索中将第j个记录后移,直至r[0].key≥r[j].key为止;
    (4) 将r[0]插入r[j+1]的位置上。
  • 折半插入排序(二分插入排序)
    将直接插入排序中寻找A[i]的插入位置的方法改为采用折半比较,即可得到折半插入排序算法。在处理A[i]时,A[0]……A[i-1]已经按关键码值排好序。所谓折半比较,就是在插入A[i]时,取A[i-1/2]的关键码值与A[i]的关键码值进行比较,如果A[i]的关键码值小于A[i-1/2]的关键码值,则说明A[i]只能插入A[0]到A[i-1/2]之间,故可以在A[0]到A[i-1/2-1]之间继续使用折半比较;否则只能插入A[i-1/2]到A[i-1]之间,故可以在A[i-1/2+1]到A[i-1]之间继续使用折半比较。如此担负,直到最后能够确定插入的位置为止。一般在A[k]和A[r]之间采用折半,其中间结点为A[k+r/2],经过一次比较即可排除一半记录,把可能插入的区间减小了一半,故称为折半。执行折半插入排序的前提是文件记录必须按顺序存储。
    折半插入算法的基本过程:
    (1)计算 0 ~ i-1 的中间点,用 i 索引处的元素与中间值进行比较,如果 i 索引处的元素大,说明要插入的这个元素应该在中间值和刚加入i索引之间,反之,就是在刚开始的位置 到中间值的位置,这样很简单的完成了折半;
    (2)在相应的半个范围里面找插入的位置时,不断的用(1)步骤缩小范围,不停的折半,范围依次缩小为 1/2 1/4 1/8 …快速的确定出第 i 个元素要插在什么地方;
    (3)确定位置之后,将整个序列后移,并将元素插入到相应位置。

蓝桥杯 BASIC-13 数列排序_第3张图片

代码

#include
void Sort(int *a,int n)
{	//插入排序 
	int i,j,temp,k;
	for(i=1;i=0&&a[j]>temp;j--)
		{
			a[j+1] = a[j];
		}
		a[j+1] = temp;
	}
}
int main()
{
	int n,*a;
	scanf("%d",&n);
	a = new int[n];
	for(int i=0;i

快速排序

快速排序(Quicksort)是对冒泡排序的一种改进。
快速排序由C. A. R. Hoare在1962年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
快速排序思想

  1. 设要排序的数组是A[0]……A[N-1],首先任意选取一个数据(通常选用数组的第一个数)作为关键数据,然后将所有比它小的数都放到它前面,所有比它大的数都放到它后面,这个过程称为一趟快速排序。
  2. 值得注意的是,快速排序不是一种稳定的排序算法,也就是说,多个相同的值的相对位置也许会在算法结束时产生变动。值得注意的是,快速排序不是一种稳定的排序算法,也就是说,多个相同的值的相对位置也许会在算法结束时产生变动。
    一趟快速排序的算法是:
    1)设置两个变量i、j,排序开始的时候:i=0,j=N-1;
    2)以第一个数组元素作为关键数据,赋值给key,即key=A[0];
    3)从j开始向前搜索,即由后开始向前搜索(j–),找到第一个小于key的值A[j],将A[j]的值赋给A[i];
    4)从i开始向后搜索,即由前开始向后搜索(i++),找到第一个大于key的A[i],将A[i]的值赋给A[j];
    5)重复第3、4步,直到i=j; (3,4步中,没找到符合条件的值,即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值,使得j=j-1,i=i+1,直至找到为止。找到符合条件的值,进行交换的时候i, j指针位置不变。另外,i==j这一过程一定正好是i+或j-完成的时候,此时令循环结束)。

蓝桥杯 BASIC-13 数列排序_第4张图片

代码

#include 
 
//划分——每次划分唯一确定一个元素位置
int Partition(int A[], int low, int high)
{
	int pivot = A[low];  
	while (low < high)
	{
		while (low < high && A[high] >= pivot)
		{
			--high;
		}
		A[low] = A[high];  //将比基准小的元素移动到左端
		while (low < high && A[low] <= pivot)
		{
			++low;
		}
		A[high] = A[low];  //将比基准小的元素移动到右端
	}
	A[low] = pivot;
	return low;
}
//快排——平均时间复杂度O(log2n)
void QuickSort(int A[], int low, int high)
{
	int pivotpos;
	if (low < high)
	{
		pivotpos = Partition(A,low,high);
		//依次对划分后的子表递归排序
		QuickSort(A,low,pivotpos-1);
		QuickSort(A,pivotpos+1,high);
	}
}
int main(void)
{
	int i, n, A[200];
	while (scanf("%d",&n) != EOF)  
	{
		for (i = 0; i < n; ++i)
		{
			scanf("%d",&A[i]);
		}
		QuickSort(A,0,n-1);
		//打印
		for (i = 0; i < n; ++i)
		{
			printf("%d ",A[i]);
		}
		printf("\n");
	}
	return 0;
} 

Sort排序

用于C++中,对给定区间所有元素进行排序。头文件是#include 。

  • 为什么要用c++标准库里的排序函数
    Sort()函数是c++一种排序方法之一,学会了这种方法也打消我学习c++以来使用的冒泡排序和选择排序所带来的执行效率不高的问题!因为它使用的排序方法是类似于快排的方法,时间复杂度为n*log2(n),执行效率较高!

  • c++标准库里的排序函数的使用方法
    I)Sort函数包含在头文件为#include的c++标准库中,调用标准库里的排序方法可以不必知道其内部是如何实现的,只要出现我们想要的结果即可!
    II)Sort函数有三个参数:
    (1)第一个是要排序的数组的起始地址。
    (2)第二个是结束的地址(最后一位要排序的地址的下一地址)
    (3)第三个参数是排序的方法,可以是从大到小也可是从小到大,还可以不写第三个参数,此时默认的排序方法是从小到大排序。
    Sort函数使用模板:
    Sort(start,end,排序方法)

蓝桥杯 BASIC-13 数列排序_第5张图片

代码

#include
#include //专属头文件 
using namespace std;
 
int main()
{
 
	int n,i,a[202];
	cin>>n;
	for(i=0;i>a[i];
	sort(a,a+n);//核心排序语句,默认从小到大; 
	for(i=0;i

运算结果

蓝桥杯 BASIC-13 数列排序_第6张图片

你可能感兴趣的:(c代码,蓝桥杯)