C++程序原码

直接插入排序基本算法
#include<iostream.h>
#include<stdlib.h>
#include<time.h>
const int n=100000;
typedef struct{
	int key;
}RedType;

typedef struct{  
RedType  *r;       //r[n+1];
int length;
}SqList;

int random();
void InsertSort(SqList &L);
void main(){  
	
  	SqList L;
	L.r = new RedType[n+1];
	L.length=n;
	for(int i=1;i<=n;i++)	L.r[i].key=random();
	long t1,t2;	
	t1=clock();
   	InsertSort(L);
	t2=clock();
	cout<<" 时间: "<<float(t2-t1)/CLK_TCK<<endl;
	
	
}
int random(){
    	int A=48271;
	int M=2147483646;
	int Q=M/A;
	int R=M%A;
	static int x=1;	int x1;
	x1=A*(x%Q)-R*(x/Q);
	if(x1>=0) x=x1;
	else	x=x1+M;
	return x;
}

void InsertSort(SqList &L)      //直接插入排序__基本算法:
{                              //对顺序表L作直接插入排序。
	for(int i=2;i<=L.length;++i)
	if((L.r[i].key < L.r[i-1].key))	{ //"<",需将L.r[i]插入有序子表
		L.r[0]=L.r[i];       //复制为哨兵
		L.r[i]=L.r[i-1];
	for(int j=i-2;(L.r[0].key<L.r[j].key);--j)
		L.r[j+1]=L.r[j];                    //记录后移				L.r[j+1]=L.r[0];    //插入到正确位置	
	}
}//InsertSort */

改进1 

#include<iostream.h>
#include<stdlib.h>
#include<time.h>
const int n=100000;
typedef struct{
	int key;
}RedType;

typedef struct{  
RedType  *r;       //r[n+1];
int length;
}SqList;

int random();
void InsertSort(SqList &L);
void main(){  
	
  	SqList L;
	L.r = new RedType[n+1];
	L.length=n;
	for(int i=1;i<=n;i++)	L.r[i].key=random();
	long t1,t2;	
	t1=clock();
   	InsertSort(L);
	t2=clock();
	cout<<" 时间: "<<float(t2-t1)/CLK_TCK<<endl;
	
	
}
int random(){
    	int A=48271;
	int M=2147483646;
	int Q=M/A;
	int R=M%A;
	static int x=1;	int x1;
	x1=A*(x%Q)-R*(x/Q);
	if(x1>=0) x=x1;
	else	x=x1+M;
	return x;
}

void InsertSort(SqList &L)                 //直接插入排序少
{
	int low,high,m;
                                         //对顺序表L作折半插入排序。
for(int i=2;i<=L.length;++i)
{
	L.r[0]=L.r[i];                           //将L.r[i]暂存到L.r[0]
	low=1;high=i-1;
	while(low<=high)
	{                      //在r[low..high]中折半查找有序插入的位置
		m=(low+high)/2;                        //折半
		if (L.r[0].key<L.r[m].key)   high=m-1;   //插入点在低半区
		else low=m+1;                          //插入点在高半区
	}//while
	for(int j=i-1;j>=high+1;--j)L.r[j+1]=L.r[j];      //记录后移
	L.r[high+1]=L.r[0];                     //插入
} //for
}//InsertSort


改进2表插入排序



#include<iostream.h>
#include<stdlib.h>
#include<time.h>
const int n=100000;
const int MAXINT=2147483647;

typedef struct{  
int key;       //r[n+1];
int next;
}SLNode;
typedef struct
{
	SLNode *r;
	int length;
}SLinkList;

int random();
void LInsertionSort (SLinkList &SL, int m);
void Arrange(SLinkList &SL);
void main(){  
	
  	SLinkList L;
	L.r = new SLNode[n+1];
	L.length=n;
	for(int i=1;i<=n;i++)
		L.r[i].key=random();
	long t1,t2;	
	t1=clock();
	LInsertionSort(L,n);
   	Arrange(L);
	t2=clock();
	cout<<" 时间: "<<float(t2-t1)/CLK_TCK<<endl;
	
	
}
int random(){
    	int A=48271;
	int M=2147483647;
	int Q=M/A;
	int R=M%A;
	static int x=1;	int x1;
	x1=A*(x%Q)-R*(x/Q);
	if(x1>=0) x=x1;
	else	x=x1+M;
	return x;
}



 void LInsertionSort (SLinkList &SL, int m) 
  {
      // 对记录序列SL[1..n]作表插入排序。 
	  int i,j,k;
      SL.r[0].key = MAXINT ; 
      SL.r[0].next = 1;  SL.r[1].next = 0; 
      for ( i=2; i<=m; ++i ) 
       {   
		  for ( j=0, k = SL.r[0].next; SL.r[k].key <= SL.r[i].key ; j = k, k = SL.r[k].next ); 
           SL.r[j].next = i;  SL.r[i].next = k; 
		} 
		
      // 结点i插入在结点j和结点k之间 
  }// LinsertionSort 


