09-排序1 排序

题目

• 给定NN个（长整型范围内的）整数，要求输出从小到大排序后的结果。

本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下：

数据1：只有1个元素；
数据2：11个不相同的整数，测试基本正确性；
数据3：103个随机整数；
数据4：104个随机整数；
数据5：105个随机整数；
数据6：105个顺序整数；
数据7：105个逆序整数；
数据8：105个基本有序的整数；
数据9：105个随机正整数，每个数字不超过1000。

输入格式:

• 输入第一行给出正整数N（≤10​5​​ ），随后一行给出N个（长整型范围内的）整数，其间以空格分隔。

输出格式:

• 在一行中输出从小到大排序后的结果，数字间以1个空格分隔，行末不得有多余空格。

输入样例:

11
4 981 10 -17 0 -20 29 50 8 43 -5

输出样例:

-20 -17 -5 0 4 8 10 29 43 50 981

AC代码

/*!
 * \file 排序.cpp
 *
 * \author ranjiewen
 * \date 2017/05/01 15:09
 *
 * 
 */

#include<iostream>

using namespace std;

#define ElementType int
#define MaxNum 100001

void X_Sort(ElementType A[], int N);

void Bubble_Sort(ElementType A[], int N)
{
	for (int P = N - 1; P >= 0;P--)
	{
		int flag = 0;
		for (int i = 0; i < P; i++)  /*一趟冒泡排序*/
		{
			if (A[i]>A[i+1])
			{
				int temp = A[i];
				A[i] = A[i + 1];
				A[i + 1] = temp;
				flag = 1;/*标识发生了交换*/
			}
		}
		if (flag==0)
		{
			break; /*全程无交换*/
		}
	}
}

void Insertion_Sort(ElementType A[], int N)
{
	for (int P = 1; P < N;P++) //第一张已在手
	{
		int temp = A[P];/*摸一下张*/
		for (int i = P; i>0 && A[i - 1] > temp;i--)
		{
			A[i] = A[i - 1]; //依次与已排序序列中元素比较并右移
		}
		A[P] = temp;
	}
}

//原始的shell排序--theta(N*N)
void Shell_Sort(ElementType A[], int N)
{
	for (int D = N / 2; D > 0; D++) /*希尔增量序列*/
	{
		for (int P = D; P < N;P++) //插入排序
		{
			int temp = A[P];
			for (int i = P; i >= D&&A[i - D]>temp;i-=D)
			{
				A[i] = A[i - D];
			}
			A[P] = temp;
		}
	}
}

void ShellSort(ElementType A[], int N)
{ /* 希尔排序 - 用Sedgewick增量序列 */
	int Si, D, P, i;
	ElementType Tmp;
	/* 这里只列出一小部分增量 */
	int Sedgewick[] = { 929, 505, 209, 109, 41, 19, 5, 1, 0 };

	for (Si = 0; Sedgewick[Si] >= N; Si++)
		; /* 初始的增量Sedgewick[Si]不能超过待排序列长度 */

	for (D = Sedgewick[Si]; D > 0; D = Sedgewick[++Si])
	for (P = D; P<N; P++) { /* 插入排序*/
		Tmp = A[P];
		for (i = P; i >= D && A[i - D]>Tmp; i -= D)
			A[i] = A[i - D];
		A[i] = Tmp;
	}
}

void PercDown(ElementType A[], int p, int N)
{ /* 改编代码4.24的PercDown( MaxHeap H, int p )    */
	/* 将N个元素的数组中以A[p]为根的子堆调整为最大堆 */
	int Parent, Child;
	ElementType X;

	X = A[p]; /* 取出根结点存放的值 */
	for (Parent = p; (Parent * 2 + 1) < N; Parent = Child) {
		Child = Parent * 2 + 1;
		if ((Child != N - 1) && (A[Child] < A[Child + 1]))
			Child++;  /* Child指向左右子结点的较大者 */
		if (X >= A[Child]) break; /* 找到了合适位置 */
		else  /* 下滤X */
			A[Parent] = A[Child];
	}
	A[Parent] = X;
}

