直接插入排序基本算法
#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中
}
}