插入排序---时间比较

插入排序的思想

每次循环使得当前位置的排序是正确的
也就是说：插入排序是从后往前进行排序，排序结果就是排序之前的数有序，那么下一次循环把该数放置在正确位置即可，也就是插入在正确位置。

//插入排序---交换
template<typename T>
void InsertionSort_swap(T a[],int n){
    for(int i=1;i<n;i++){ //只考虑一个数，第一个位置自然是有序的
       int j;
       for(j=i;j>0;j--){
           if(a[j]<a[j-1]){
               swap(a[j],a[j-1]);
           }
           else  break;
       }
    }
}

当然也可以把if-else并入for循环

//插入排序---交换
template<typename T>
void InsertionSort_swap(T a[],int n){
    for(int i=1;i<n;i++){ //只考虑一个数，第一个位置自然是有序的
       int j;
       for(j=i;j>0&&a[j]<a[j-1];j--){
          swap(a[j],a[j-1]);
       }
    }
}

 插入排序最大的特点就是可以提前终止循环，这个对于效率来说提高不少

两个文件:sorthelper.h和sortRuntime.cpp

头文件包含了：

• 打印数组

• 生成范围内的随机数组

• 判断排序是否成功

• 打印程序运行时间

#ifndef  SortHelp
#define  SortHelp
#include<iostream>
#include<ctime>//for srand
#include<cassert>//for assert()
using namespace std;
namespace SortHelper{
    //生成带范围的随机数组
    template<typename T>
    T* genRandonArr(int n,int rangel,int ranger){
        T* arr=new T[n];
        assert(rangel <= ranger);
        srand(time(NULL));
        for(int i=0;i<n;i++){
            arr[i]=rand()%(ranger-rangel)+rangel;
        }
        return arr;
    }
    //打印数组
    template<typename T>
    void arr_print(T a[],int n){
        for(int i=0;i<n;i++){
            cout<<a[i]<<",";
        }
        cout<<endl;
    }
    //判断排序是否成功
    template<typename T>
    bool is_sort_success(T a[],int n){
       for(int i=1;i<n;i++){
           if (a[i]<a[i-1]){
               return false;
           }
       }
       return true;
    }
    //打印程序运行时间
    template<typename T>
    void  program_run_time(const string& name,void(*p)(T[],int),T a[],int n){
        clock_t starttime=clock();
        p(a,n);
        clock_t finishtime=clock();
        assert(is_sort_success(a,n));
        cout<<name<<"的运行时间:"<<double(finishtime-starttime)/CLOCKS_PER_SEC<<"s";
    }
}
#endif

主程序包含了：

插入排序，选择排序以及测试用例

#include<iostream>
#include"sortHelper.h"
using namespace std;
//选择排序
template<typename T>
void SelectionSort(T a[],int n){
    for(int i=0;i<n;i++){
        int minIndex=i;
        for(int j=i+1;j<n;j++){
            if(a[minIndex]>a[j]){
                minIndex=j;
            }
        }
        swap(a[i],a[minIndex]);
    }
}
//插入排序---交换
template<typename T>
void InsertionSort_swap(T a[],int n){
    for(int i=1;i<n;i++){ //只考虑一个数，第一个位置自然是有序的
       int j;
       for(j=i;j>0&&a[j]<a[j-1];j--){
          swap(a[j],a[j-1]);
       }
    }
}
int main(){
    int count=200;
    int* arr=SortHelper::genRandonArr<int>(count,0,count);
    InsertionSort_swap(arr,count);
    SortHelper::is_sort_success(arr,count);
    SortHelper::arr_print(arr,count);
    delete[] arr;
    return 0;
}

比较插入排序和选择排序的时间 

首先需要控制变量，也就是生成一个拷贝函数,使得两种排序数据一致---arrcopy()

//数组拷贝函数
    template<typename T>
    T* arr_copy(T a[],int n){
        T* arr=new T[n];
        for(int i=0;i<n;i++){
            arr[i]=a[i];
        }
        return arr;
    }
}

 当然也可以用标准库的copy函数-----第一个参数是头指针位置，第二个参数是尾指针位置

由于编译器的不用，copy使用可能会报错，需要在预编译时：加上提示的No-Warning(等)

//数组拷贝函数
    template<typename T>
    T* arr_copy(T a[],int n){
        T* arr=new T[n];
        copy(a,a+n,arr);
        return arr;
    }

---