void Arrange(SLinkList &SL){
                                                //根据静态链表SL中各结点的指针值调整记录位置,使得SL中记录按关键字非递减有序顺序排列
int p,q,i;
SLNode temp;
p=SL.r[0].next;                                 //p指示第一个记录的当前位置
for(i=1;i<SL.length;++i){                        //SL.r[1..i-1]中记录已按关键字有序排列,第
                                               //个记录在SL中的当前位置应不小于i
while(p<i) p=SL.r[p].next;                     //找到第i个记录,并用p指示其在SL中的
                                               //当前位置
q=SL.r[p].next;                                //q指示尚未调整的表尾
if(p!=i){
temp=SL.r[p]; SL.r[p]= SL.r[i]; SL.r[i]=temp;  //交换记录,使第i个记录到位
SL.r[i].next=p;                                //指向被移走的记录,使得以后可由while循环找回
}
p=q;                                           //q指示尚未调整的表尾,为找第i+1个记录作准备
}
}                                              //Arrange



                                                冒泡排序          



#include<iostream.h>
 #include<stdlib.h> 
#include<time.h> 

const int n=100000; 

	 int random(); 
	 void bubble(int a[],int l);  

	 void main() 
	 {    
		 int *r=(int *)malloc(sizeof(int)*n); 
		 for(int i=0;i<n;i++) 	
			 r[i]=random(); 	
		 long t1,t2; 
		 t1=clock();    
		 bubble(r,n);
		 t2=clock(); 
		 cout<<" 时间: "<<float(t2-t1)/CLK_TCK<<endl; 
	 }  
	 int random() 
	 {    
		 int A=200314;
		 int M=2003146010; 
		 int Q=M/A; 	
		 int R=M%A; 	
		 static int x=1; 
		 int x1; 
		 x1=A*(x%Q)-R*(x/Q); 
		 if(x1>=0) x=x1; 	
		 else x=x1+M; 
		 return x; 
	 } 

     void bubble(int a[],int l)
	{
		 int i,temp,work;
      for(int pass=1;pass<l;pass++)             //对数组排序       	
	  {work=1;
      for(i=0;i<l-pass;i++)
      if(a[i]>a[i+1])                           //相邻元素比较           		  
	  {temp=a[i];a[i]=a[i+1];a[i+1]=temp;work=0;}
       if(work)break;	 
	  }	 
	 }  






                            										直接选择排序



#include<iostream.h>
#include<stdlib.h>
#include<time.h>
#include<stdio.h>

const int n=100000;
typedef struct{  
int key;       //r[n+1];
int next;
}SLNode;
typedef struct
{
	SLNode *r;
	int length;
}SLinkList;


int random();
void SelectSort(SLinkList &SL ,int m);
void main(){  
  	SLinkList L;
	L.r = new SLNode[n+1];
	L.length=n;
	for(int i=1;i<=n;i++)	L.r[i].key=random();
	long t1,t2;	
	t1=clock();
   	SelectSort(L,n);
	t2=clock();
	cout<<" 时间: "<<float(t2-t1)/CLK_TCK<<endl;
	
	
}
int random(){
    	int A=48271;
	int M=2147483646;
	int Q=M/A;
	int R=M%A;
	static int x=1;	int x1;
	x1=A*(x%Q)-R*(x/Q);
	if(x1>=0) x=x1;
	else	x=x1+M;
	return x;
}


void SelectSort(SLinkList &SL ,int m){                    //直接选择排序
int i,j,k;
for(i=1;i<=m-1;i++){                               //n-1趟排序
k=i;
for(j=i+1;j<=m;j++)                               //在当前无序区中找键值最小的记录R[k]
if ( SL.r[j].key<SL.r[k].key ) k=j;
if (k!=i) { SL.r[0]=SL.r[i];SL.r[i]=SL.r[k];SL.r[k]=SL.r[0]; }            //交换R[i]和R[k],R[0]作辅助量
}
}
                       
                                                                                                


希尔排序


#include<iostream.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#include<stdio.h>

const int n=10000000;

typedef struct{
	int key;
}RedType;

typedef struct{  
RedType  *r;       //r[n+1];
int length;
}SqList;



