#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");
}
排序算法的复杂度
最新推荐文章于 2024-03-12 17:47:05 发布