程序运行时间比较：

 

 发现虽然插入排序可以终止循环，但是反而选择排序快，这是因为：交换很费时

改进的插入排序 

//插入排序---赋值
template<typename T>
void InsertionSort_fuzhi(T a[],int n){
    for(int i=1;i<n;i++){
        T e=a[i];
        int j;
        for(j=i;j>0&&a[j-1]>e;j--){
            a[j]=a[j-1];
        }
        a[j]=e;
    }
}

注意：

这里采取定义一个比较值，如果进入循环，说明当前位置不对，但是它前面的数有序，故只要后移，循环终止，把该位置的数填入最开始的记录即可。

循环条件-----a[j-1]>e   内层结束后------a[j]=e

比较三种循环时间 

 

 发现优化的插入排序比较快

插入排序特点

由于插入排序可以提前终止循环，所以在近乎有序的情况下，几乎不进入内层循环，效率不亚于一些nlogn的时间复杂度，因为此时自己是O（n）

生成近乎有序的数组

 //生成近乎有序的数组
    template<typename T>
    T* near_order_arr(int n,int swaptime){
        T* arr=new T[n];
        for(int i=0;i<n;i++){
            arr[i]=i;
        }
        for(int j=0;j<swaptime;j++){
            int posx=rand()%n;
            int posy=rand()%n;
            swap(arr[posx],arr[posy]);
        }
        return arr;
    }

思想很简单，顺序生成，然后随机交换几次位置。

注意：rand()%n----随机数不能超出数组位置

---

最后看一下近乎有序的比较：

 

 

---

---

程序核心代码：

#include<iostream>
#include<ctime>//for srand
#include<cassert>//for assert()
using namespace std;
namespace SortHelper{
    //生成带范围的随机数组
    template<typename T>
    T* genRandonArr(int n,int rangel,int ranger){
        T* arr=new T[n];
        assert(rangel <= ranger);
        srand(time(NULL));
        for(int i=0;i<n;i++){
            arr[i]=rand()%(ranger-rangel)+rangel;
        }
        return arr;
    }
    //打印数组
    template<typename T>
    void arr_print(T a[],int n){
        for(int i=0;i<n;i++){
            cout<<a[i]<<",";
        }
        cout<<endl;
    }
    //判断排序是否成功
    template<typename T>
    bool is_sort_success(T a[],int n){
       for(int i=1;i<n;i++){
           if (a[i]<a[i-1]){
               return false;
           }
       }
       return true;
    }
    //打印程序运行时间
    template<typename T>
    void  program_run_time(const string& name,void(*p)(T[],int),T a[],int n){
        clock_t starttime=clock();
        p(a,n);
        clock_t finishtime=clock();
        assert(is_sort_success(a,n));
        cout<<name<<"的运行时间:"<<double(finishtime-starttime)/CLOCKS_PER_SEC<<"s"<<endl;
    }
    //数组拷贝函数
    template<typename T>
    T* arr_copy(T a[],int n){
        T* arr=new T[n];
        copy(a,a+n,arr);
        return arr;
    }
    //生成近乎有序的数组
    template<typename T>
    T* near_order_arr(int n,int swaptime){
        T* arr=new T[n];
        for(int i=0;i<n;i++){
            arr[i]=i;
        }
        for(int j=0;j<swaptime;j++){
            int posx=rand()%n;
            int posy=rand()%n;
            swap(arr[posx],arr[posy]);
        }
        return arr;
    }
}

//选择排序
template<typename T>
void SelectionSort(T a[],int n){
    for(int i=0;i<n;i++){
        int minIndex=i;
        for(int j=i+1;j<n;j++){
            if(a[minIndex]>a[j]){
                minIndex=j;
            }
        }
        swap(a[i],a[minIndex]);
    }
}
//插入排序---交换
template<typename T>
void InsertionSort_swap(T a[],int n){
    for(int i=1;i<n;i++){ //只考虑一个数，第一个位置自然是有序的
       int j;
       for(j=i;j>0&&a[j]<a[j-1];j--){
          swap(a[j],a[j-1]);
       }
    }
}
//插入排序---赋值
template<typename T>
void InsertionSort_fuzhi(T a[],int n){
    for(int i=1;i<n;i++){
        T e=a[i];
        int j;
        for(j=i;j>0&&a[j-1]>e;j--){
            a[j]=a[j-1];
        }
        a[j]=e;
    }
}