目次
1つは、並べ替えを選択します
線形テーブルでは、ソートされる最初の部分Vとソートされていない後半の部分に分割されます。最初は、線形テーブル全体がソートされていません。選択ソートとは、最小値を選択し、ソートされていないUセットの一部で毎回一番上に変更することです。その後、セットVに含まれます。
2、バブルソート
バブルソートでは、ソートが2つの連続する要素を比較するたびに、小さい要素が前面に交換され、大きい要素が背面に交換されるため、小さい要素が配列の前面または大きい要素を「フロート」します。アレイの後ろに「シンク」します。プロセス。
三、挿入ソート
挿入ソートは、ソートされる前者の部分Vと、まだソートされていない後者の部分Uに分けられます。i = 1から始めて、0番目の要素と比較します。並べ替えられたセットが比較対象の要素よりも大きい場合は、1つ後ろに移動し、最後に、比較対象の要素をそれ自体よりも小さい要素の後に配置します。
フォー、ヒルソート
つまり、ステップサイズでの挿入ソートです。最後の並べ替えのステップ長は1である必要があります。{4,3,1}に設定されたステップ長を追加します。コードは、元の線形テーブルの要素ごとに1回挿入され、相互間隔4で並べ替えられます。元の線形テーブルの相互間隔3の要素は、1回挿入およびソートされ、最後に、元の線形テーブルの間隔1のすべての要素が1回挿入およびソートされます。一般的な挿入ソートは、実際にはステップ長が1のヒルソートです。順序セットでの挿入ソートの時間計算量はO（n）に達する可能性があるため、ヒルソートはサブセットを可能な限りソートすることです。ステップサイズセットによって適切なステップサイズが設定されている場合、ヒルソートの時間計算量はO（n（log n）^ 2）に減らすことができます。
5、クイックソート
クイックソート。各ソートは、ソートされる要素を最終的な位置に配置します。右側はそれよりも大きく、左側はそれよりも小さくなります。
具体的な操作手順は、比較する要素を決定することです。トラバーサルが後ろから前に開始する場合、要素へのトラバーサルが比較する要素よりも小さい場合、交換が実行され、トラバーサルは前から後ろに位置を交換します。この時点で、要素が比較対象の要素よりも大きいことがトラバースされる場合は、交換します。トラバースを繰り返し、最後にその位置を確認します。
2回目の並べ替えでは、前回位置が決定された要素である限り、左のセットと右のセットがすばやく別々に並べ替えられます。
6、マージソート
初期要素はセットとして設定され、各セットはソートされたセットにすることができます。次に、セットがペアでマージされます.2つのセットの「ヘッド」要素を比較することにより、小さな要素が移動され、新しいスペースにマージされて、新しいセットが形成されます。マージを続け、最終的に大きなコレクションにマージします。
セブン、ヒープソート
小さいものから大きいものへとソートされた線形テーブルを作成するには、「ビッグトップヒープ」を作成する必要があります。これは、実際には、各親ノードが子ノードよりも大きい完全なバイナリツリーです。線形テーブル[0 ... length]の場合、完全な二分木に階層的にマップされます。n番目の要素の左側の子には2n + 1個の要素があり、右側の子は2n +2番目の要素です。
「ビッグトップ」に調整する手順は次のとおりです。2人の子が大きい方を選択し、親ノードと比較します。子ノードと親ノードが大きい場合は、交換します。次に、リーフノードが比較されるまで子と比較します。完全な二分木[0 .... length]では、最後の非リーフノードの位置はfloor（heaplen / 2）-1です。
操作手順は以下のとおりです。
まず、無秩序な配列を大きなトップヒープに調整します。floor（heaplen / 2）-1から0に調整します。
大きな上部パイルに調整する場合、パイルの上部要素が最後の要素と交換され、大きな上部要素が配列の後ろに押し出されます。次に、プッシャーノードを調整します。
8、コードと呼び出し
hpp
//
// Created by Administrator on 2020/11/2.
//
#ifndef SMARTDONGLIB_SORT_H
#define SMARTDONGLIB_SORT_H
#include "const.h"
#include <vector>
//#include<cstring>
#include <iostream>
namespace SmartDongLib{
class Sort{
public:
enum sortMethod {
SelectionSort =1,
BubbleSort ,
InsertionSort,
ShellSort,
QuickSort,
MergingSort=6,
HeapSort
};
template<class _tp,class _RandomAccessIterator , class _Compare>
static void sort(_RandomAccessIterator _first, _RandomAccessIterator _last,
_Compare _comp ,sortMethod method=QuickSort){
switch (method) {
case SelectionSort:
selectionSort(_first,_last,_comp);
break;
case BubbleSort:
bubbleSort(_first,_last,_comp);
break;
case InsertionSort:
insertionSort(_first,_last,_comp);
break;
case ShellSort:
shellSort(_first,_last,_comp);
break;
case QuickSort:
quickSort(_first,_last-1,_comp);
break;
case MergingSort:
mergingSort<_tp>(_first,_last,_comp);
case HeapSort:
heapSort(_first,_last,_comp);
default:
quickSort(_first,_last-1,_comp);
break;
}
}
template<class _tp,class _RandomAccessIterator>
static void sort(_RandomAccessIterator _first, _RandomAccessIterator _last,sortMethod method=QuickSort){
switch (method) {
case SelectionSort:
selectionSort(_first,_last);
break;
case BubbleSort:
bubbleSort(_first,_last);
break;
case InsertionSort:
insertionSort(_first,_last);
break;
case ShellSort:
shellSort(_first,_last);
break;
case QuickSort:
quickSort(_first,_last-1);
break;
case MergingSort:
mergingSort<_tp>(_first,_last);
case HeapSort:
heapSort(_first,_last);
default:
quickSort(_first,_last-1);
break;
}
}
protected:
/**
* <p>堆排序.每次选择最值放到子节点前
* @tparam _RandomAccessIterator 线性表地址类型
* @tparam _Compare 比较函数类型
* @param _first 线性表起始地址
* @param _last 线性表结束地址
* @param _comp 比较函数
*/
template< class _RandomAccessIterator, class _Compare>
static void heapSort(_RandomAccessIterator _first, _RandomAccessIterator _last,
_Compare _comp ){
int heaplen =_last - _first;
//把无序堆建立成有序堆,从最后一个节点的父节点 heaplen -1,堆的一半开始调整
for (int i = heaplen/2 -1 ; i >= 0 ; --i) {
HeapAdjust(_first,i,heaplen-1,_comp);
}
//有序堆,每次调整后堆顶和最后一元素交换。
for (int j = heaplen-1; j >0 ; --j) {
iteratorSwap(_first,_first+j);
HeapAdjust(_first,0,j-1,_comp);
}
}
template< class _RandomAccessIterator >
static void heapSort(_RandomAccessIterator _first, _RandomAccessIterator _last ){
int heaplen =_last - _first;
//把无序堆建立成有序堆,从最后一个节点的父节点 heaplen -1,堆的一半开始调整
for (int i = heaplen/2 -1 ; i >= 0 ; --i) {
HeapAdjust(_first,i,heaplen-1);
}
//有序堆,每次调整后堆顶和最后一元素交换。
for (int j = heaplen-1; j >0 ; --j) {
iteratorSwap(_first,_first+j);
HeapAdjust(_first,0,j-1);
}
}
/**
* <p>归并排序.每次选择最值放到最前面
* @tparam _RandomAccessIterator 线性表地址类型
* @tparam _Compare 比较函数类型
* @param _first 线性表起始地址
* @param _last 线性表结束地址
* @param _comp 比较函数
*/
template<class _tp,class _RandomAccessIterator, class _Compare>
static void mergingSort(_RandomAccessIterator _first, _RandomAccessIterator _last,
_Compare _comp ){
Size len = _last -_first;
_tp temp[len];
Sort::mergeSort(_first,temp,0,len-1,_comp);
}
template<class _tp,class _RandomAccessIterator>
static void mergingSort(_RandomAccessIterator _first, _RandomAccessIterator _last){
Size len = _last -_first;
_tp temp[len];
Sort::mergeSort(_first,temp,0,len-1);
}
/**
* <p>选择排序.每次选择最值放到最前面
* @tparam _RandomAccessIterator 线性表地址类型
* @tparam _Compare 比较函数类型
* @param _first 线性表起始地址
* @param _last 线性表结束地址
* @param _comp 比较函数
*/
template<class _RandomAccessIterator, class _Compare>
static void selectionSort(_RandomAccessIterator _first, _RandomAccessIterator _last,
_Compare _comp ){
for (_RandomAccessIterator iter = _first ; iter < _last ;iter++){
_RandomAccessIterator maxValue = iter;
for (_RandomAccessIterator index= iter; index < _last; ++index) {
if ( _comp (*index,*maxValue) ){
maxValue=index;
}
}
iteratorSwap(maxValue,iter);
}
}
template<class _RandomAccessIterator>
static void selectionSort(_RandomAccessIterator _first, _RandomAccessIterator _last){
for (_RandomAccessIterator iter = _first ; iter < _last ;iter++){
_RandomAccessIterator maxValue = iter;
for (_RandomAccessIterator index= iter; index < _last; ++index) {
if (*index<*maxValue ){
maxValue=index;
}
}
iteratorSwap(maxValue,iter);
}
}
/**
* <p> 冒泡排序。每次双循环把最值交换到最前面
* @tparam _RandomAccessIterator 线性表地址类型
* @tparam _Compare 比较函数类型
* @param _first 线性表起始地址
* @param _last 线性表结束地址
* @param _comp 比较函数
*/
template<class _RandomAccessIterator, class _Compare>
static void bubbleSort(_RandomAccessIterator _first, _RandomAccessIterator _last,
_Compare _comp ){
for (_RandomAccessIterator iter = _last ; iter > _first+1 ;iter--){
for (_RandomAccessIterator index= _first; index < iter -1; ++index) {
if ( _comp (*(index +1),*index) ){
iteratorSwap(index,index +1);
}
}
}
}
template<class _RandomAccessIterator>
static void bubbleSort(_RandomAccessIterator _first, _RandomAccessIterator _last){
for (_RandomAccessIterator iter = _last ; iter > _first+1 ;iter--){
for (_RandomAccessIterator index= _first; index < iter -1; ++index) {
if ( *(index +1)<*index ){
iteratorSwap(index,index +1);
}
}
}
}
/**
* <p> 直接插入排序。每次双循环i次表示前 i-1 个数都已经排好序。
* @tparam _RandomAccessIterator 线性表地址类型
* @tparam _Compare 比较函数类型
* @param _first 线性表起始地址
* @param _last 线性表结束地址
* @param _comp 比较函数
*/
template<class _RandomAccessIterator, class _Compare>
static void insertionSort(_RandomAccessIterator _first, _RandomAccessIterator _last,
_Compare _comp ){
singleShellInsert(_first,_last,_comp,1);
}
template<class _RandomAccessIterator>
static void insertionSort(_RandomAccessIterator _first, _RandomAccessIterator _last){
singleShellInsert(_first,_last,1);
}
/**
* <p> 希尔排序，有步长的插入排序
* @tparam _RandomAccessIterator
* @tparam _Compare
* @param _first
* @param _last
* @param _comp
*/
template<class _RandomAccessIterator, class _Compare>
static void shellSort(_RandomAccessIterator _first, _RandomAccessIterator _last,
_Compare _comp){
Size len =_last-_first;
std::vector<Size> dlta;
// int loopnum =(int)(log10(2*len+1) / log10(3) );
for (int i = (len>>1); i >1; i=(i>>1) ){
dlta.push_back(i);
}
dlta.push_back(1);
for (int j = 0; j < dlta.size(); ++j) {
singleShellInsert(_first,_last,_comp,dlta[j]);
}
}
template<class _RandomAccessIterator>
static void shellSort(_RandomAccessIterator _first, _RandomAccessIterator _last){
Size len =_last-_first;
std::vector<Size> dlta;
// int loopnum =(int)(log10(2*len+1) / log10(3) );
for (int i = (len>>1); i >1; i=(i>>1) ){
dlta.push_back(i);
}
dlta.push_back(1);
for (int j = 0; j < dlta.size(); ++j) {
singleShellInsert(_first,_last,dlta[j]);
}
}
/**
* <p> 快速排序，每一次partitio确定一个元素对应的位置，左右两边序列递归
* @tparam _RandomAccessIterator 线性表地址类型
* @tparam _Compare 比较函数类型
* @param _first 线性表起始地址
* @param _last 线性表结束地址
* @param _comp 比较函数
*/
template<class _RandomAccessIterator, class _Compare>
static void quickSort(_RandomAccessIterator _first, _RandomAccessIterator _last,
_Compare _comp){
if (_first<_last){
_RandomAccessIterator pivotloc = singlePartition(_first,_last,_comp);
quickSort(_first,pivotloc-1,_comp);
quickSort(pivotloc+1,_last,_comp);
}
}
template<class _RandomAccessIterator>
static void quickSort(_RandomAccessIterator _first, _RandomAccessIterator _last){
if (_first<_last){
_RandomAccessIterator pivotloc = singlePartition(_first,_last);
// for (_RandomAccessIterator i = _first; i < _last; ++i) {
// std::cout<< *i <<" ";
// }
// std::cout<<"\n";
quickSort(_first,pivotloc-1 );
quickSort(pivotloc+1,_last );
}
}
template<class _RandomAccessIterator, class _Compare>
static void
mergeSort(_RandomAccessIterator _arr1first, _RandomAccessIterator _arr2first,int s, int t,
_Compare _comp) {
//把arr1[s...t] 并入到 arr2[s...t];
if (s == t) {
*(_arr2first + s) = *(_arr1first + s);
} else{
int m =(s + t )/2;
mergeSort(_arr1first,_arr2first,s,m,_comp);
mergeSort(_arr1first,_arr2first,m+1,t,_comp);
merging(_arr2first,_arr1first,s,m,t,_comp);
// memcpy(_arr2first+s,_arr1first+s,(t-s+1)*sizeof(*_arr2first));
}
}
template<class _RandomAccessIterator>
static void
mergeSort(_RandomAccessIterator _arr1first, _RandomAccessIterator _arr2first,int s, int t) {
//把arr1[s...t] 并入到 arr2[s...t];
if (s == t) {
*(_arr2first + s) = *(_arr1first + s);
} else{
int m =(s + t )/2;
mergeSort(_arr1first,_arr2first,s,m);
mergeSort(_arr1first,_arr2first,m+1,t);
merging(_arr2first,_arr1first,s,m,t);
// memcpy(_arr2first+s,_arr1first+s,(t-s+1)*sizeof(*_arr2first));
}
}
template<class _RandomAccessIterator, class _Compare>
static void singleShellInsert(_RandomAccessIterator _first, _RandomAccessIterator _last,
_Compare _comp,Size dk){
for (_RandomAccessIterator iter = _first+ dk ; iter < _last ;iter++){
auto temp = *iter;
_RandomAccessIterator index = iter -dk;
//假如前面 iter -1 个都已经排好序 ，现在插第 iter 个
// 先把iter的值保存起来 到temp
// 然后从 iter -1 开始 和 temp 开始比较,如果小则 index的值往后移
// 当比较结果为大时结束循环,把 temp 放入到 当前比较位置的后一个
for ( ;index >= _first && _comp(temp , *index); index-=dk) {
*(index +dk) = *(index);
}
*(index +dk) = (temp);
}
}
template<class _RandomAccessIterator >
static void singleShellInsert(_RandomAccessIterator _first, _RandomAccessIterator _last,
Size dk){
for (_RandomAccessIterator iter = _first+ dk ; iter < _last ;iter++){
auto temp = *iter;
_RandomAccessIterator index = iter -dk;
//假如前面 iter -1 个都已经排好序 ，现在插第 iter 个
// 先把iter的值保存起来 到temp
// 然后从 iter -1 开始 和 temp 开始比较,如果小则 index的值往后移
// 当比较结果为大时结束循环,把 temp 放入到 当前比较位置的后一个
for ( ;index >= _first && temp < *index; index-=dk) {
*(index +dk) = *(index);
}
*(index +dk) = (temp);
}
}
private:
template<class _RandomAccessIterator>
static void iteratorSwap(_RandomAccessIterator _elem1, _RandomAccessIterator _elem2){
auto temp = *_elem1;
*_elem1 = *_elem2;
*_elem2 = temp;
}
template<class _RandomAccessIterator, class _Compare>
static _RandomAccessIterator singlePartition(_RandomAccessIterator _first, _RandomAccessIterator _last,
_Compare _comp ){
auto temp = *_first;
while(_first -_last <0){
while (_first<_last && _comp(temp,*_last)){
--_last;
}
*_first=*_last;
while (_first<_last && _comp(*_first,temp)){
++_first;
}
*_last=*_first;
}
*_first=temp;
return _first;
}
/**
* <p> 找到指定位置
* @tparam _RandomAccessIterator
* @param _first 包含起始位置
* @param _last 包含结束位置
* @return
*/
template<class _RandomAccessIterator >
static _RandomAccessIterator singlePartition(_RandomAccessIterator _first, _RandomAccessIterator _last){
auto temp = *_first;
while(_first -_last <0){
while (_first<_last && temp<=*_last){
--_last;
}
*_first=*_last;
while (_first<_last && *_first<=temp){
++_first;
}
*_last=*_first;
}
*_first=temp;
return _first;
}
template<class _RandomAccessIterator, class _Compare>
static void
merging(_RandomAccessIterator _arr1first, _RandomAccessIterator _arr2first, int i, int m, int n,
_Compare _comp) {
//把arr1[i...mid]和arr1[mid+1...n] 并入到 arr2[i .... n];
int j,k; //j属于mid+1...last i属于i...mid k属于 i...last
for (j = m+1 ,k=i; i <=m && j <= n ; ++k) {
if (_comp(*(_arr1first + i) , *(_arr1first + j))){
*(_arr2first + k) = *(_arr1first+ (i++));
} else{
*(_arr2first + k) = *(_arr1first+ (j++));
}
}
if ( i <=m){
// memcpy(_arr2first+k,_arr1first+i,(m-i+1)*sizeof(*_arr2first));
for (;k<=n && i<=m ; k++,i++) {
*(_arr2first + k) = *(_arr1first+ i);
}
}
if ( j <=n){
// memcpy(_arr2first+k,_arr1first+j,(n-j+1)*sizeof(*_arr2first));
for (;k<=n && i<=n ; k++,i++) {
*(_arr2first + k) = *(_arr1first+ i);
}
}
}
template<class _RandomAccessIterator>
static void
merging(_RandomAccessIterator _arr1first, _RandomAccessIterator _arr2first, int i, int m, int n) {
//把arr1[i...mid]和arr1[mid+1...n] 并入到 arr2[i .... n];
int j,k; //j属于mid+1...last i属于i...mid k属于 i...last
for (j = m+1 ,k=i; i <=m && j <= n ; ++k) {
if (*(_arr1first + i) < *(_arr1first + j)){
*(_arr2first + k) = *(_arr1first+ (i++));
} else{
*(_arr2first + k) = *(_arr1first+ (j++));
}
}
if ( i <=m){
// memcpy(_arr2first+k,_arr1first+i,(m-i+1)*sizeof(*_arr2first));
for (;k<=n && i<=m ; k++,i++) {
*(_arr2first + k) = *(_arr1first+ i);
}
}
if ( j <=n){
// memcpy(_arr2first+k,_arr1first+j,(n-j+1)*sizeof(*_arr2first));
for (;k<=n && i<=n ; k++,i++) {
*(_arr2first + k) = *(_arr1first+ i);
}
}
}
/**
* 堆节点"筛选"函数,堆顶自堆底的调整方式
* @tparam _RandomAccessIterator
* @tparam _Compare
* @param _first
* @param _last
* @param _comp
*/
template<class _RandomAccessIterator, class _Compare>
static void HeapAdjust(_RandomAccessIterator _first, int nodeIndex,int heapLenth,
_Compare _comp ){
//从小到大排序用大顶堆,父节点比自身节点大,假如按层(从0开始)排列,那么 第n个节点的左孩子是 2n+1 2n+2
//和自己的孩子进行比较然后交换,接着继续和孩子比较到叶子节点
auto temp = *(_first + nodeIndex);
for (int i = 2*nodeIndex +1; i <=heapLenth ; i =2 *i+1 ) {
if (i < heapLenth && _comp( *(_first+i) , *(_first+i+1)))
++i;
if (!_comp(temp,*(_first + i)))
break;
*(_first + nodeIndex) = *(_first+i);
nodeIndex = i;
}
*(_first+nodeIndex) = temp;
}
/**
* 堆节点"筛选"函数,堆顶自堆底的调整方式
* @tparam _RandomAccessIterator
* @tparam _Compare
* @param _first
* @param _last
* @param _comp
*/
template<class _RandomAccessIterator >
static void HeapAdjust(_RandomAccessIterator _first, int nodeIndex,int heapLenth){
//从小到大排序用大顶堆,父节点比自身节点大,假如按层(从0开始)排列,那么 第n个节点的左孩子是 2n+1 2n+2
//和自己的孩子进行比较然后交换,接着继续和孩子比较到叶子节点
auto temp = *(_first + nodeIndex);
for (int i = 2*nodeIndex +1; i <=heapLenth ; i =2 *i+1 ) {
if (i < heapLenth && *(_first+i)< *(_first+i+1) )
++i;
if (! temp<*(_first + i) )
break;
*(_first + nodeIndex) = *(_first+i);
nodeIndex = i;
}
*(_first+nodeIndex) = temp;
}
};
}
#endif //SMARTDONGLIB_SORT_H
cpp
//
// Created by Administrator on 2020/11/2.
//
#include<iostream>
#include "sdalgorithm/util/sort.h"
#include <ctime>
#include <malloc.h>
#include<algorithm>
using namespace std;
using namespace SmartDongLib;
void print(int a[],int size){
for (int i = 0; i < size; ++i) {
cout<< a[i]<<" ";
}
cout<<endl;
};
class C1{
public:
C1(int a){a_=a;}
int a_;
};
int main(){
const int veclen =100000 ;
int a[veclen] ;
// a.resize(veclen);
// int a[10] ={9,34,24,56,31,24,66,3,45,20};
// Sort::sort(a.begin(),a+veclen,[](int x,int y){return abs(x-30)<=abs(y-30);},SmartDongLib::Sort::QuickSort);
// print(a,10);
unsigned seed = time(0);
srand(seed);
for (int i = 0; i < veclen; ++i) {
a[i]=rand();
}
clock_t startSelectionSort,endSelectionSort;
startSelectionSort = clock();
Sort::sort<int>(a,a+veclen,SmartDongLib::Sort::SelectionSort);
endSelectionSort = clock();
cout<<"1.SelectionSort:"<< (double)(endSelectionSort - startSelectionSort)
<<"\t isSort:"<<std::is_sorted(a,a+veclen)<<endl;
for (int i = 0; i < veclen; ++i) {
a[i]=rand();
}
clock_t startBubbleSort,endBubbleSort;
startBubbleSort = clock();
Sort::sort<int>(a,a+veclen,SmartDongLib::Sort::BubbleSort);
endBubbleSort = clock();
cout<<"2.BubbleSort:"<< (double)(endBubbleSort - startBubbleSort)
<<"\t isSort:"<<std::is_sorted(a,a+veclen)<<endl;;
for (int i = 0; i < veclen; ++i) {
a[i]=rand();
}
clock_t startInsertionSort,endInsertionSort;
startInsertionSort = clock();
Sort::sort<int>(a,a+veclen,SmartDongLib::Sort::InsertionSort);
endInsertionSort = clock();
cout<<"3.InsertionSort:"<< (double)(endInsertionSort - startInsertionSort)
<<"\t isSort:"<<std::is_sorted(a,a+veclen)<<endl;
;
for (int i = 0; i < veclen; ++i) {
a[i]=rand();
}
clock_t startShellSort,endShellSort;
startShellSort = clock();
Sort::sort<int>(a,a+veclen,SmartDongLib::Sort::ShellSort);
endShellSort = clock();
cout<<"4.ShellSort:"<< (double)(endShellSort - startShellSort)
<<"\t isSort:"<<std::is_sorted(a,a+veclen)<<endl;;
for (int i = 0; i < veclen; ++i) {
a[i]=rand();
}
clock_t startQuickSort,endQuickSort;
startQuickSort = clock();
// print(a, veclen);
Sort::sort<int>(a,a+veclen,SmartDongLib::Sort::QuickSort);
// print(a, veclen);
endQuickSort = clock();
cout<<"5.QuickSort:"<< (double)(endQuickSort - startQuickSort)
<<"\t isSort:"<<std::is_sorted(a,a+veclen)<<endl;;
for (int i = 0; i < veclen; ++i) {
a[i]=rand();
}
clock_t startMergingSort,endMergingSort;
startMergingSort = clock();
Sort::sort<int>(a, a+veclen,Sort::MergingSort) ;
endMergingSort = clock();
cout<<"6.MergingSort:"<< (double)(endMergingSort - startMergingSort)
<<"\t isSort:"<<std::is_sorted(a,a+veclen)<<endl;
for (int i = 0; i < veclen; ++i) {
a[i]=rand();
}
// int b[8] = {49,38,65,97,76,13,27,49};
clock_t startHeapSort,endHeapSort;
startHeapSort = clock();
Sort::sort<int>(a, a+veclen,Sort::HeapSort) ;
endHeapSort = clock();
cout<<"7.HeapSort:"<< (double)(endHeapSort - startHeapSort)
<<"\t isSort:"<<std::is_sorted(a,a+veclen)<<endl;
// print(a,veclen);
for (int i = 0; i < veclen; ++i) {
a[i]=rand();
}
clock_t startSTLSort,endSTLSort;
startSTLSort = clock();
std::sort(a, a+veclen) ;
endSTLSort = clock();
cout<<"8.STLSort:"<< (double)(endSTLSort - startSTLSort)
<<"\t isSort:"<<std::is_sorted(a,a+veclen)<<endl;
}
出力結果
