数据结构：采用线性顺序表动态存储结构。
InsertSort:
void insertSort(SqList &L)
{ /* 对顺序表L作直接插入排序。算法10.1 */
clock_t start, end;
start = clock();
int i,j;
for(i = 2; i <= L.length;++i)
if LT( *(L.elem+i),*(L.elem+i-1)) /* "<",需将L.r[i]插入有序子表 */
{
*(L.elem) = *(L.elem+i); /* 复制为哨兵 */
for(j=i-1;LT(*(L.elem),*(L.elem+j));--j)
*(L.elem+j+1)=*(L.elem+j); /* 记录后移 */
*(L.elem+j+1)=*(L.elem); /* 插入到正确位置 */
}
end = clock();
cout<<"InsertSort Run time: "<<"/t"<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
}
void bInsertSort(SqList &L)
{ /* 对顺序表L作折半插入排序。算法10.2 */
clock_t start, end;
start = clock();
int i,j,m,low,high;
for(i = 2; i <= L.length; ++i)
{
*(L.elem)=*(L.elem+i); /* 将L.r[i]暂存到L.r[0] */
low=1;
high=i-1;
while(low<=high)
{ /* 在r[low..high]中折半查找有序插入的位置 */
m=(low+high)/2; /* 折半 */
if LT(*(L.elem),*(L.elem+m))
high=m-1; /* 插入点在低半区 */
else
low=m+1; /* 插入点在高半区 */
}
for(j=i-1;j>=high+1;--j)
*(L.elem+j+1)=*(L.elem+j); /* 记录后移 */
*(L.elem+high+1)=*(L.elem); /* 插入 */
}
end = clock();
cout<<"BInsertSort Run time: "<<"/t"<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
}
void p2_InsertSort(SqList &L)
{ /* 2_路插入排序 */
clock_t start, end;
start = clock();
int i,j,first,final;
ElemType **d;
d = (ElemType **)malloc(L.length*sizeof(ElemType)); /* 生成L.length个记录的临时空间 */
d[0]= L.elem+1; /* 设L的第1个记录为d中排好序的记录(在位置[0]) */
first = final = 0; /* first、final分别指示d中排好序的记录的第1个和最后1个记录的位置 */
for(i = 2 ; i <= L.length; ++i)
{ /* 依次将L的第2个～最后1个记录插入d中 */
if(*(L.elem+i) < *d[first])
{ /* 待插记录小于d中最小值，插到d[first]之前(不需移动d数组的元素) */
first = (first-1 + L.length) % L.length; /* 设d为循环向量 */
d[first] = L.elem+i;
}
else if(*(L.elem+i) > *d[final])
{ /* 待插记录大于d中最大值，插到d[final]之后(不需移动d数组的元素) */
final=final+1;
d[final] = L.elem+i;
}
else
{ /* 待插记录大于d中最小值，小于d中最大值，插到d的中间(需要移动d数组的元素) */
j=final++; /* 移动d的尾部元素以便按序插入记录 */
while(*(L.elem+i) < *d[j])
{
d[(j+1)% L.length] = d[j];
j=(j-1+L.length)%L.length;
}
d[j+1]=L.elem+i;
}
}
for(i=1;i<=L.length;i++) /* 把d赋给L.r */
*(L.elem+i) = *d[(i+first-1)%L.length]; /* 线性关系 */
end = clock();
cout<<"P2_InsertSort Run time: "<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
}
void shellInsert(SqList &L,int dk)
{ /* 对顺序表L作一趟希尔插入排序。本算法是和一趟直接插入排序相比， */
/* 作了以下修改： */
/* 1.前后记录位置的增量是dk,而不是1; */
/* 2.L.elem只是暂存单元,不是哨兵。当j<=0时,插入位置已找到。算法10.4 */
int i,j;
for(i = dk+1; i <= L.length; ++i)
if LT(*(L.elem+i),*(L.elem+i-dk))
{ /* 需将L.elem+i插入有序增量子表 */
*L.elem = *(L.elem + i); /* 暂存在L.elem */
for(j = i-dk; j>0&<(*L.elem,*(L.elem+j));j-=dk)
*(L.elem+j+dk) = *(L.elem+j); /* 记录后移，查找插入位置 */
*(L.elem+j+dk) = *L.elem; /* 插入 */
}
}
void shellSort(SqList &L,int dlta[],int t)
{ /* 按增量序列dlta[0..t-1]对顺序表L作希尔排序。算法10.5 */
clock_t start, end;
start = clock();
int k;
for(k=0;k<t;++k)
{
shellInsert(L,dlta[k]); /* 一趟增量为dlta[k]的插入排序 */
}
end = clock();
cout<<"ShellSort Run time: "<<"/t"<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
}
QuickSort:
//QuickSort 快速排序
void bubbleSort(SqList &L)
{ /* 将a中整数序列重新排列成自小至大有序的整数序列(冒泡排序)*/
clock_t start, end;
start = clock();
int i,j;
ElemType t;
bool change;
for(i = L.length-1, change = true; i >= 1 && change;--i)
{
change = false;
for(j = 1; j <= i; ++j)
if(L.elem[j]>L.elem[j+1])
{
t=L.elem[j];
L.elem[j]=L.elem[j+1];
L.elem[j+1]=t;
change=true;
}
}
end = clock();
cout<<"BubbleSort Run time: "<<"/t"<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
}
int partition(SqList &L,int low,int high)
{ /* 交换顺序表L中子表L.r[low..high]的记录，使枢轴记录到位， */
/* 并返回其所在位置，此时在它之前(后)的记录均不大(小)于它。算法10.6(a) */
ElemType t;
ElemType pivotkey;
pivotkey = L.elem[low]; /* 用子表的第一个记录作枢轴记录 */
while(low<high)
{ /* 从表的两端交替地向中间扫描 */
while(low<high&&L.elem[high]>=pivotkey)
--high;
t=L.elem[low]; /* 将比枢轴记录小的记录交换到低端 */
L.elem[low]=L.elem[high];
L.elem[high]=t;
while(low<high&&L.elem[low]<=pivotkey)
++low;
t=L.elem[low]; /* 将比枢轴记录大的记录交换到高端 */
L.elem[low]=L.elem[high];
L.elem[high]=t;
}
return low; /* 返回枢轴所在位置 */
}
void qSort(SqList &L,int low,int high)
{ /* 对顺序表L中的子序列L.r[low..high]作快速排序。算法10.7 */
int pivotloc;
if(low<high)
{ /* 长度大于1 */
pivotloc = partition(L,low,high); /* 将L.r[low..high]一分为二 */
qSort(L,low,pivotloc-1); /* 对低子表递归排序，pivotloc是枢轴位置 */
qSort(L,pivotloc+1,high); /* 对高子表递归排序 */
}
}
void quickSort(SqList &L)
{ /* 对顺序表L作快速排序。算法10.8 */
clock_t start, end;
start = clock();
qSort(L,1,L.length);
end = clock();
cout<<"QuickSort Run time: "<<"/t"<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
}
SelectSort:
// SelectionSort 选择排序
int selectMinKey(SqList &L,int i)
{ /* 返回在L.r[i..L.length]中key最小的记录的序号 */
ElemType min;
int j,k;
k = i; /* 设第i个为最小 */
min = L.elem[i];
for(j = i+1; j <= L.length; j++)
if(L.elem[j] < min) /* 找到更小的 */
{
k = j;
min = L.elem[j];
}
return k;
}
void selectSort(SqList &L)
{ /* 对顺序表L作简单选择排序。算法10.9 */
clock_t start, end;
start = clock();
int i,j;
ElemType t;
for(i = 1; i < L.length; ++i)
{ /* 选择第i小的记录，并交换到位 */
j = selectMinKey(L,i); /* 在L.r[i..L.length]中选择key最小的记录 */
if(i != j)
{ /* 与第i个记录交换 */
t=L.elem[i];
L.elem[i]=L.elem[j];
L.elem[j]=t;
}
}
end = clock();
cout<<"SelectSort Run time: "<<"/t"<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
}
void treeSort(SqList &L)
{ /* 树形选择排序 */
int i,j,j1,k,k1,l,n = L.length;
ElemType *t;
l = (int)ceil(log(n)/log(2))+1; /* 完全二叉树的层数 */
k = (int)pow(2,l)-1; /* l层完全二叉树的结点总数 */
k1 = (int)pow(2,l-1)-1; /* l-1层完全二叉树的结点总数 */
t=(ElemType*)malloc(k*sizeof(ElemType)); /* 二叉树采用顺序存储结构 */
for(i = 1; i <= n; i++) /* 将L.r赋给叶子结点 */
t[k1+i-1]= L.elem[i];
for(i = k1+n; i < k; i++) /* 给多余的叶子的关键字赋无穷大 */
t[i] = INT_MAX;
j1 = k1;
j = k;
while(j1)
{ /* 给非叶子结点赋值 */
for(i=j1;i<j;i+=2)
t[i]<t[i+1]?(t[(i+1)/2-1]=t[i]):(t[(i+1)/2-1]=t[i+1]);
j = j1;
j1 = (j1-1)/2;
}
for(i=0;i<n;i++)
{
L.elem[i+1]=t[0]; /* 将当前最小值赋给L.r[i] */
j1=0;
for(j=1;j<l;j++) /* 沿树根找结点t[0]在叶子中的序号j1 */
t[2*j1+1] == t[j1]?(j1=2*j1+1):(j1=2*j1+2);
t[j1]=INT_MAX;
while(j1)
{
j1=(j1+1)/2-1; /* 序号为j1的结点的双亲结点序号 */
t[2*j1+1]<=t[2*j1+2]?(t[j1]=t[2*j1+1]):(t[j1]=t[2*j1+2]);
}
}
free(t);
}
void heapAdjust(HeapType &H,int s,int m) /* 算法10.10 */
{ /* 已知H.r[s..m]中记录的关键字除H.r[s].key之外均满足堆的定义，本函数 */
/* 调整H.r[s]的关键字,使H.r[s..m]成为一个大顶堆(对其中记录的关键字而言) */
ElemType rc;
int j;
rc = H.elem[s];
for(j = 2*s; j <= m; j *= 2)
{ /* 沿key较大的孩子结点向下筛选 */
if(j < m&<(H.elem[j],H.elem[j+1]))
++j; /* j为key较大的记录的下标 */
if(!LT(rc,H.elem[j]))
break; /* rc应插入在位置s上 */
H.elem[s] = H.elem[j];
s = j;
}
H.elem[s] = rc; /* 插入 */
}
void heapSort(HeapType &H)
{ /* 对顺序表H进行堆排序。算法10.11 */
clock_t start, end;
start = clock();
ElemType t;
int i;
for(i = H.length/2; i > 0; --i) /* 把H.r[1..H.length]建成大顶堆 */
heapAdjust(H,i,H.length);
for(i = H.length; i > 1; --i)
{ /* 将堆顶记录和当前未经排序子序列H.r[1..i]中最后一个记录相互交换 */
t = H.elem[1];
H.elem[1] = H.elem[i];
H.elem[i] = t;
heapAdjust(H,1,i-1); /* 将H.r[1..i-1]重新调整为大顶堆 */
}
end = clock();
cout<<"HeapSort Run time: "<<"/t"<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
}
MergeSort:
//MergingSort 归并排序
void merge(ElemType SR[],ElemType TR[],int i,int m,int n)
{ /* 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] 算法10.12 */
int j,k,l;
for(j = m+1, k = i; i <= m&&j <= n; ++k) /* 将SR中记录由小到大地并入TR */
if LQ(SR[i],SR[j])
TR[k] = SR[i++];
else
TR[k] = SR[j++];
if(i <= m)
for(l = 0; l <= m-i; l++)
TR[k+l] = SR[i+l]; /* 将剩余的SR[i..m]复制到TR */
if(j <= n)
for(l = 0; l <= n-j; l++)
TR[k+l] = SR[j+l]; /* 将剩余的SR[j..n]复制到TR */
}
void mSort(ElemType SR[],ElemType TR1[],int s, int t,long int n)
{ /* 将SR[s..t]归并排序为TR1[s..t]。算法10.13 */
int m;
ElemType *TR2;
TR2 = (ElemType *)malloc(n*sizeof(ElemType));
if(s == t)
TR1[s] = SR[s];
else
{
m = (s+t)/2; /* 将SR[s..t]平分为SR[s..m]和SR[m+1..t] */
mSort(SR,TR2,s,m,n); /* 递归地将SR[s..m]归并为有序的TR2[s..m] */
mSort(SR,TR2,m+1,t,n); /* 递归地将SR[m+1..t]归并为有序的TR2[m+1..t] */
merge(TR2,TR1,s,m,t); /* 将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t] */
}
}
void mergeSort(SqList &L)
{ /* 对顺序表L作归并排序。算法10.14 */
clock_t start, end;
start = clock();
ElemType *TR2;
TR2 = (ElemType *)malloc(L.length*sizeof(ElemType));
mSort(L.elem,L.elem,1,L.length,L.length);
end = clock();
cout<<"MergeSort Run time: "<<"/t"<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
