排序算法

//Sort.cpp
#include<iostream>
using namespace std;
//直接插入排序
void InsertSort(int r[], int n)
{	
	int i,j,k;
	for ( i=2; i<=n; i++)
	{ 
		r[0]=r[i];                        //设置哨兵
		for ( j=i-1; r[0]<r[j]; j--)   //寻找插入位置
			r[j+1]=r[j];                //记录后移
		r[j+1]=r[0];                 
	}
	for( k=1;k<n;k++)
		cout<<r[k]<<" ";	  
	cout<<"\n";
}

//希尔排序
void ShellSort(int r[], int n)
{	
	int i,d, j;
	for (d=n/2; d>=1; d=d/2)   //以增量为d进行直接插入排序
	{
		for (i=d+1; i<=n; i++)    
		{   
			r[0]=r[i];                 //暂存被插入记录
			for (j=i-d; j>0 && r[0]<r[j]; j=j-d)
				r[j+d]=r[j];       //记录后移d个位置
			r[j+d]=r[0];
		}
	}
	for(i=1;i<n;i++)
		cout<<r[i]<<" ";
	cout<<"\n";
}
void swap1(int r[],int i,int j)
{
	int temp;
	temp=r[i];
	r[i]=r[j];
	r[j]=temp;
}
void BubbleSort0(int r[],int n)
{ 
	int i,j;
	for(i=0;i<n-1;i++)        
		for(j=0;j<n-1-i;j++)       
			if(r[j]>r[j+1])
				swap1(r,j,j+1);
}

//起泡排序
void BubbleSort(int r[], int n)
{
	int exchange;
	int bound;
	exchange=n-1;                       //第一趟起泡排序的范围是r[0]到r[n-1]	
	while (exchange)                    //仅当上一趟排序有记录交换才进行本趟排序
	{
		bound=exchange; 
		exchange=0;  
		for (int j=0; j<bound; j++)     //一趟起泡排序
			if (r[j]>r[j+1]) 
			{
				swap1(r,j,j+1);                //记录每一次发生记录交换的位置
				exchange=j;
			}
	}
	for(int i=0;i<n;i++)
		cout<<r[i]<<" ";
	cout<<"\n";
}


//快速排序一次划分
/* 交换顺序表r中子表的记录，使枢轴记录到位，并返回其所在位置 */
/* 此时在它之前(后)的记录均不大(小)于它。 */
int Partition(int r[], int first, int end)
{	
	int pivotkey;
	pivotkey=r[first];
	while (first<end)	
	{  
		while (first<end&& r[end]>= pivotkey)
			end--;                        //右侧扫描
		swap1(r,first,end); /* 将比枢轴记录小的记录交换到低端 */
		while (first<end && r[first]<= pivotkey) 
			first++;                         //左侧扫描
		swap1(r,first,end);  /* 将比枢轴记录大的记录交换到高端 */
	}
	return first;                           //first为轴值记录的最终位置
}

//快速排序
void QuickSort(int r[], int first, int end)
{
	if (first<end) 
	{                                   //递归结束
		int pivot=Partition(r, first, end);  //一次划分
		QuickSort(r, first, pivot-1);//递归地对左侧子序列进行快速排序
		QuickSort(r, pivot+1, end);  //递归地对右侧子序列进行快速排序
	}
}

//简单选择排序
void SelectSort(int r[ ], int n)
{ 
	int i,j;
	int index;
	for (i=0; i<n-1; i++)  //对n个记录进行n-1趟简单选择排序
	{  
		index=i; 		
		for (j=i+1; j<n; j++)    //在无序区中选取最小记录
			if (r[j]<r[index])
				index=j;
		if (index!=i)  /* 若index不等于i，说明找到最小值，交换 */
			swap1(r,i,index); /* 交换r[i]与L->r[index]的值 */
	}
	for(i=0;i<n;i++)
		cout<<r[i]<<" ";
	cout<<"\n";
}


//筛选法调整堆
void Sift(int r[], int k, int m)
{

	int i;
	int j;
	int temp;
	i=k; 
	j=2*i+1;                            //置i为要筛的结点，j为i的左孩子
	while (j<=m)                          //筛选还没有进行到叶子
	{
		if (j<m && r[j]<r[j+1]) 
			j++;                          //比较i的左右孩子，j为较大者
		if (r[i]>r[j]) break;             //根结点已经大于左右孩子中的较大者
		else 
		{
			temp=r[i];
			r[i]=r[j];
			r[j]=temp;                   //将根结点与结点j交换
			i=j;
			j=2*i+1;                     //被筛结点位于原来结点j的位置
		}
	}
}
//堆排序
void HeapSort(int r[ ], int n)
{

	int i;
	int temp;
	for (i=n/2; i>=0; i--)                //初始建堆，从最后一个非终端结点至根结点
		Sift(r, i, n) ;     
	for (i=n-1; i>0; i--)                //重复执行移走堆顶及重建堆的操作
	{
		temp=r[i];
		r[i]=r[0];
		r[0]=temp;
		Sift(r, 0, i-1);
	}
	for(i=0;i<n;i++)
		cout<<r[i]<<" ";
	cout<<"\n";
}


//一次归并
void Merge(int r[], int r1[], int s, int m, int t)
{

	int i=s;
	int j=m+1;
	int k=s;

	while (i<=m && j<=t)
	{   
		if (r[i]<=r[j]) 
			r1[k++]=r[i++];            //取r[i]和r[j]中较小者放入r1[k]
		else 
			r1[k++]=r[j++]; 
	}
	if (i<=m) 
		while (i<=m)                  //若第一个子序列没处理完，则进行收尾处理         
			r1[k++]=r[i++]; 
	else  
		while (j<=t)                  //若第二个子序列没处理完，则进行收尾处理        
			r1[k++]=r[j++]; 
}


