各种排序效率比较程序冒泡，选择，插入，快速，堆，归并，基数，希尔

#include “iostream.h“
#include “stdio.h“
#include “stdlib.h“
#include “time.h“

/*******************************************************************************
	冒泡排序
*******************************************************************************/
long Bubblesort（long R[] long n）
{
	int flag=1;						//当flag为0则停止排序
	long BC=0;
	for（long i=1;i	{								//i表示趟数最多n-1趟
		flag=0;						//开始时元素未交换
		for（long j=n-1;j>=i;j--）
		{
			if（R[j]			{
				long t=R[j];
				R[j]=R[j-1];
				R[j-1]=t;flag=1;   //交换并标记发生了交换
			}
			BC++;
		}
	}
		return BC;
}


/*******************************************************************************
	选择排序
*******************************************************************************/
long selectsort（long R[] long n）
{
	long ijm;long tSC=0;
	for（i=0;i	{
		m=i;
		for（j=i+1;j		{
			SC++;
			if（R[j]			if（m!=i）
			{    
				t=R[i];
				R[i]=R[m];
				R[m]=t;   
			}
		}
	}
	return SC;
}


/*******************************************************************************
	直接插入排序
*******************************************************************************/
long insertsort（long R[] long n）
{
	long IC=0;
	for（long i=1;i	{
		long temp=R[i];				//把待排序元素赋给temp
		long j=i-1;
		while（（j>=0）&&（temp		{
			R[j+1]=R[j];j--;		//顺序比较和移动
			IC++;
		}
		IC++;
		R[j+1]=temp;
	}
	return IC;
}

/*******************************************************************************
	希尔排序
*******************************************************************************/
long ShellSort（long R[] int n）
{
	int tempSC=0;
	for（int i = n / 2; i > 0; i /= 2）					//将所有记录分成增量为t的子序列
	{
		for（int j = 0; j < i; j ++）						//对每个子序列进行插入排序
			for（int k = j + i; k < n; k += i）			//依次将记录插入有序子序列中
				for（int p = j; p < k; p += i）			//循环查找要插入的位置
					if （R[k] < R[p]） {
						temp = R[k];
						for（int q = k; q > p; q -= i）{	//插入位置以后的记录依次后移
							R[q] = R[q - i];
							SC++;
						}
						R[p] = temp;					//插入记录
						break;
					}
	}
	return SC;
}

/*******************************************************************************
	快速排序
*******************************************************************************/
long quicksort（long R[] long left long right）
{
	static long QC=0;
	long i=leftj=right;
	long temp=R[i];
	while（i	{
		while（（R[j]>temp）&&（j>i））
		{
			QC++;
			j=j-1;
		}
		if（j>i）
		{
			R[i]=R[j];
			i=i+1;
			QC++;
		}
		while（（R[i]<=temp）&&（j>i））
		{
			QC++;
			i=i+1;
		}
			if（i			{
				R[j]=R[i];
				j=j-1;
				QC++;
			}
	}
									//二次划分得到基准值的正确位置
	R[i]=temp;
	if（left		quicksort（Rlefti-1）;		//递归调用左子区间
	if（i+1		quicksort（Ri+1right）;		//递归调用右子区间
	return QC;
}


/*******************************************************************************
	堆排序
****************************************