// data_sort_alg.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "sort_alg.h"
#include <iostream>
#include <vector>
void show(std::vector<int> &a)
{
std::vector<int>::iterator it=a.begin();
while(it!=a.end())
{
std::cout<<*it<<" ";
++it;
}
std::cout<<std::endl;
return;
}
int main(void)
{
int a[11]={1,-4,43,12,0,6,78,32,23,10,8};
int b[12]={0,1,-4,43,12,0,6,78,32,23,10,8};
int c[11]={9,3,45,43,95,92,90,72,32,30,66};
int d[11]={9,34,79,23,345,78,120,4578,547,89,500};
std::vector<int> src(a,a+11);
std::vector<int> src1(b,b+12); //heap sort
std::vector<int> src2(c,c+11); //bucket sort
std::vector<int> src3(d,d+11); // radix sort
std::cout<<"The original data order is:"<<std::endl;
show(src3);
radix_sort(src3);
std::cout<<"The sorting result is:"<<std::endl;
show(src3);
system("pause");
return 0;
}#ifndef SORT_ALG_H #define SORT_ALG_H #include <vector> void bubble_sort(std::vector<int> &a); void shell_sort(std::vector<int> &a); void simple_sort(std::vector<int> &a); void merge_sort(std::vector<int> &s,int b,int e); void insert_sort(std::vector<int>& a); void heap_sort(std::vector<int> &a); void fast_sort(std::vector<int> &a,int start,int end); void bucket_sort(std::vector<int> &a); void radix_sort(std::vector<int> &a); #endif
#include "stdafx.h"
#include <vector>
#include<algorithm>
#define STEP 5
/*==============================
1 name:bubble sort
--------------------------------
time complexity:
worst average best
O(n^2) O(n^2) O(n)
--------------------------------
space complexity:
O(1)
--------------------------------
stability:
stable
==============================*/
void bubble_sort(std::vector<int> &a)
{
for(int i=a.size()-1;i>0;i--)
{
for(int j=0;j<i;j++)
{
if(a[j]>a[j+1])
{
std::swap(a[j],a[j+1]);
}
}
}
return;
}
/*==============================
2 name:shell sort
--------------------------------
time complexity:
worst average best
O(ns) O(nlogn) O(n)
1<s<2
--------------------------------
space complexity:
O(1)
--------------------------------
stability:
unstable
==============================*/
void shell_sort_assist(std::vector<int> &a,int d)
{
int i=d;
while(i<a.size())
{
int j=0;
while(j<i)
{
if(a[i]<a[j])
{
int temp=a[i];
int k=i;
while(k-d>=j)
{
a[k]=a[k-d];
k=k-d;
}
a[j]=temp;
break;
}
j=j+d;
}
i=i+d;
}
return;
}
void shell_sort(std::vector<int> &a)
{
int d=STEP;
while(d!=0)
{
shell_sort_assist(a,d);
d/=2;
}
return;
}
/*==============================
3 name:simple sort
--------------------------------
time complexity:
worst average best
O(n^2) O(n^2) O(n^2)
--------------------------------
space complexity:
O(1)
--------------------------------
stability:
unstable
==============================*/
void simple_sort(std::vector<int> &a)
{
std::vector<int>::iterator it=a.begin(),it1,saveit;
for(;it!=a.end();it++)
{
int min=*it;
saveit=it;
it1=it;
while(it1!=a.end())
{
if(min>*it1)
{
min=*it1;
saveit=it1;
}
it1++;
}
if(saveit!=it)
{
std::swap(*it,*saveit);
}
}
return;
}
/*==============================
4 name: merge sort
--------------------------------
time complexity:
worst average best
O(nlogn) O(nlogn) O(nlogn)
--------------------------------
space complexity:
O(n)
--------------------------------
stability:
stable
==============================*/
void merge(std::vector<int> &s,int b,int m,int e)
{
int* temp=new int[e-b+1];
int i=b;
int j=m+1;
int k=0;
while(i<m+1 && j<e+1)
{
if(s[i]>s[j])
{
temp[k++]=s[j++];
}
else
{
temp[k++]=s[i++];
}
}
if(i<m+1)
{
while(i<m+1)
{
temp[k++]=s[i++];
}
}
if(j<e+1)
{
while(j<e+1)
{
temp[k++]=s[j++];
}
}
for(int m=0;m<e-b+1;m++)
{
s[b+m]=temp[m];
}
delete [] temp;
return;
}
void merge_sort(std::vector<int> &s,int b,int e)
{
int m;
if(e>b)
{
m=(b+e)/2;
merge_sort(s,b,m);
merge_sort(s,m+1,e);
merge(s,b,m,e);
}
return;
}
/*==============================
5 name: insert sort
--------------------------------
time complexity:
worst average best
O(n^2) O(n^2) O(n)
--------------------------------
space complexity:
O(1)
--------------------------------
stability:
stable
==============================*/
void insert_sort(std::vector<int>& a)
{
std::vector<int>::iterator it,it1,it2;
int temp;
it=a.begin();
while(it!=a.end())
{
it1=a.begin();
while(it1!=it)
{
if(*it<*it1)
{
temp=*it;
it2=it;
while(it2!=it1)
{
*it2=*(it2-1);
it2--;
}
*it1=temp;
break;
}
it1++;
}
it++;
}
}
/*==============================
6 name: heap sort
--------------------------------
time complexity:
worst average best
O(nlogn) O(nlogn) O(nlogn)
--------------------------------
space complexity:
O(1)
--------------------------------
stability:
unstable
==============================*/
void heap_adjust(std::vector<int> &a,int i,int end)
{
int lchild=2*i;
int rchild=2*i+1;
int max=i;
if(rchild<end+1)
{
if(a[lchild]>a[max])
{
max=lchild;
}
if(a[rchild]>a[max])
{
max=rchild;
}
if(max!=i)
{
std::swap(a[max],a[i]);
heap_adjust(a,max,end);
}
}
}
void build_heap(std::vector<int> &a)
{
int size=a.size()-1;
for(int i=size/2;i>0;i--)
{
heap_adjust(a,i,size);
}
return;
}
void heap_sort(std::vector<int> &a)
{
build_heap(a);
for(int i=a.size()-1;i>0;i--)
{
std::swap(a[1],a[i]);
heap_adjust(a,1,i-1);
}
}
/*==============================
7 name: fast sort
--------------------------------
time complexity:
worst average best
O(n^2) O(nlogn) O(nlogn)
--------------------------------
space complexity:
O(logn)
--------------------------------
stability:
unstable
==============================*/
void fast_sort(std::vector<int> &a,int start,int end)
{
int med=a[start];
int i=start;
int j=end;
while(j>i)
{
while(a[j]>=med && j>i)
{
j--;
}
a[i]=a[j];
while(a[i]<=med && j>i)
{
i++;
}
a[j]=a[i];
}
a[i]=med;
if(start<i)
{
fast_sort(a,start,i);
}
if(i+1<end)
{
fast_sort(a,i+1,end);
}
return;
}
/*==============================
8 name:bucket sort
--------------------------------
time complexity:
average
O(n+nlogn-nlogm)
--------------------------------
space complexity:
O(n)
--------------------------------
stability:
unstable
==============================*/
//suppose: 0<data[i]<100
//we should design the project function based on the data distribution
void bucket_sort(std::vector<int> &a)
{
std::vector<std::vector<int>> bucket;
bucket.resize(10);
std::vector<int>::iterator it=a.begin();
while(it!=a.end())
{
int idx=*it/10;
bucket[idx].push_back(*it);
it++;
}
std::vector<std::vector<int>>::iterator it1=bucket.begin();
while(it1!=bucket.end())
{
simple_sort(*it1);
it1++;
}
it=a.begin();
it1=bucket.begin();
while(it!=a.end() && it1!=bucket.end())
{
std::vector<int>::iterator tmp_it=(*it1).begin();
while(tmp_it!=(*it1).end())
{
*it=*tmp_it;
tmp_it++;
it++;
}
it1++;
}
}
/*==============================
9 name: radix sort
--------------------------------
time complexity:
average
O(2dn)
--------------------------------
space complexity:
O(n)
--------------------------------
stability:
stable
==============================*/
void refresh_data(std::vector<int> &a, std::vector<std::vector<int>> &sto)
{
std::vector<int>::iterator it,it1;
std::vector<std::vector<int>>::iterator it2;
it=a.begin();
it2=sto.begin();
while(it!=a.end() && it2!=sto.end())
{
it1=(*it2).begin();
while(it1!=(*it2).end())
{
*it=*it1;
it1++;
it++;
}
(*it2).clear();
it2++;
}
return;
}
//suppose:there are no minus number
void radix_sort(std::vector<int> &a)
{
std::vector<std::vector<int>> sto;
sto.resize(10);
int max=0;
std::vector<int>::iterator it=a.begin();
while(it!=a.end())
{
int idx;
if(max<*it)
{
max=*it;
}
idx=(*it)%10;
sto[idx].push_back(*it);
it++;
}
refresh_data(a,sto);
int d=0;
int temp=max;
while(1)
{
if(temp!=0)
{
d++;
}
else
{
break;
}
temp/=10;
}
for(int i=1;i<=d;i++)
{
int div=pow(10.0,i);
it=a.begin();
while(it!=a.end())
{
int idx;
idx=(*it/div)%10;
sto[idx].push_back(*it);
it++;
}
refresh_data(a,sto);
}
return;
}原文：http://blog.csdn.net/cjc211322/article/details/38177159