排序算法的复杂度

#include <iostream> 
#include <fstream> 
#include <algorithm> 
#include <vector> 
#include <ctime> 
#include <stdlib.h>
using namespace std; 
const int MAX = 1000; 
vector<int> orited;//全局原始未排序vector 

void randNum() 
{//产生随机数存于vector 
    ofstream fp("data.txt"); 
    if (fp.fail()) 
    { 
        cout << "open data error " << endl; 
        exit(EXIT_FAILURE); 
    } 
    srand((unsigned)time(NULL)); 
    for (int i=0 ; i<MAX ; i++) 
    { 
        orited.push_back(rand()); //是用vector保存随机数 
        fp << orited[i] << " ";
    } 
    fp.close(); 
} 
/************************************************************************/ 
/* 快速排序 */ 
/************************************************************************/ 
int Partion(vector<int> &v ,int low ,int high) 
{//对vector进行划分，返回枢轴下标 
    int pivotkey; 
    pivotkey = v[low] ; 
    while ( low < high ) 
    {
 while (low < high && v[high] >= pivotkey) 
     high--; 
 v[low] = v[high]; 
 while (low < high && v[low] <= pivotkey) 
     low++; 
 v[high] = v[low]; 
    } 
    v[low] = pivotkey; 
    return low; 
} 
void quickSort(vector<int> &number, int left, int right) 
{//用引用解决传参问题，以下类似 
    if ( left < right ) 
    { 
        int i = Partion(number , left, right) ; 
        quickSort(number, left, i-1); // 对左边进行递归 59. quickSort(number, i+1, right); // 对右边进行递归 
    } 
} 
void quick_sort() 
{//快速排序测试程序 
    double start ,end ; 
    vector<int> v(orited);//直接用全局orited初始化v 
    start = clock() ; 
    quickSort(v,0,MAX-1); 
    end = clock(); 
    cout << "quick sort cost : " << end - start << endl; 
}
/*********************************/
/*冒泡排序*/
/**********************************/
void bubble_sort()
{ 
    int i, j; 
    vector<int> v(orited); 
    double start, end; 

    start = clock(); /*计时函数*/
    for (i = 0; i< MAX; i++) 
    { 
        for (j = i + 1; j< MAX; j++) 
        { 
            if (v[i] > v[j])//最小的往左冒泡 
            { 
                swap(v[i],v[j]); 
            } 
        } 
    } 
    end = clock(); 
    cout << "bubble sort cost : " << end - start << endl; 
}
/****************/
/*插入排序*/
/******************/
void InsertSort(vector<int> &v)
{ //对vector做插入排序
    int j;
    int key;
    for (int i = 1; i <int(v.size()); i++)
    if ( v[i]<v[i-1] )// "<",将v[i]插入有序子表
    {
        key = v[i];
        for (j = i - 1; key < v[j];j--)
            v[j+1] = v[j]; // 记录后移
        v[j+1] = key; // 插入到正确位置
        }
}
void insert_sort(){
double start, end;
vector<int>v(orited);
start = clock();
InsertSort(v);
end = clock();
cout <<"insert sort cost: "<< end - start << endl;
}

/****************/
/*c++sort函数*/
/*********************/
void verctor_sort(){
    double start, end;
    vector<int>v(orited);
    start = clock();
    sort(v.begin(), v.end());
    end = clock();
    cout <<"verctor sort cost"<< end - start << endl;
}
/****************/
/*选择排序*/
/*****************/
void select_sort(){
    int i, j, min;
    vector<int>v(orited);
    double start, end;
    start = clock();
    for (i = 0; i < MAX; i++)
    {
        min = i;
        for (j = i + 1; j < MAX; j++)
        {
            if (v[j] < v[min])
                min = j;

        }
        if (min != i)
            swap(v[i], v[min]);
    }
    end = clock();
    cout <<"select sort cost" <<end - start << endl;
}
/************/
/*归并排序（分治法）*/
/*************/
void Merge(vector<int> &array, int start, int mid, int end) 
{//合并vector的start-mid和mid-end两段 
    int j,k,l; 
    vector<int> temp(array); //引入temp，方便用array作为汇总 
    for( j=mid+1,k=start ; start<=mid&&j<=end ; k++ ) 
    { 
        if ( temp[start] < temp[j] ) 
            array[k] = temp[start++]; 
        else 
            array[k] = temp[j++]; 
    } 
    if( start <= mid ) 
    { 
        for( l=0 ; l <= mid-start ; l++) 
            array[k+l] = temp[start+l]; //将剩余0至min-start的复制到array 
    } 
    if( j <= end ) 
    {
        for (l = 0; l <= end - j; l++) 
            array[k + l] = temp[j + l]; //复制j至end到array 
    } 
} 
void MergeSort( vector<int> &v, int low ,int high ) 
{ 
    if (low < high) 
{ 
        int mid = ( low + high )/2; //平分 
        MergeSort( v , low , mid ); //递归合并低段 
        MergeSort( v , mid+1 , high ); //递归合并高段 
        Merge( v , low , mid , high ) ; //合并排序后两段 
    } 
}
//归并排序的测试函数 
void merge_sort() 
{ 
    vector<int> v( orited ); 
    double start ,end; 
    start = clock(); 
    MergeSort(v,0,MAX-1); 
    end = clock(); 
    cout << "merge sort cost : " << end - start << endl;
}

