排序--冒泡排序、插入排序、希尔排序

这次研究 一下各种排序，也是利用一下pat系统的07-1

题目：

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

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

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

输入格式：

输入第一行给出正整数N（<= 10⁵），随后一行给出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

冒泡排序：

void Bubble_sort(int 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 tmp = A[i];
				A[i] = A[i+1];
				A[i+1] = tmp;
			}
			flag=1;			//发生了交换 
		}
		if(flag==0)			//如果全程无交换，则表明序列已经有序 
			break;
	}
}

测试结果：

插入排序：

void Insertion_sort(int A[],int N)						//插入排序 
{
	for(int p=1;p<N;p++)
	{
		int tmp = A[p];		//插入下一个数 
		int i; 
		for(i=p;i>0 && A[i-1]>tmp;i--)
			A[i] = A[i-1];	//往后移动一位 
		A[i] = tmp;			//插入到A[i]位 
	}
} 

测试结果：

希尔排序：

在测试中，我使用的是Hibbard增量序列，Sedgewick增量序列表达式太复杂

<span style="font-size:12px;">//希尔增量序列   Hibbard：Dk=2^k-1  Sedgewick:  Dk=4^i-3*2^i+1
void Shell_sort(int A[],int N)
{
	int k,p,tmp,i;
	int s=log2(N);	
	for(k=f(2,s)-1;k>0;k=f(2,log2(k+1)-1)-1)	//希尔增量序列(使用了Hibbard序列)
//	for(k=N/2;k>0;k/=2)							//这个是原始增量序列 
	{
		for(p=k;p<N;p++) 
		{
			tmp = A[p];
			for(i=p;i>=k && A[i-k]>tmp;i-=k)		//插入排序 
				A[i] = A[i-k]; 
			A[i] = tmp; 
		}
	} 
} </span>

测试结果：

可以发现，当数的数量很大时，用时大大减少

==========================================================================================================

时间很晚了，今天先写这三种排序，后面的明天再加。

继续往下加

==========================================================================================================================

归并排序

算法代码中，我使用的是非递归的，递归的效率有时候很低，所以一向不太喜欢

//归并排序 
// L=左边起始位置  ，R=有限起始位置 ， RightEnd=右边终止位置 
void Merge1(int A[],int tmp[],int L,int R,int RightEnd)
{
	int LeftEnd = R-1;		//左边终点位置，假设左右两边挨着 
	int Tmp = L;			//存放结果数组的初始位置
	while(L<=LeftEnd && R<=RightEnd)
	{
		if(A[L]<=A[R])
			tmp[Tmp++] = A[L++];
		else
			tmp[Tmp++] = A[R++];
	} 
	while(L<=LeftEnd)		//直接复制左边剩下的 
		tmp[Tmp++] = A[L++];
	while(R<=RightEnd)		//直接复制右边剩下的 
		tmp[Tmp++] = A[R++];
}
//一趟的归并 
void Merge_pass(int A[],int tmp[],int N,int length)		//length为当前有序子列的长度 
{
	int i,j; 
	for(i=0;i<=N-2*length;i+=2*length)
		Merge1(A,tmp,i,i+length,i+2*length-1);
	if(i+length<N)										//归并最后2个子列 
		Merge1(A,tmp,i,i+length,N-1);
	else
	{												//最后只剩下一个子列 
		for(j=i;j<N;j++)
			tmp[j] = A[j]; 
	}
}
//归并排序传统接口 
void Merge_sort(int A[],int N)
{
	int length=1;		//初始化有序子列的长度
	int *tmp = new int[N];
	if(tmp != NULL)
	{
		while(length < N)
		{
			Merge_pass(A,tmp,N,length);
			length *= 2;
			Merge_pass(tmp,A,N,length);
			length *= 2;
		}
		delete(tmp);
	} 
	else
		cout<<"空间不足！"<<endl; 
}

接下来看看测试结果：

通过观察，说明归并排序的效率的确高

选择排序

<span style="font-size:12px;">//选择排序 
void Selection_sort(int A[],int N)
{
	for(int i=0;i<N;i++)
	{
		int MinPosition = i;			//从A[i]到A[N-1]中找到最小元，
		int minNum = A[i];
        for(int j=i; j<N; j++)
        {
            if(A[j] < minNum)
            {
                minNum = A[j];
                MinPosition = j;
            }
        }
		int tmp;
		tmp = A[i]; A[i]=A[MinPosition];A[MinPosition]=tmp;				//将末端排序部分的最小元换到有序部分的最后位置 
	 } 
}</span>

测试结果：

这是最简单的选择排序，所以当数量很大时，就会超时。选择排序在求最小元时可以进行优化，堆排序就是一种，堆排序代码量很大，以后再更新到博客上