八大排序算法的C++实现

#include "stdafx.h"
#include<iostream>
#include<vector>
#include <algorithm>
#include <math.h>
using namespace std;

void print(vector<int> numv)//输出数组
{
int size = numv.size();
if(size == 0)
{
cout<<"null"<<endl;
}
else
{
cout << "数组的顺序是：" << endl;
for(int i = 1;i < size;i++)
{
cout << numv.at(i-1) << " ";
}
cout << numv.at(size-1) << endl << endl;
}
}

vector<int> insertionsort(vector<int> numv)//插入排序
{
int size = numv.size();
for(int i = 1;i < size;i++){
int v = numv.at(i);
int j = i-1;
while((j >= 0)&&(numv.at(j) > v)){
numv.at(j+1)=numv.at(j);
j--;
}
numv.at(j+1)=v;
}
return numv;
}

vector<int> selectionsort(vector<int> numv)//选择排序
{
int size = numv.size();
for(int i = 0;i < size-1;i++){
int min = i;
for(int j = i+1;j < size;j++){
if(numv.at(j) < numv.at(min))
min = j;
}
int a = numv.at(i);
numv.at(i) = numv.at(min);
numv.at(min) = a;
}
return numv;
}

vector<int> bubblesort(vector<int> numv){//冒泡排序
int size = numv.size();
for(int i = 0;i < size-1;i++){
for(int j = 0;j < size-1-i;j++){
if(numv.at(j+1) < numv.at(j)){
int a = numv.at(j);
numv.at(j) = numv.at(j+1);
numv.at(j+1) = a;
}
}
}
return numv;
}

vector<int> merge2(vector<int> nb,vector<int> nc);
vector<int> mergesort(vector<int> numv){//归并排序
int size = numv.size();
if(size <= 1)
return numv;
else
{
vector<int> numb,numc;
for(int i = 0;i <=size/2-1;i++)
{
numb.push_back(numv.at(i));
}
for(int i = size/2;i <=size-1;i++)
{
numc.push_back(numv.at(i));
}
numb = mergesort(numb);
numc = mergesort(numc);
numv = merge2(numb,numc);
return numv;
}
}

vector<int> merge2(vector<int> nb,vector<int> nc)//合并
{
vector<int> na;
int i = 0,j = 0;
while((i <= nb.size()-1)&&(j <= nc.size()-1)){
if(nb.at(i) >= nc.at(j))
{
na.push_back(nc.at(j));
j++;
}
else
{
na.push_back(nb.at(i));
i++;
}
}
if(i == nb.size()){
while(j <= nc.size()-1)
{
na.push_back(nc.at(j));
j++;
}
}
else
{
while(i <= nb.size()-1)
{
na.push_back(nb.at(i));
i++;
}
}
return na;
}

struct pare{
vector<int> numv;
int s;
};
pare partition(vector<int> numv,int i,int j);
vector<int> quicksort(vector<int> numv,int i,int j)//快速排序
{
int size = j-i+1;
if(size <= 1)
{
return numv;
}
else if(size == 2)
{
if(numv.at(i) > numv.at(j))
{
int a = numv.at(i);
numv.at(i) = numv.at(j);
numv.at(j) = a;
}
return numv;
}
else{
pare pr = partition(numv,i,j);
numv = pr.numv;
int s = pr.s;
numv = quicksort(numv,i,s-1);
numv = quicksort(numv,s+1,j);
return numv;
}
}
pare partition(vector<int> numv,int i,int j)//分区
{
int p = numv.at(i);
int l = i;
i++;
while(i < j)
{
while((numv.at(i) <= p)&&(i < j))i++;
while((numv.at(j) >= p)&&(i < j))j--;
if(i>=j)
break;
int a = numv.at(i);
numv.at(i) = numv.at(j);
numv.at(j) = a;
i++;
j--;
}
if(numv.at(i) > p)i--;
int a = numv.at(i);
numv.at(i) = p;
numv.at(l) = a;
pare par;
par.numv = numv;
par.s = i;
return par;
}

vector<int> quicksort(vector<int> numv)
{
int j=numv.size()-1;
return quicksort(numv,0,j);
}

