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中



}

}

  

你可能感兴趣的:(C++)