[算法]_[对数组内的数字进行从小到大排序]

#include <stdio.h>
#include <algorithm>
#include <stdlib.h>
#include <iostream>
#include <time.h>
#include <assert.h>
#include <vector>
#include <windows.h>

using namespace std;

void InsertSort(vector<int>& array,size_t length)
{
int key = 0;
for(size_t j=1;j<length;++j)
{
int i = j-1;
key = array[j];
while(i>=0 && array[i] > key)
{
array[i+1] = array[i];
--i;
}
array[i+1] = key;
}
}

bool cmp(int a,int b)
{
return a<b;
}

inline int Partition(int array[],int p,int r)
{
int value = array[p];
int i = p;
int j = r+1;
int temp = 0;
do
{
do
{
++i;
if(i > r)
{
break;
}
}
while(array[i]<value);//1.直到找到比它大的元素索引.

do
{
--j;
}
while(array[j]>value);

if(i < j)
{
temp = array[j];
array[j] = array[i];
array[i] = temp;
}
}while(i < j);
array[p] = array[j];
array[j] = value;
return j;
}

void QuickSort(int array[],int p,int r)
{
if(p<r)
{
int j = Partition(array,p,r);
QuickSort(array,p,j-1);
QuickSort(array,j+1,r);
}
}

inline int PartitionSlow(int array[],int p,int r)
{
int x = array[r];
int i = p -1;
int r1 = r-1;

int temp = 0;
//1.这里始终要把比它小的元素往前移动,是慢的原因
//2.交换元素值是非常耗时的.swap
//3.比它小的尽量原地不动会更好,减少交换次数.
for(int j = p;j <= r1;++j)
{
if(array[j]<x)
{
++i;
temp = array[j];
array[j] = array[i];
array[i] = temp;
}
}
array[r] = array[i+1];
array[i+1] = x;
return i+1;
}

//缺点：对于有序数组，耗时比较长（稳定性不够好）
void QuickSortSlow(int array[],int p,int r)
{
if(p<r)
{
int j = PartitionSlow(array,p,r);
QuickSortSlow(array,p,j-1);
QuickSortSlow(array,j+1,r);
}
}

int main(int argc, char *argv[])
{
printf("Hello, world\n");

//RAND_MAX
srand(time(NULL));
const int kMaxNum = 100000;
vector<int> v1(kMaxNum,0);
for(int i=0;i<kMaxNum;++i)
{
v1[i] = rand()%100;
}
vector<int> v2(v1);
//这个在windows下是毫秒级别.
//1.使用库函数排序.
cout << CLOCKS_PER_SEC << endl;
double time=clock();
sort(v1.begin(),v1.end(),cmp);
double Inteval = clock()-time;
cout << "排序耗时 单位(毫秒): " << Inteval << endl;

//1.验证排序.
int pre = v1[0];
for(int i=0;i<kMaxNum;++i)
{
assert(v1[i] >= pre);
pre = v1[i];
}

//2.使用自己的排序算法.
size_t length = v2.size();
time=clock();
InsertSort(v2,length);
Inteval = clock()-time;
cout << "插入排序耗时 单位(毫秒): " << Inteval << endl;
pre = v1[0];
for(int i=0;i<kMaxNum;++i)
{
assert(v1[i] >= pre);
pre = v1[i];
}

int array[kMaxNum];
for(int i=0;i<kMaxNum;++i)
{
array[i] = rand()%100;
}

//    int array_bug1[] = {4,3,1};
//    int array_bug2[] = {1,3,4};
time=clock();
QuickSort(array,0,kMaxNum-1);
Inteval = clock()-time;
cout << "快速排序优化耗时 单位(毫秒): " << Inteval << endl;

pre = array[0];
for(int i=0;i<kMaxNum;++i)
{
assert(array[i] >= pre);
pre = array[i];
}

for(int i=0;i<kMaxNum;++i)
{
array[i] = rand()%100;
}
time=clock();
QuickSortSlow(array,0,kMaxNum - 1);
Inteval = clock()-time;
cout << "快速排序(算法导论)耗时 单位(毫秒): " << Inteval << endl;

pre = array[0];
for(int i=0;i<kMaxNum;++i)
{
assert(array[i] >= pre);
pre = array[i];
}

return 0;
}

C:\workspace\script-test\test_sort>test_sort
Hello, world
1000
排序耗时 单位(毫秒): 56
插入排序耗时 单位(毫秒): 0
快速排序优化耗时 单位(毫秒): 10
快速排序(算法导论)耗时 单位(毫秒): 161

C:\workspace\script-test\test_sort>test_sort
Hello, world
1000
排序耗时 单位(毫秒): 50
插入排序耗时 单位(毫秒): 26774
快速排序优化耗时 单位(毫秒): 12
快速排序(算法导论)耗时 单位(毫秒): 167

C:\workspace\script-test\test_sort>test_sort
Hello, world
1000
排序耗时 单位(毫秒): 63
插入排序耗时 单位(毫秒): 25666
快速排序优化耗时 单位(毫秒): 10
快速排序(算法导论)耗时 单位(毫秒): 161