基于排序及性能检测

#define owen

#include

#include

#include

#include

#include

using namespace std;

const int maxn = 100000 + 10;

int n = maxn - 10;

int a[maxn];

int TR2[maxn];

void insertion_sort(int* R, int n){                   // 直接插入排序

    for(int i = 1; i < n; i++){

        int m = R[i],j;

        for(j = i - 1; m < R[j]&&j > 0; --j)

            R[j+1] = R[j];

        R[j+1] = m;

    }

}

void bubble_sort(int* R, int n){                     //冒泡排序

    bool flag;

    while(flag){

        flag = false;

        for(int i = 0; i < n-1; i++){

            if(R[i]>R[i+1]){

                swap(R[i],R[i+1]);

               

                flag = true;

            }

        }

    }

}

void selection_sort(int* R, int n){                   //简单选择

    int m,i;

    for(i = 0; i < n-1; i++){

        m = i;

        for(int j = i+1; j < n; j++){

            if(R[j]

        }

        if(m!=i) swap(R[i],R[m]);

    }

}

int partition1(int R[], int low, int high){     //快速排序

    R[n+1] = R[low];

    while(low

        while(low=R[n+1])

            high--;

        R[low] = R[high];

        while(low<=R[n+1])

            low++;

        R[high] = R[low];

    }

    R[low] = R[n+1];

    return low;

}

void quick_sort(int* R, int low, int high){

    if(low < high - 1){

        int k = partition1(R,low,high);

        quick_sort(R,low,k-1);

        quick_sort(R,k+1,high);

    }

}

void Merge(int* SR, int* TR, int i, int m, int n){ //归并排序

    int j=m+1,k=i;

    while(i<=m&&j<=n){

        if(SR[i]<=SR[j]) TR[k++] = SR[i++];

        else TR[k++] =SR[j++];

    }

    while(i <= m) TR[k++] = SR[i++];

    while(j <= n) TR[k++] = SR[j++];

}

void merge_sort(int* SR, int* TR1, int low, int high){

    if(low == high) TR1[low] = SR[low];

    if(low

        int m = (low + high)/2;

        merge_sort(SR,TR2,low,m);

        merge_sort(SR,TR2,m+1,high);

        Merge(TR2,TR1,low,m,high);

    }

}

void mergearray(int a[], int first, int mid, int last, int temp[])

{

    int i = first, j = mid + 1;

    int m = mid,   n = last;

    int k = 0;

    while (i <= m && j <= n)

    {

        if (a[i] <= a[j])

            temp[k++] = a[i++];

        else

            temp[k++] = a[j++];

    }

    while (i <= m)

        temp[k++] = a[i++];

    while (j <= n)

        temp[k++] = a[j++];

    for (i = 0; i < k; i++)

        a[first + i] = temp[i];

}

void mergesort(int a[], int first, int last, int temp[])

{

    if (first < last)

    {

        int mid = (first + last) / 2;

        mergesort(a, first, mid, temp);     //左边有序

        mergesort(a, mid + 1, last, temp); //右边有序

        mergearray(a, first, mid, last, temp); //再将二个有序数列合并

    }

}

bool MergeSort(int a[], int n)

{

    int *p = new int[n];

    if (p == NULL)

        return false;

    mergesort(a, 0, n - 1, p);

    delete[] p;

    return true;

}

void heap_adjust(int* R, int s, int m){               //堆排序

    int rc = R[s];

    for(int j = 2*s+1; j <= m; j = j*2+1){

        if(j

        if(rc>=R[j]) break;

        //swap(R[s],R[j]);

        R[s] = R[j]; s = j;

    }

    R[s] = rc;

}

void heap_sort(int* R, int n){

    for(int i = (n-1)/2; i>=0; --i)

        heap_adjust(R,i,n);

    for(int i = n;i>0;--i){

        swap(R[0],R[i]);

        heap_adjust(R,0,i-1);

    }

}

void print(){

    for(int i = 0; i < n; i++)

        printf("�",a[i]);

    printf("\n");

}

int main(){

    clock_t start, finish;

    start = clock();

    #ifdef owen

    //freopen("out.txt","w",stdout);

    #endif // owen

    int T;

    //srand(time(NULL));

    //scanf("%d",&T);

    //while(cin>>T){

        for(int i = 0; i

            a[i] = rand();

            printf("�",a[i]);

        }

        printf("\n");

       

        insertion_sort(a,n);

        //bubble_sort(a,n);

        //selection_sort(a,n);

        //quick_sort(a,0,n-1);

        //merge_sort(a,a,0,n-1);

        //heap_sort(a,n-1);

        //mergesort(a,0,n-1,TR2);

        print();

    //}

    finish = clock();

    cout<<"Run time: "<<(double)((finish - start)*1000 / CLOCKS_PER_SEC)<<"MS"<<endl;

    return 0;

}

由于这个是入门基础就不加评论语了仅此！！