经典排序——归并、快排递归与非递归实现与冒泡排序

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <cstdio>
#include <stack>
using namespace std;

void merge(int a[],int b[],int l,int mid,int r){
    int i = l, j = mid + 1;
    int k = 0;
    while(i <= mid && j <= r){
        if(a[i] <= a[j])
            b[k++] = a[i++];
        else
            b[k++] = a[j++];
    }
    while(i <= mid) b[k++] = a[i++];
    while(j <= r) b[k++] = a[j++];
    for(i = 0 ; i < k; i ++)
        a[i+l] = b[i];
}

void mergesort_recursive(int a[],int b[],int l,int r){
    if(l < r){
        int mid = (l + r) >> 1;
        mergesort_recursive(a,b,l,mid);
        mergesort_recursive(a,b,mid+1,r);
        merge(a,b,l,mid,r);
    }
}

void merge2(int a[],int b[],int l,int mid,int r){
    int i = l, j = mid + 1;
    int k = l;
    while(i <= mid && j <= r){
        if(a[i] <= a[j])
            b[k++] = a[i++];
        else
            b[k++] = a[j++];
    }
    while(i <= mid) b[k++] = a[i++];
    while(j <= r) b[k++] = a[j++];
}

void mergepass(int a[],int b[],int s,int n){
    int i = 0;
    while(i <= n - 2*s){
        merge2(a,b,i,i+s-1,i+2*s-1);
        i += 2*s;
    }
    if(i + s < n)
        merge2(a,b,i,i+s-1,n-1);
    else
        for(int j = i ; j < n ; j ++)
            b[j] = a[j];
}

void mergesort_unrecursive(int a[],int n){
    int *b = new int[n];
    int s = 1;
    while(s < n){
        mergepass(a,b,s,n);
        s += s;
        mergepass(b,a,s,n);
        s += s;
    }
   // for(int i = 0 ; i < n ; i ++)
      //  printf("%d ",a[i]);
}

bool MergeSort1(int a[],int n){
    int *b = new int[n];
    if(b == NULL)
        return false;
    mergesort_recursive(a,b,0,n-1);
    //for(int i = 0 ; i < n ; i ++)
      //  printf("%d ",a[i]);
   // puts("");
    delete b;
    return true;
}

void swap(int &a,int &b){
    int temp;
    temp = a;a = b; b = temp;
}

int partition(int a[],int l,int r){
    int m = ((r - l) >> 1) + l;
    swap(a[m],a[r]);
    int x = a[r];
    int i = l - 1;
    for(int j = l ; j < r ; j ++){
        if(a[j] < x){
            i ++;
            swap(a[i],a[j]);
        }
    }
    swap(a[i+1],a[r]);
    return i + 1;
}

void qsort(int a[],int l,int r){
    if(l < r){
        int q = partition(a,l,r);
        qsort(a,l,q-1);
        qsort(a,q+1,r);
    }
}

void qsort_recursive(int a[],int l,int r){
    stack<int> st1;
    stack<int> st2;
    st1.push(l);
    st2.push(r);
    while(!st1.empty() && !st2.empty()){
        int tleft = st1.top();
        int tright = st2.top();
        st1.pop(),st2.pop();
        if(tleft >= tright) continue;
        int q = partition(a,tleft,tright);
        st1.push(tleft);st1.push(q+1);
        st2.push(q-1);st2.push(tright);
    }
}

void bubblesort(int a[],int n){
    bool flag = true;
    int k = n;
    while(flag){
        flag = false;
        for(int j = 1; j < k ; j ++){
            if(a[j - 1] > a[j]){
                swap(a[j-1],a[j]);
                flag = true;
            }
        }
        k --;
    }
}

int random(int n){
    double ran = (double)(rand()/(double)RAND_MAX);
    ran = ran * (n - 1) + 1.0;
    return (int)ran;
}

int main()
{
    srand((int)time(0));
    double ans;
    for(int n = 100 ; n <= 10000000 ; n *=10){
        int *a = new int[n];
        for(int i = 0 ; i < n ; i ++)
            a[i] = random(n*10);

        clock_t start,finish;
        start = clock();
        bool res = MergeSort1(a,n);
        finish = clock();
        ans = (double)(finish - start) / CLOCKS_PER_SEC;
        printf("数据量为%d时:\n",n);
        printf("递归归并排序耗时：%.1fms\n",ans*1000);

        for(int i = 0 ; i < n ; i ++)
            a[i] = random(n*10);
        start = clock();
        mergesort_unrecursive(a,n);
        finish = clock();
        ans = (double)(finish - start) / CLOCKS_PER_SEC;
        printf("非递归归并排序耗时：%.1fms\n",ans*1000);

        for(int i = 0 ; i < n ; i ++)
            a[i] = random(n*10);
        start = clock();
        qsort(a,0,n-1);
        finish = clock();
        ans = (double)(finish - start) / CLOCKS_PER_SEC;
        printf("递归快速排序耗时：%.1fms\n",ans*1000);

        for(int i = 0 ; i < n ; i ++)
            a[i] = random(n*10);
        start = clock();
        qsort_recursive(a,0,n-1);
        finish = clock();
        ans = (double)(finish - start) / CLOCKS_PER_SEC;
        printf("非递归快速排序耗时：%.1fms\n",ans*1000);


        for(int i = 0 ; i < n ; i ++)
            a[i] = random(n*10);
        start = clock();
        //bubblesort(a,n);
        finish = clock();
        ans = (double)(finish - start) / CLOCKS_PER_SEC;
        printf("冒泡排序耗时：%.1fms\n",ans*1000);
        printf("\n");
        delete []a;
    }
    return 0;
}

习惯了递归的实现方法，非递归的很有必要学学。