//一趟归并
void MergePass(int r[ ], int r1[ ], int n, int h)
{
	int i=0;
	int k;

	while (i<=n-2*h)                     //待归并记录至少有两个长度为h的子序列
	{
		Merge(r, r1, i, i+h-1, i+2*h-1);
		i+=2*h;
	}
	if (i<n-h) 
		Merge(r, r1, i, i+h-1, n);       //待归并序列中有一个长度小于h
	else for (k=i; k<=n; k++)            //待归并序列中只剩一个子序列
		r1[k]=r[k];
}

//归并排序的非递归算法
void MergeSort1(int r[ ], int r1[ ], int n )
{ 
	int h=1;
	int i;

	while (h<n)
	{
		MergePass(r, r1, n-1, h);           //归并
		h=2*h;
		MergePass(r1, r, n-1, h);
		h=2*h;
	}
	for(i=0;i<n;i++)
		cout<<r[i]<<" ";
	cout<<"\n";
}

//归并排序的递归算法
void MergeSort2(int r[], int r1[], int r2[],int s, int t)
{ 

	int m;
	if (s==t) 
	{
		r1[s]=r[s];

	}
	else 
	{ 
		m=(s+t)/2;
		MergeSort2(r, r2, r1, s, m);        //归并排序前半个子序列		
		MergeSort2(r, r2, r1, m+1, t);      //归并排序后半个子序列
		Merge(r2, r1, s, m, t);             //将两个已排序的子序列归并 		
	}	 
}

//sortmain.cpp
#include <iostream>
using namespace std;
//void swap1(int r[],int i,int j);
void InsertSort(int r[], int n);                  //直接顺序排序
void ShellSort(int r[], int n);                   //希尔排序
void BubbleSort(int r[], int n);                  //起泡排序
void BubbleSort0(int r[], int n);     
int Partition(int r[], int first, int end);       //快速排序一次划分
void QuickSort(int r[], int first, int end);      //快速排序
void SelectSort(int r[ ], int n);                 //简单选择排序
void Sift(int r[], int k, int m);                 //筛选法调整堆
void HeapSort(int r[], int n);                   //堆排序
void Merge(int r[], int r1[], int s, int m, int t);//一次归并
void MergePass(int r[], int r1[], int n, int h); //一趟归并
void MergeSort1(int r[], int r1[], int n );      //归并排序的非递归算法
void MergeSort2(int r[], int r1[], int r2[],int s, int t);//归并排序的递归算法

int main()
{
	const int numv=11;                                //赋值
	int a[]={0,3,56,32,78,5,24,9,64,34,7};
	int b[]={0,4,6,23,45,15,10,36,25,79,21};
	int c[]={38,23,56,2,79,42,93,29,6,5,57};
	int d[]={50,23,45,67,87,14,29,32,44,97,89};
	int e[]={8,6,1,48,37,63,39,74,52,26,49};
	int f[]={12,23,45,87,2,6,15,43,26,40,44};
	int g[]={13,10,23,45,64,34,24,7,9,3,16};
	int h[]={34,23,54,76,12,13,14,11,78,8};
	int g1[numv];
	int h1[numv];
	int h2[numv];  

	cout << "\n直接顺序排序前：" << "\n";
	for(int j=1;j<numv;j++)
		cout<<a[j]<<" ";
	cout << "\n直接顺序排序结果为：" << "\n";
	InsertSort(a,numv);  

	cout << "\n希尔排序前：" << "\n";
	for(int j=1;j<numv;j++)
		cout<<b[j]<<" ";
	cout << "\n希尔排序结果为：" << "\n";
	ShellSort(b, numv);

	cout << "\n起泡排序前：" << "\n";
	for(int k=0;k<numv;k++)
		cout<<c[k]<<" ";
	cout << "\n起泡排序结果为：" << "\n";
	BubbleSort(c, numv);

	cout << "\n快速排序前：" << "\n";
	for(int j=0;j<numv;j++)
		cout<<d[j]<<" ";
	cout << "\n快速排序结果为：" << "\n";
	QuickSort(d,0,numv-1);  
	for(int i=0;i<numv;i++)
		cout<<d[i]<<" ";
	cout<<"\n";

	cout << "\n简单选择排序前：" << "\n";
	for(int j=0;j<numv;j++)
		cout<<e[j]<<" ";
	cout << "\n简单选择排序结果为：" << "\n";
	SelectSort(e,numv);

	cout << "\n堆排序前：" << "\n";
	for(int j=0;j<numv;j++)
		cout<<f[j]<<" ";
	cout << "\n堆排序结果为：" << "\n";
	HeapSort(f, numv);

	cout << "\n归并排序非递归算法前：" << "\n";
	for(int j=0;j<numv;j++)
		cout<<g[j]<<" ";
	cout << "\n归并排序非递归算法的结果为：" << "\n";
	MergeSort1(g, g1,numv );

	cout << "\n归并排序递归算法前：" << "\n";
	for(int j=0;j<numv;j++)
		cout<<h[j]<<" ";
	cout << "\n归并排序递归算法的结果为：" << "\n";
	MergeSort2(h,h1,h2, 0, numv-1);
	for(int i=0; i < numv; i++)
		cout<<h1[i]<<" ";
	cout<<"\n";

	return 0;
}