/************************************************************************/ 
/* 希尔排序 */ 
/************************************************************************/ 
const int SORTCOUNT = 20;//希尔排序的排序次数
const int dlta[SORTCOUNT] = {2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3,2,3};//增量数组 
void ShellInsert(vector<int> &v , int dk) 
{//对v做一趟shell插入排序，增量为dk，不是1；j<=0时，找到插入位置 
    int i,j; 
    for ( i=dk ; i < v.size() ; i++)
    { 
        if (v[i] < v[i-dk]) 
        { 
            int temp = v[i];//暂存 
            for (j=i-dk ; j>0 && temp < v[j] ; j -= dk) 
                v[j+dk] = v[j] ;//记录后移，查找插入位置 
            v[j+dk] = temp; //插入 
        } 
    } 
}

void ShellSort(vector<int> &v, const int dlta[], int t) 
{//希尔排序 
    for (int k=0 ; k < t ; k++) 
        ShellInsert(v,dlta[k]) ;//一趟增量为dlta[k]的插入排序 
} 
void shell_sort() 
{ 
    vector<int> v( orited ); 
    double start ,end; 
    start = clock(); 
    ShellSort(v,dlta,SORTCOUNT); 
    end = clock(); 
    cout << "shell sort cost : " << end - start << endl; 
} 
/************************************************************************/ 
/* 堆排序 */ 
/************************************************************************/ 
void HeapAdjust(vector<int> &v ,int s ,int m)//将堆用数组表示，此处为vector 
{//调整为大顶堆 
    int rc,j; 
    rc = v[s]; 
    for ( j=2*s ; j<= m ; j *= 2 ) 
    {//沿key较大的孩子结点向下筛选 
        if (j<m && v[j] < v[j+1]) 
            j++ ;//j为key较大的记录的下标 
        if ( rc >= v[j] ) 
            break;// rc应插入在位置s上 
        v[s] = v[j] ; 
        s = j; 
    }
    v[s] = rc ; //插入 
} 
void HeapSort(vector<int> &v) 
{ // 对vector进行堆排序 
    int t , i; 
    for( i=v.size()/2 ; i>0 ; i--) // 把v建成大顶堆 
        HeapAdjust( v,i,v.size()-1 ); 
    for( i=v.size()-1 ; i>0 ; i-- ) 
    {//将堆顶记录和当前未经排序子序列[0..i]中最后一个记录相互交换 
        t = v[0]; 
        v[0] = v[i]; 
        v[i] = t ; 
        HeapAdjust(v,0,i-1); // 将v[0..i-1]重新调整为大顶堆 
    }

} 
//堆排序测试函数 
void heap_sort() 
{ 
    vector<int> v( orited ); 
    double start ,end; 
    start = clock(); 
    HeapSort(v); 
    end = clock(); 
    cout << "heap sort cost : " << end - start << endl; 
}

/*main函数输出时间复杂度*/
void main(){
    randNum();

    quick_sort();
    bubble_sort();
    //insert_sort();
    verctor_sort();
    select_sort();
    merge_sort();
    shell_sort();
    heap_sort();

    double t = clock();
    cout << t << endl;

    system("pause");
}