int random();
void ShellInsert(SqList &SL,int h);
void ShellSort(SqList &SL,int t);
void main(){ 
	int t;
  	SqList L;
	L.r = new RedType[n+1];
	L.length=n;
	for(int i=1;i<=n;i++)	L.r[i].key=random();
	long t1,t2;	
	t1=clock();
   	ShellInsert(L,n);
	t=log10(double(n+1))/log10(double(2));
	ShellSort(L,t);
	t2=clock();
	cout<<" 时间: "<<float(t2-t1)/CLK_TCK<<endl;
	
	
}
int random(){
    	int A=48271;
	int M=2147483646;
	int Q=M/A;
	int R=M%A;
	static int x=1;	int x1;
	x1=A*(x%Q)-R*(x/Q);
	if(x1>=0) x=x1;
	else	x=x1+M;
	return x;
}


void ShellInsert(SqList &SL,int h){    //对顺序表L作一趟希尔排序.本算法是和一趟直接插入排序相比,作了以下修改:
									//1.前后记录位置的增量是h,而不是1;
									//2.r[0]只是暂存单元,不是哨兵.当j<=0时,插入位置已找到.
int i,j;
for(i=h+1;i<=SL.length;i++)               //i为组号
if(SL.r[i].key>=SL.r[i-h].key) {   //R[j]大于有序区最后一个记录,则不需要插入
SL.r[0]=SL.r[i];                      //R[0]保存待插记录,但不是监视哨
for(j=i-h;j>0&&(SL.r[0].key>=SL.r[j].key);j-=h )
SL.r[j+h]=SL.r[j];
SL.r[j+h]=SL.r[0];
}
}


void ShellSort(SqList &SL,int t){     //d[]为增量序列,t为增量序列长度
int i,dlta;
for(i=0;i<t;i++) 
{                       //各趟插入排序
	dlta=pow(2,t-i+1)-1;
    ShellInsert(SL,dlta);
	if(dlta==1)
		break;
}
}



快速排序



#include<iostream.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#include<stdio.h>

const int n=1000000;

typedef struct{
	int key;
}RedType;

typedef struct{  
RedType  *r;       //r[n+1];
int length;
}SqList;



int random();
int partition(SqList &L,int low,int high);
void QSort(SqList &L,int low,int high);
void main(){ 
	
    int t,m;
  	SqList L;
	L.r = new RedType[n+1];
	L.length=n;
	for(int i=1;i<=n;i++)	L.r[i].key=random();
	long t1,t2;	
	t=1;
	m=n;
	t1=clock();
   QSort(L,t,m);
	t2=clock();
	cout<<" 时间: "<<float(t2-t1)/CLK_TCK<<endl;
//	for(i=1;i<=n;i++)
//		cout<<L.r[i].key<<endl;
	
	
}
int random(){
    	int A=48271;
	int M=2147483647;
	int Q=M/A;
	int R=M%A;
	static int x=1;	int x1;
	x1=A*(x%Q)-R*(x/Q);
	if(x1>=0) x=x1;
	else	x=x1+M;
	return x;
}


int partition(SqList &L,int low,int high){
	int pivotkey;
//交换顺序表L中子表r[low..high]的记录,枢轴记录到位,并返回其所在位置,此时在它之前(后)的//记录均不大(小)于它.
L.r[0]=L.r[low];                       //用子表的第一个记录作枢轴记录
pivotkey=L.r[low].key;                 //枢轴记录关键字
while(low<high){                     //从表的两端交替的向中间扫描
while(low<high&&L.r[high].key>=pivotkey) --high;
L.r[low]=L.r[high];             //将枢轴记录小的记录移到低端
while(low<high&&L.r[low].key<=pivotkey) ++low;
L.r[high]=L.r[low];             //将枢轴记录大的记录移到高端
}
L.r[low]=L.r[0];                      //枢轴记录到位
return low;                          //返回枢轴位置
}// partition

void QSort(SqList &L,int low,int high){
	int pivotloc;
 //对顺序表L中的子序列L.r[low..high]做快速排序
if (low<high){                      //长度大于1
pivotloc=partition(L,low,high);       //将L.r[low..high]一分为二
QSort(L,low,pivotloc-1);            //对低子表递归排序,pivotloc是枢轴位置
QSort(L,pivotloc+1,high);          //对高子表递归排序
}
}//QSort	



堆排序


#include<iostream.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#include<stdio.h>

const int n=10000;

typedef struct{
	int key;
}RedType;

typedef struct{  
RedType  *r;       //r[n+1];
int length;
}SqList;