void Heap_Sort(ElementType A[], int N) //和堆的操作有点不一样：这里从0开始存储元素，堆的操作0位置为哨兵
{
	for (int i = N / 2 - 1; i >= 0; i--) /*buildMaxHeap建立最大堆*/
	{
		PercDown(A, i, N);
	}

	for (int i = N - 1; i > 0;i--)
	{
		/*删除最大堆顶*/
		int temp = A[0];
		A[0] = A[i];
		A[i] = temp;
		PercDown(A, 0, i); //长度减1,依次建立
	}
}

/* L = 左边起始位置, R = 右边起始位置, RightEnd = 右边终点位置*/
void Merge(ElementType A[], ElementType TmpA[], int L, int R, int RightEnd)
{ /* 将有序的A[L]~A[R-1]和A[R]~A[RightEnd]归并成一个有序序列 */

	int LeftEnd = R - 1; /* 左边终点位置 */
	int temp = L;         /* 有序序列的起始位置 */
	int NumElements = RightEnd - L + 1;

	while (L <= LeftEnd && R <= RightEnd) {
		if (A[L] <= A[R])
			TmpA[temp++] = A[L++]; /* 将左边元素复制到TmpA */
		else
			TmpA[temp++] = A[R++]; /* 将右边元素复制到TmpA */
	}

	while (L <= LeftEnd)
		TmpA[temp++] = A[L++]; /* 直接复制左边剩下的 */
	while (R <= RightEnd)
		TmpA[temp++] = A[R++]; /* 直接复制右边剩下的 */

	for (int i = 0; i < NumElements; i++, RightEnd--)
		A[RightEnd] = TmpA[RightEnd]; /* 将有序的TmpA[]复制回A[] */
}

/* 核心递归排序函数 */
void Msort(ElementType A[], ElementType TmpA[], int L, int RightEnd)
{
	int Center;

	if (L < RightEnd) {
		Center = (L + RightEnd) / 2;
		Msort(A, TmpA, L, Center);              /* 递归解决左边 */
		Msort(A, TmpA, Center + 1, RightEnd);     /* 递归解决右边 */
		Merge(A, TmpA, L, Center + 1, RightEnd);  /* 合并两段有序序列 */
	}
}
/* 归并排序接口函数 */
void MergeSort(ElementType A[], int N)
{
	ElementType *TmpA;
	TmpA = (ElementType *)malloc(N*sizeof(ElementType));

	if (TmpA != NULL) {
		Msort(A, TmpA, 0, N - 1);
		free(TmpA);
	}
	else printf("空间不足");
}

/* length = 当前有序子列的长度*/
void Merge_pass(ElementType A[], ElementType TmpA[], int N, int length)
{ /* 两两归并相邻有序子列 */
	int i, j;

	for (i = 0; i <= N - 2 * length; i += 2 * length)
		Merge(A, TmpA, i, i + length, i + 2 * length - 1);
	if (i + length < N) /* 归并最后2个子列*/
		Merge(A, TmpA, i, i + length, N - 1);
	else /* 最后只剩1个子列*/
	for (j = i; j < N; j++) TmpA[j] = A[j];
}

void Merge_Sort(ElementType A[], int N)
{
	int length;
	ElementType *TmpA;

	length = 1; /* 初始化子序列长度*/
	TmpA = (ElementType *)malloc(N * sizeof(ElementType));
	if (TmpA != NULL) {
		while (length < N) {
			Merge_pass(A, TmpA, N, length);
			length *= 2;
			Merge_pass(TmpA, A, N, length);
			length *= 2;
		}
		free(TmpA);
	}
	else printf("空间不足");
}

int main()
{
	int N,data[MaxNum];
	cin >> N;
	for (int i = 0; i < N;i++)
	{
		cin >> data[i];
	}
	
	Bubble_Sort(data, N);
	//Insertion_Sort(data, N);

	//ShellSort(data, N);
	//Shell_Sort(data, N);

	//Heap_Sort(data, N);
	//Merge_Sort(data, N);

	for (int i = 0; i < N; i++)
	{
		if (i==0)
		{
			printf("%d", data[i]);
		}
		else
		{
			printf(" %d", data[i]);
		}
	}
		
	return 0;
}

实验结果

• 堆排序的结果：

• 冒泡排序的结果：数据多了超时