經典排序演算法實驗複雜性分析
十大經典排序演算法:氣泡排序,插入排序,選擇排序,歸併排序,希爾排序(插入排序的變形),快速排序,堆排序, 計數排序,基數排序,桶排序。
理論上的分析各類演算法的複雜性:
(1)氣泡排序:平均(期望)執行時間:O(n^2);最好(輸入是排好序的陣列)執行時間:O(n^2);最差(輸入是逆序的陣列)執行時間:O(n^2)。一般實際應用中會選擇修改的氣泡排序,這種情況下最好執行時間是O(n^2)。
(2)插入排序:平均(期望)執行時間:O(n^2);最好(輸入是排好序的陣列)執行時間:O(n);最差(輸入是逆序的陣列)執行時間:O(n^2)。在最好的情況每個插入要求常量時間。
(3)選擇排序:平均(期望)執行時間:O(n^2);最好(輸入是排好序的陣列)執行時間:O(n^2);最差(輸入是逆序的陣列)執行時間:O(n^2)。即使是完美的排好序的輸入也要求掃描整個陣列。
(4)歸併排序:平均(期望)執行時間:O(n*log(n));最好(輸入是排好序的陣列)執行時間:O(n*(log(n));最差(輸入是逆序的陣列)執行時間:O(n*(log(n))。使用陣列儲存資料時需要O(n)的儲存空間,使用連結串列時常量的儲存空間。
(5)希爾排序:使用高納德(1973)的增量序列[1, 4, 13, 40, 121...] 最差(輸入是逆序的陣列)執行時間:O(n^1.5)。不穩定排序。
(6)快速排序:平均(期望)執行時間:O(n*log(n));最好(輸入是排好序的陣列)執行時間:O(n*(log(n));最差(輸入是逆序的陣列)執行時間:O(n^2)。
(7)堆 排 序:平均(期望)執行時間:O(n*log(n));最好(輸入是排好序的陣列)執行時間:O(n*(log(n));最差(輸入是逆序的陣列)執行時間:O(n*(log(n));堆排序與待排數的初始位置無關。不穩定排序。
(8)計數排序:平均(期望)執行時間:O(n);最好(輸入是排好序的陣列)執行時間:O(n);最差(輸入是逆序的陣列)執行時間:O(n)。
(9)基數排序:平均(期望)執行時間:O(n);最好(輸入是排好序的陣列)執行時間:O(n);最差(輸入是逆序的陣列)執行時間:O(n)。
(10)桶 排 序:平均(期望)執行時間:O(n);最好(輸入是排好序的陣列)執行時間:O(n);最差(所有待排序的數被雜湊到一個桶中)執行時間:O(n^2)。
使用的兩個測試資料檔案分別是FNRandomNum.txt和SNRandomNum.txt,其大小分別是10000, 30000;最初計劃使用三個資料集10000, 100000, 1000000,其中使用1000000的資料集時對記憶體要求為常量的氣泡排序在win7,32位,4 GB RAM的Core 2主機上無法裝載執行。同時對100000大小的資料集使用歸併排序演算法時記憶體無法裝載,為了使實驗結果更具對比性,第二個使用了30000大小的資料集,以確保所有排序演算法在現有主機上都可以執行。
生成測試 .txt檔案
#include <stdio.h>
#include <stdlib.h>
#define FN 10000
#define TN 30000
#define SN 100000
main()
{
int i, c;
unsigned long x;
FILE *frofp, *srofp, *trofp;
frofp = fopen("FNRandomNum.txt", "w");
srand((unsigned)time(NULL));
for (i = 0; i < FN; i++) {
c = rand();
if (i != 0 && i % 15 == 0)
putc('\n', frofp);
fprintf(frofp, "%10d", c);
}
fclose(frofp);
srofp = fopen("SNRandomNum.txt", "w");
srand((unsigned)time(NULL));
for (i = 0; i < SN; i++) {
c = rand();
c <<= 15;
c ^= rand();
c %= 100001;
if (i != 0 && i % 15 == 0)
putc('\n', srofp);
fprintf(srofp, "%10d", c);
}
fclose(srofp);
trofp = fopen("TNRandomNum.txt", "w");
srand((unsigned)time(NULL));
for (i = 0; i < TN; i++) {
x = rand();
x %= 30001;
if (i != 0 && i % 15 == 0)
putc('\n', trofp);
fprintf(trofp, "%10d", x);
}
fclose(trofp);
return 0;
}
1、氣泡排序bubble sort
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define FN 10000
#define SN 30000
#define NELEMS(x) (sizeof(x) / sizeof(x[0]))
void BubbleSort(int [], int);
void BucketSort(int [], int);
main()
{
int c, i, len, fr[FN], vr[FN],
sfr[SN], svr[SN];
double spent;
FILE *fifp, *sifp, *fofp, *sofp;
clock_t tic, toc;
i = 0;
fifp = fopen("FNRandomNum.txt", "r");
fscanf(fifp, "%d", &c);
while (!feof(fifp)) {
fr[i++] = c;
fscanf(fifp, "%d", &c);
}
fr[i] = c;
fclose(fifp);
i = 0;
sifp = fopen("TNRandomNum.txt", "r");
fscanf(sifp, "%d", &c);
while (!feof(sifp)) {
sfr[i++] = c;
fscanf(sifp, "%d", &c);
}
sfr[i] = c;
fclose(sifp);
tic = clock();
BubbleSort(fr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("BubbleSort:\n");
printf("\t%10d elements average running time: %f seconds\n", FN, spent);
tic = clock();
BubbleSort(fr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", FN, spent);
for (i = 0; i < FN; i++)
vr[i] = fr[FN - 1 - i];
tic = clock();
BubbleSort(vr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
tic = clock();
BubbleSort(sfr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements average running time: %f seconds\n", SN, spent);
tic = clock();
BubbleSort(sfr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", SN, spent);
for (i = 0; i < SN; i++)
svr[i] = sfr[SN - 1 - i];
tic = clock();
BubbleSort(svr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", SN, spent);
return 0;
}
void BubbleSort(int a[], int len)
{
int i, j, temp;
for (i = 0; i < len - 1; i++) {
for (j = len - 1; j > i; j--) {
if (a[j] < a[j-1]) {
temp = a[j];
a[j] = a[j-1];
a[j-1] = temp;
}
}
}
}
2、插入排序 insertion sort
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define FN 10000
#define SN 30000
#define NELEMS(x) (sizeof(x) / sizeof(x[0]))
void InsertionSort(int [], int);
main()
{
int c, i, len, fr[FN], vr[FN],
sfr[SN], svr[SN];
double spent;
FILE *fifp, *sifp, *fofp, *sofp;
clock_t tic, toc;
i = 0;
fifp = fopen("FNRandomNum.txt", "r");
fscanf(fifp, "%d", &c);
while (!feof(fifp)) {
fr[i++] = c;
fscanf(fifp, "%d", &c);
}
fr[i] = c;
fclose(fifp);
i = 0;
sifp = fopen("TNRandomNum.txt", "r");
fscanf(sifp, "%d", &c);
while (!feof(sifp)) {
sfr[i++] = c;
fscanf(sifp, "%d", &c);
}
sfr[i] = c;
fclose(sifp);
tic = clock();
InsertionSort(fr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("InsertionSort:\n");
printf("\t%10d elements average running time: %f seconds\n", FN, spent);
tic = clock();
InsertionSort(fr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", FN, spent);
for (i = 0; i < FN; i++)
vr[i] = fr[FN - 1 - i];
tic = clock();
InsertionSort(vr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
tic = clock();
InsertionSort(sfr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements average running time: %f seconds\n", SN, spent);
tic = clock();
InsertionSort(sfr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", SN, spent);
for (i = 0; i < SN; i++)
svr[i] = sfr[SN - 1 - i];
tic = clock();
InsertionSort(svr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", SN, spent);
return 0;
}
void InsertionSort(int a[], int len)
{
int i, j, key;
for ( j = 1; j < len; j++) {
key = a[j];
i = j - 1;
while (i >= 0 && a[i] > key) {
a[i+1] = a[i];
i = i - 1;
}
a[i+1] = key;
}
}
3、選擇排序 selection sort
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define FN 10000
#define SN 30000
#define NELEMS(x) (sizeof(x) / sizeof(x[0]))
void SelectionSort(int [], int);
main()
{
int c, i, len, fr[FN], vr[FN],
sfr[SN], svr[SN];
double spent;
FILE *fifp, *sifp, *fofp, *sofp;
clock_t tic, toc;
i = 0;
fifp = fopen("FNRandomNum.txt", "r");
fscanf(fifp, "%d", &c);
while (!feof(fifp)) {
fr[i++] = c;
fscanf(fifp, "%d", &c);
}
fr[i] = c;
fclose(fifp);
i = 0;
sifp = fopen("TNRandomNum.txt", "r");
fscanf(sifp, "%d", &c);
while (!feof(sifp)) {
sfr[i++] = c;
fscanf(sifp, "%d", &c);
}
sfr[i] = c;
fclose(sifp);
tic = clock();
SelectionSort(fr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("SelectionSort:\n");
printf("\t%10d elements average running time: %f seconds\n", FN, spent);
tic = clock();
SelectionSort(fr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", FN, spent);
for (i = 0; i < FN; i++)
vr[i] = fr[FN - 1 - i];
tic = clock();
SelectionSort(vr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
tic = clock();
SelectionSort(sfr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements average running time: %f seconds\n", SN, spent);
tic = clock();
SelectionSort(sfr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", SN, spent);
for (i = 0; i < SN; i++)
svr[i] = sfr[SN - 1 - i];
tic = clock();
SelectionSort(svr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", SN, spent);
return 0;
}
void SelectionSort(int a[], int len)
{
int i, j, mi, key, temp;
for (i = 0; i < len - 1; i++) {
mi = a[i];
key = i;
for (j = i + 1; j < len; j++) {
if (a[j] < mi) {
mi = a[j];
key = j;
}
}
temp = a[i];
a[i] = a[key];
a[key] = temp;
}
}
4、歸併排序merge sort
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <time.h>
#define FN 10000
#define SN 30000
#define NELEMS(x) (sizeof(x) / sizeof(x[0]))
void MergeSort(int [], int, int);
void Merge(int [], int, int, int);
main()
{
int c, i, low, fr[FN], vr[FN],
sfr[SN], svr[SN];
double spent;
FILE *fifp, *sifp, *fofp, *sofp;
clock_t tic, toc;
i = 0;
low = 0;
fifp = fopen("FNRandomNum.txt", "r");
fscanf(fifp, "%d", &c);
while (!feof(fifp)) {
fr[i++] = c;
fscanf(fifp, "%d", &c);
}
fr[i] = c;
fclose(fifp);
i = 0;
sifp = fopen("TNRandomNum.txt", "r");
fscanf(sifp, "%d", &c);
while (!feof(sifp)) {
sfr[i++] = c;
fscanf(sifp, "%d", &c);
}
sfr[i] = c;
fclose(sifp);
tic = clock();
MergeSort(fr, low, FN-1);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("MergeSort:\n");
printf("\t%10d elements average running time: %f seconds\n", FN, spent);
tic = clock();
MergeSort(fr, low, FN-1);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", FN, spent);
for (i = 0; i < FN; i++)
vr[i] = fr[FN - 1 - i];
tic = clock();
MergeSort(vr, low, FN-1);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
tic = clock();
MergeSort(sfr, low, SN-1);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements average running time: %f seconds\n", SN, spent);
tic = clock();
MergeSort(sfr, low, SN-1);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", SN, spent);
for (i = 0; i < SN; i++)
svr[i] = sfr[SN - 1 - i];
tic = clock();
MergeSort(svr, low, SN-1);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", SN, spent);
return 0;
}
void MergeSort(int a[], int p, int r)
{
int q;
if (p < r) {
q = (p + r) / 2;
MergeSort(a, p, q);
MergeSort(a, q + 1, r);
Merge(a, p, q, r);
}
}
void Merge(int a[], int p, int q, int r)
{
int n1, n2, i, j, k;
n1 = q - p + 1;
n2 = r - q;
int ri[n1+1], lf[n2+1];
for (i = 0; i < n1; i++)
ri[i] = a[p + i];
for (j = 0; j < n2; j++)
lf[j] = a[q + j + 1];
ri[n1] = INT_MAX;
lf[n2] = INT_MAX;
i = 0;
j = 0;
for (k = p; k <= r; k++) {
if (lf[j] <= ri[i]) {
a[k] = lf[j];
j++;
} else {
a[k] = ri[i];
i++;
}
}
}
5.希爾排序(shell sort)
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define FN 10000
#define SN 30000
#define NELEMS(x) (sizeof(x) / sizeof(x[0]))
void ShellSort(int [], int);
int power(int, int);
main()
{
int c, i, len, fr[FN], vr[FN],
sfr[SN], svr[SN];
double spent;
FILE *fifp, *sifp, *fofp, *sofp;
clock_t tic, toc;
i = 0;
fifp = fopen("FNRandomNum.txt", "r");
fscanf(fifp, "%d", &c);
while (!feof(fifp)) {
fr[i++] = c;
fscanf(fifp, "%d", &c);
}
fr[i] = c;
fclose(fifp);
i = 0;
sifp = fopen("TNRandomNum.txt", "r");
fscanf(sifp, "%d", &c);
while (!feof(sifp)) {
sfr[i++] = c;
fscanf(sifp, "%d", &c);
}
sfr[i] = c;
fclose(sifp);
tic = clock();
ShellSort(fr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("ShellSort:\n");
printf("\t%10d elements average running time: %f seconds\n", FN, spent);
tic = clock();
ShellSort(fr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", FN, spent);
for (i = 0; i < FN; i++)
vr[i] = fr[FN - 1 - i];
tic = clock();
ShellSort(vr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
tic = clock();
ShellSort(sfr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements average running time: %f seconds\n", SN, spent);
tic = clock();
ShellSort(sfr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", SN, spent);
for (i = 0; i < SN; i++)
svr[i] = sfr[SN - 1 - i];
tic = clock();
ShellSort(svr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", SN, spent);
return 0;
}
void ShellSort(int a[], int len)
{
int i, gap, j, k, temp, itv, key;
key = 1;
do {
itv = (power(3, key) - 1) / 2;
key++;
}while (itv < ((float)len) / 3.0f + 0.5f);
key -= 2;
int in[key];
for (i = key; i > 0; i--) {
gap = (power(3, i) - 1) / 2;
for (j = gap; j < len; j++) {
temp = a[j];
for (k = j; j >= gap && a[j] < a[j-gap]; j = j - gap)
a[j] = a[j-gap];
a[j] = temp;
}
}
}
int power(int base, int exp)
{
int i, pro;
pro = 1;
for (i = 0; i < exp; i++)
pro *= base;
return pro;
}
6.快速排序(quick sort)
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define FN 10000
#define SN 30000
#define NELEMS(x) (sizeof(x) / sizeof(x[0]))
void QuickSort(int [], int, int);
int Partion(int [], int, int);
main()
{
int c, i, low, fr[FN], vr[FN],
sfr[SN], svr[SN];
double spent;
FILE *fifp, *sifp, *fofp, *sofp;
clock_t tic, toc;
i = 0;
low = 0;
fifp = fopen("FNRandomNum.txt", "r");
fscanf(fifp, "%d", &c);
while (!feof(fifp)) {
fr[i++] = c;
fscanf(fifp, "%d", &c);
}
fr[i] = c;
fclose(fifp);
i = 0;
sifp = fopen("TNRandomNum.txt", "r");
fscanf(sifp, "%d", &c);
while (!feof(sifp)) {
sfr[i++] = c;
fscanf(sifp, "%d", &c);
}
sfr[i] = c;
fclose(sifp);
tic = clock();
QuickSort(fr, low, FN-1);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("QuickSort:\n");
printf("\t%10d elements average running time: %f seconds\n", FN, spent);
tic = clock();
QuickSort(fr, low, FN-1);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", FN, spent);
for (i = 0; i < FN; i++)
vr[i] = fr[FN - 1 - i];
tic = clock();
QuickSort(vr, low, FN-1);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
tic = clock();
QuickSort(sfr, low, SN-1);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements average running time: %f seconds\n", SN, spent);
tic = clock();
QuickSort(sfr, low, SN-1);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", SN, spent);
for (i = 0; i < SN; i++)
svr[i] = sfr[SN - 1 - i];
tic = clock();
QuickSort(svr, low, SN-1);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", SN, spent);
return 0;
}
void QuickSort(int a[], int p, int r)
{
int q;
if (p < r) {
q = Partion(a, p, r);
QuickSort(a, p, q - 1);
QuickSort(a, q + 1, r);
}
}
int Partion(int a[], int p, int r)
{
int i, j, temp;
i = p - 1;
for (j = p; j < r; j++) {
if (a[j] <= a[r]) {
i++;
temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
temp = a[i+1];
a[i+1] = a[r];
a[r] = temp;
return i+1;
}
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define FN 10000
#define SN 30000
#define NELEMS(x) (sizeof(x) / sizeof(x[0]))
void HeapSort(int[], int);
void BuildMaxHeap(int [], int);
void MaxHeap(int [], int, int);
main()
{
int c, i, len, fr[FN], vr[FN],
sfr[SN], svr[SN];
double spent;
FILE *fifp, *sifp, *fofp, *sofp;
clock_t tic, toc;
i = 0;
fifp = fopen("FNRandomNum.txt", "r");
fscanf(fifp, "%d", &c);
while (!feof(fifp)) {
fr[i++] = c;
fscanf(fifp, "%d", &c);
}
fr[i] = c;
fclose(fifp);
i = 0;
sifp = fopen("TNRandomNum.txt", "r");
fscanf(sifp, "%d", &c);
while (!feof(sifp)) {
sfr[i++] = c;
fscanf(sifp, "%d", &c);
}
sfr[i] = c;
fclose(sifp);
tic = clock();
HeapSort(fr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("HeapSort:\n");
printf("\t%10d elements average running time: %f seconds\n", FN, spent);
tic = clock();
HeapSort(fr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", FN, spent);
for (i = 0; i < FN; i++)
vr[i] = fr[FN - 1 - i];
tic = clock();
HeapSort(vr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
tic = clock();
HeapSort(sfr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements average running time: %f seconds\n", SN, spent);
tic = clock();
HeapSort(sfr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", SN, spent);
for (i = 0; i < SN; i++)
svr[i] = sfr[SN - 1 - i];
tic = clock();
HeapSort(svr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", SN, spent);
return 0;
}
void HeapSort(int a[], int len)
{
int i, temp, si;
si = len;
BuildMaxHeap(a, len);
for (i = len - 1; i > 0; i--) {
temp = a[i];
a[i] = a[0];
a[0] = temp;
si = si - 1;
MaxHeap(a, 0, si);
}
}
void BuildMaxHeap(int a[], int len)
{
int i, si, mid;
si = len;
mid = len / 2 - 1;
for (i = mid; i>=0; i--)
MaxHeap(a, i, si);
}
void MaxHeap(int a[], int i, int si)
{
int lef, rig, largest, temp;
lef = 2 * i + 1;
rig = 2 * i + 2;
if (lef < si && a[lef] > a[i])
largest = lef;
else
largest = i;
if (rig < si && a[rig] > a[largest])
largest = rig;
if (largest != i) {
temp = a[i];
a[i] = a[largest];
a[largest] = temp;
MaxHeap(a, largest, si);
}
}
8.計數排序(count sort)
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define FN 10000
#define SN 30000
#define NELEMS(x) (sizeof(x) / sizeof(x[0]))
void CountSort(int [], int [], int, int);
int maximum(int [], int);
main()
{
int c, i, len, ran,
fr[FN], vr[FN], ofr[FN],
sfr[SN], svr[SN], osr[SN];
double spent;
FILE *fifp, *sifp, *fofp, *sofp;
clock_t tic, toc;
i = 0;
fifp = fopen("FNRandomNum.txt", "r");
fscanf(fifp, "%d", &c);
while (!feof(fifp)) {
fr[i++] = c;
fscanf(fifp, "%d", &c);
}
fr[i] = c;
fclose(fifp);
i = 0;
sifp = fopen("TNRandomNum.txt", "r");
fscanf(sifp, "%d", &c);
while (!feof(sifp)) {
sfr[i++] = c;
fscanf(sifp, "%d", &c);
}
sfr[i] = c;
fclose(sifp);
tic = clock();
CountSort(fr, ofr, FN, maximum(fr, FN));
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("CountSort:\n");
printf("\t%10d elements average running time: %f seconds\n", FN, spent);
tic = clock();
CountSort(ofr, fr, FN, maximum(ofr, FN));
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", FN, spent);
for (i = 0; i < FN; i++)
vr[i] = fr[FN - 1 - i];
tic = clock();
CountSort(vr, ofr, FN, maximum(vr, FN));
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
tic = clock();
CountSort(sfr, osr, SN, maximum(sfr, SN));
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements average running time: %f seconds\n", SN, spent);
tic = clock();
CountSort(osr, sfr, SN, maximum(ofr, SN));
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", SN, spent);
for (i = 0; i < SN; i++)
svr[i] = sfr[SN - 1 - i];
tic = clock();
CountSort(svr, osr, SN, maximum(svr, SN));
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", SN, spent);
return 0;
}
void CountSort(int a[], int b[], int len, int ran)
{
int i, j, k, m;
int c[ran+1];
for (i = 0; i <= ran; i++)
c[i] = 0;
for (j = 0; j < len; j++)
c[a[j]]++;
for (k = 1; k <= ran; k++)
c[k] += c[k-1];
for (m = len - 1; m >= 0; m--) {
b[c[a[m]]-1] = a[m];
c[a[m]]--;
}
}
int maximum(int a[], int len)
{
int i, maxval;
maxval = a[0];
for (i = 1; i < len; i++)
if (maxval < a[i])
maxval = a[i];
return maxval;
}
9.基數排序(radix sort)
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define FN 10000
#define SN 30000
#define NELEMS(x) (sizeof(x) / sizeof(x[0]))
void RadixSort(int [], int [], int, int);
void CountSort(int [], int [], int [], int[], int, int);
main()
{
int c, i, len, sd, fd,
fr[FN], vr[FN], ofr[FN],
sfr[SN], svr[SN], osr[SN];
double spent;
FILE *fifp, *sifp, *fofp, *sofp;
clock_t tic, toc;
i = 0;
sd = fd = 5;
fifp = fopen("FNRandomNum.txt", "r");
fscanf(fifp, "%d", &c);
while (!feof(fifp)) {
fr[i++] = c;
fscanf(fifp, "%d", &c);
}
fr[i] = c;
fclose(fifp);
i = 0;
sifp = fopen("TNRandomNum.txt", "r");
fscanf(sifp, "%d", &c);
while (!feof(sifp)) {
sfr[i++] = c;
fscanf(sifp, "%d", &c);
}
sfr[i] = c;
fclose(sifp);
tic = clock();
RadixSort(fr, ofr, FN, fd);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("RadixSort:\n");
printf("\t%10d elements average running time: %f seconds\n", FN, spent);
tic = clock();
RadixSort(ofr, fr, FN, fd);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", FN, spent);
for (i = 0; i < FN; i++)
vr[i] = fr[FN - 1 - i];
tic = clock();
RadixSort(vr, ofr, FN, fd);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
tic = clock();
RadixSort(sfr, osr, SN, sd);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements average running time: %f seconds\n", SN, spent);
tic = clock();
RadixSort(osr, sfr, SN, sd);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", SN, spent);
for (i = 0; i < SN; i++)
svr[i] = sfr[SN - 1 - i];
tic = clock();
RadixSort(svr, osr, SN, sd);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", SN, spent);
return 0;
}
void RadixSort(int a[], int temp[], int len, int d)
{
int i, j, k, m, ran;
int bb[len], c[len];
ran = 9;
for (i = 0; i < len; i++)
bb[i] = a[i];
for (j = 0; j < d; j++) {
for (k = 0; k < len; k++) {
c[k] = bb[k] % 10;
bb[k] = bb[k] / 10;
}
CountSort(a, c, temp, bb, len, ran);
for (m = 0; m < len; m++)
a[m] = temp[m];
}
}
void CountSort(int a[], int b[], int temp[], int bb[], int len, int ran)
{
int i, j, k, m, n;
int c[ran+1], te[len];
for (i = 0; i <= ran; i++)
c[i] = 0;
for (j = 0; j < len; j++)
c[b[j]]++;
for (k = 1; k <= ran; k++)
c[k] += c[k-1];
for (m = len - 1; m >= 0; m--) {
temp[c[b[m]]-1] = a[m];
te[c[b[m]]-1] = bb[m];
c[b[m]]--;
}
for (n = 0; n < len; n++)
bb[n] = te[n];
}
10.桶排序(bucket sort)
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define FN 10000
#define SN 30000
#define NELEMS(x) (sizeof(x) / sizeof(x[0]))
typedef struct node *link;
struct node
{
int item;
link next;
};
void BucketSort(int [], int);
main()
{
int c, i, len, fr[FN], vr[FN],
sfr[SN], svr[SN];
double spent;
FILE *fifp, *sifp, *fofp, *sofp;
clock_t tic, toc;
i = 0;
fifp = fopen("FNRandomNum.txt", "r");
fscanf(fifp, "%d", &c);
while (!feof(fifp)) {
fr[i++] = c;
fscanf(fifp, "%d", &c);
}
fr[i] = c;
fclose(fifp);
i = 0;
sifp = fopen("TNRandomNum.txt", "r");
fscanf(sifp, "%d", &c);
while (!feof(sifp)) {
sfr[i++] = c;
fscanf(sifp, "%d", &c);
}
sfr[i] = c;
fclose(sifp);
tic = clock();
BucketSort(fr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("BucketSort:\n");
printf("\t%10d elements average running time: %f seconds\n", FN, spent);
tic = clock();
BucketSort(fr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", FN, spent);
for (i = 0; i < FN; i++)
vr[i] = fr[FN - 1 - i];
tic = clock();
BucketSort(vr, FN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
tic = clock();
BucketSort(sfr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements average running time: %f seconds\n", SN, spent);
tic = clock();
BucketSort(sfr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements best running time: %f seconds\n", SN, spent);
for (i = 0; i < SN; i++)
svr[i] = sfr[SN - 1 - i];
tic = clock();
BucketSort(svr, SN);
toc = clock();
spent = (double)(toc - tic) / CLOCKS_PER_SEC;
printf("\t%10d elements worst running time: %f seconds\n", SN, spent);
return 0;
}
link nextSort(link);
int maximum(int [], int);
void BucketSort(int a[], int len)
{
int i, j, pos, maxval;
link buc[len], curr, nlist;
maxval = maximum(a, len);
for (i = 0; i < len; i++)
buc[i] = NULL;
for (i = 0; i < len; i++) {
pos = (int)(a[i] * len / maxval);
curr = (link)malloc(sizeof(*curr));
curr->next = buc[pos];
curr->item = a[i];
buc[pos] = curr;
}
for (i = 0, j = 0; i < len; i++) {
buc[i] = nextSort(buc[i]);
nlist = buc[i];
while(nlist) {
a[j++] = nlist->item;
nlist = nlist->next;
}
}
for (i = 0; i < len; i++) {
link hd;
hd = buc[i];
while (hd) {
link nt;
nt = hd;
hd = hd->next;
free(nt);
}
}
free(buc);
}
link nextSort(link lis)
{
struct node head;
link slis, b, p, tmp;
if (lis == NULL || lis->next == NULL)
return lis;
slis = &head;
slis->next = NULL;
for (p = lis; p != NULL; p = tmp) {
tmp = p->next;
for (b = slis; b->next != NULL; b = b->next)
if (b->next->item > p->item)
break;
p->next = b->next;
b->next = p;
}
return slis->next;
}
int maximum(int a[], int len)
{
int i, maxval;
maxval = a[0];
for (i = 1; i < len; i++)
if (maxval < a[i])
maxval = a[i];
return maxval;
}