int random();
void HeapSort(SqList &R,int m);
void main(){ 
	
    int t,m;
  	SqList L;
	L.r = new RedType[n+1];
	L.length=n;
	for(int i=1;i<=n;i++)	L.r[i].key=random();
	long t1,t2;	
	t=1;
	m=n;
	t1=clock();
    HeapSort(L,n);
	t2=clock();
	cout<<" 时间: "<<float(t2-t1)/CLK_TCK<<endl;
//	for(i=1;i<=n;i++)
//		cout<<L.r[i].key<<endl;
	
	
}
int random(){
    	int A=48271;
	int M=2147483647;
	int Q=M/A;
	int R=M%A;
	static int x=1;	int x1;
	x1=A*(x%Q)-R*(x/Q);
	if(x1>=0) x=x1;
	else	x=x1+M;
	return x;
}

void Sift(SqList &R,int p,int q)
{
	int j;
	R.r[0]=R.r[p];
	j=2*p;
	while(j<=q)
	{
		if(j<q&&R.r[j].key<R.r[j+1].key)j++;
		if(R.r[0].key>R.r[j].key)break;
		R.r[p]=R.r[j];
		p=j;
		j=2*p;
	}
	R.r[p]=R.r[0];
}

void HeapSort(SqList &R,int m){       //对R[1]到R[n]进行堆排序
int i;
for(i=m/2;i>=1;i--) Sift(R,i,m);     //建初始堆
for(i=m;i>=2;i--){              //进行n-1趟堆排序
R.r[0]=R.r[1];                   //堆顶和当前堆底交换,R[0]作辅助量
R.r[1]=R.r[i];
R.r[i]=R.r[0];
Sift(R,1,i-1);                 //R[1]到R[i-1]重建成新堆
}
}// HeapSort






二路归并排序


#include<iostream.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#include<stdio.h>

const int n=1000000;

typedef struct{
	int key;
}RedType;

typedef struct{  
RedType  *r;       //r[n+1];
int length;
}SqList;


int random();
void Merge(SqList &R,SqList &R1,int low, int mid,int high);
void MergePass(SqList &R,SqList &R1,int m,int len);
void MergeSort(SqList &R,SqList &R1,int m);
void main(){ 
//	int m;
	//m=log10(double(n+1))/log10(double(2));
  	SqList L;
    SqList L1;
	L.r = new RedType[n+1];
	L1.r=new RedType[n+1];
	L.length=n;
	for(int i=1;i<=n;i++)	L.r[i].key=random();
	long t1,t2;	
	t1=clock();
    MergeSort(L,L1,n);
	t2=clock();
	cout<<" 时间: "<<float(t2-t1)/CLK_TCK<<endl;
//	for(i=1;i<=n;i++)
//		cout<<L.r[i].key<<endl;
	
	
}
int random(){
    	int A=48271;
	int M=2147483647;
	int Q=M/A;
	int R=M%A;
	static int x=1;	int x1;
	x1=A*(x%Q)-R*(x/Q);
	if(x1>=0) x=x1;
	else	x=x1+M;
	return x;
}

void Merge(SqList &R,SqList &R1,int low, int mid,int high)
{
		int i,j,k;
		i=low;j=mid+1;k=low;
		 while(i<=mid&&j<=high)
    	 if(R.r[i].key<=R.r[j].key)
			R1.r[k++]=R.r[i++];
			else  R1.r[k++]=R.r[j++];
			while(i<=mid) R1.r[k++]=R.r[i++];
			while(j<=high) R1.r[k++]=R.r[j++];
}

void MergePass(SqList &R,SqList &R1,int m,int len){  //对R做一趟归并,结果在R1中
int i,j;
i=1;                                 //i指第一对子表的起始点
while(i+2*len-1<=m){                  //归并长度为len的两个子表
Merge(R,R1,i,i+len-1,i+2*len-1);
i=i+2*len;                           //指向下一对子表起始点
}
if(i+len-1<m)                        //剩下两个子表,其中一个长度小于len
Merge(R,R1,i,i+len-1,m);
else                               //子表个数为奇数,剩一段
for(j=i;j<=m;j++)                    //将最后一个表复制到R1中
R1.r[j]=R.r[j];
}


void MergeSort(SqList &R,SqList &R1,int h) {        //对R二路归并排序,结果在R中(非递归算法)
int len;
len=1;
while(len<h){
MergePass(R,R1,h,len);len=len*2;         //一趟归并,结果在R1中
MergePass(R1,R,h,len);len=len*2;         //再次归并,结果在R中

}
}