内部排序选择、冒泡、插入、希尔、快速、归并、堆排序原理概要和实现

目录

 

一、选择排序

二、冒泡排序

三、插入排序

四、希尔排序

五、快速排序

六、归并排序

七、堆排序

八、代码和调用

 

一、选择排序

     在线性表中,分为排好序的前一部分V和还未排好序U的后一部分,刚开始整个线性表都是未排好序的。选择排序就是在未排好序U集合的部分每次选择最小值换到最前面。然后纳入集合V。

二、冒泡排序

    冒泡排序,每次排序比较连续两个相邻的元素,小的交换到前面,大的交换交换到后面,达到每次排序小元素“浮"数组前面或大元素"沉"到数组后面的过程。

三、插入排序

     插入排序,分为排好序的前一部分V和还未排好序U的后一部分。从 i=1 开始和 第0个元素比较,如果已经排号序的集合中要比 被比较元素 大,那么往后挪一个位置,最后把被比较元素放在率先比自己小的元素之后。

四、希尔排序

     即带有步长的插入排序。最后一次排序的步长必然是1.加入设 步长集合分别为{4,3,1}.代码 原始线性表中每相互间隔为4的元素进行插入排序一次.之后,原始线性表中每相互间隔为3的元素进行插入排序一次,最后原始线性表中每相互间隔为1的元素进行插入排序一次。一般插入排序实际上也就是步长为1的希尔排序。由于插入排序在顺序集合中的时间复杂度能达到 O(n).所以希尔排序就是尽可能的让子集合进行顺序排好序。如果步长集合设置的合适步长 希尔排序的时间复杂度可以降低为 O(n(log n)^2 )。

五、快速排序

    快速排序,每次排序把待排序元素放入到它的最终位置,并且,它的右侧有比它大,左侧都比它小的目的。

具体操作步骤就是 确定好待比较元素后,如果遍历从后往前开始,那么当遍历到元素比待比较元素小时进行交换,接着从交换位置开始从前往后遍历。如果此时遍历到元素比待比较元素大时,进行交换.反复遍历,最后确认好自身位置。

第二次排序时,只要对上一次确定好位置的元素,左边集合和右边集合分别进行快排就行。

六、归并排序

    把刚开始元素各自立为一个集合,每个集合都可以已经排好序的集合。接着集合两两合并,通过比较两个集合中的"头"元素,把小的元素移值新合并到新的空间中成为一个新的集合。不断合并最后合并成一个大集合。

七、堆排序

   构建从小到大排序的线性表,需要构建一个"大顶堆",实际上就是每个父节点都要比子节点大的完全二叉树。对于线性表[0...length] ,按层次映射到完全二叉树中,第n个元素的左孩子2n+1个元素,右孩子第2n+2个元素。

调整成”大顶"步骤如下,两个孩子选出大的孩子,然后和父节点比较如果子节点和父节点大,那么交换。接着和孩子比较,直到比较到叶子节点。在完全二叉树[0....length]中,最后一个非叶子节点的位置是,floor(heaplen/2)-1 。

操作步骤如下。

首先把乱序数组调成大顶堆。从  floor(heaplen/2)-1  到 0 进行调整。

当调整成大顶堆时,堆顶元素和最后一个元素进行交换,把推顶大元素弄到数组后边去。然后调整推顶节点即可。

八、代码和调用

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;

}







输出结果

猜你喜欢

转载自blog.csdn.net/superSmart_Dong/article/details/109711636
今日推荐