class heap//二叉堆
{
private:
vector<int> h;
void buildheap()
{
for(int i=h.size()-1;i>0;i--)
{
pdown(i);
}
}
void pdown(int x)
{
if(2*x+1<=h.size()-1)
{
if((h.at(x)>h.at(2*x))||(h.at(x)>h.at(2*x+1)))
{
if(h.at(2*x)<h.at(2*x+1))
{
int a=h.at(2*x);
h.at(2*x)=h.at(x);
h.at(x)=a;
pdown(2*x);
}
else
{
int a=h.at(2*x+1);
h.at(2*x+1)=h.at(x);
h.at(x)=a;
pdown(2*x+1);
}
}
}
else if((2*x==h.size()-1)&&(h.at(x)>h.at(2*x)))
{
int a=h.at(2*x);
h.at(2*x)=h.at(x);
h.at(x)=a;
pdown(2*x);
}
}
public:
heap()
{
h.push_back(0);
}
heap(vector<int> nuin)
{
h.push_back(0);
for(int i=0;i<nuin.size();i++)
h.push_back(nuin.at(i));
buildheap();
}
void print()
{
for(int i=1;i<h.size();i++){
cout<<h.at(i)<<" ";
}
cout<<endl;
}
int top()
{
return h.at(1);
}
void deletemin()
{
if(h.size()>1){
h.at(1)=h.back();
h.pop_back();
pdown(1);
}
}
bool isempty()
{
return h.size()<=1;
}
};

vector<int> heapsort(vector<int> numv)
{
heap heap1(numv);
vector<int> num;
while(!heap1.isempty())
{
num.push_back(heap1.top());
heap1.deletemin();
}
return num;
}

vector<int> shell_sort(vector<int> numv)
{
int size = numv.size();
for (int h = size / 2;h > 0;h /= 2)//间隔循环减半
{
for (int k = 0;k < h;k++)
{
for(int i = k + h;i < size;i = i + h)
{
int v = numv.at(i);
int j = i - h;
while((j >= 0)&&(numv.at(j) > v))
{
numv.at(j + h) = numv.at(j);
j = j - h;
}
numv.at(j + h) = v;
}
}
}
return numv;
}

int find_max(vector<int> numv)//找出数组中最大的数
{
int max = numv.at(0);
for (int i = 1;i < numv.size();i++)
{
if (max < numv.at(i))
{
max = numv.at(i);
}
}
return max;
}

int digit_num(int num)
{
int digit = 0;
do
{
num /= 10;
digit++;
} while (num != 0);
return digit;
}

int Kth_digit(int number,int Kth)
{
for (int i = 0;i < Kth;i++)
{
number /= 10;
}
number = number % 10;
return number;
}

vector<int> radix_sort(vector<int> numv)//基数排序
//基数排序参考了《C和C++程序员面试秘笈》人民邮电出版社
{
int len = numv.size();
int max = find_max(numv);
int max_digit = digit_num(max);
int count[10] = {0,0,0,0,0,0,0,0,0,0};
int * temp[10];
for (int i = 0;i < 10;i++)
{
temp[i] = new int[len];
memset(temp[i],0,sizeof(int) * len);
}
for (int i = 0;i < max_digit;i++)
{
memset(count,0,sizeof(int) * 10);
for (int j = 0;j < len;j++)
{
int xx = Kth_digit(numv[j],i);
temp[xx][count[xx]] = numv[j];
count[xx]++;
}
int index = 0;
for (int j = 0;j < 10;j++)
{
for (int k = 0;k < count[j];k++)
{
numv[index] = temp[j][k];
index++;
}
}
}
return numv;
}

int _tmain(int argc, _TCHAR* argv[])
{
int n = 100;
vector<int> number;
for(int i = 1;i <= n;i++)
{
number.push_back(i);
}
random_shuffle(number.begin(),number.end());//生成乱序的1到n的数
vector<int> number1;
print(number);
cout << "插入排序" << endl;
number1 = insertionsort(number);
print(number1);

cout << "选择排序" << endl;
number1 = selectionsort(number);
print(number1);

cout << "冒泡排序" << endl;
number1 = bubblesort(number);
print(number1);

cout << "归并排序" << endl;
number1 = mergesort(number);
print(number1);

cout << "快速排序" << endl;
number1 = quicksort(number);
print(number1);

cout << "堆排序" << endl;
number1 = heapsort(number);
print(number1);

cout << "希尔排序" << endl;
number1=shell_sort(number);
print(number1);

cout << "基数排序" << endl;
number1=radix_sort(number);
print(number1);
return 0;
}