直接插入排序(Straight Insertion Sort)

1. 知识背景与目的
   进行直接插入排序算法练习，使用上篇的数据生成测试。
   插入排序：将待排序的元素插入到已经排序好的有序序列中。
   插入排序常见的有：直接插入排序(straight Insertion Sort)与希尔排序(shell’s Sort)
   直接插入排序：逐个将元素插入带已经排序好的有序序列中。
   归纳法证明：
   第一步：i=1,单个元素，肯定是已经排序好的。
   第二步：i=j,将第j+1位元素（记为K)，插入到前面n个已经排好的序列中。将大于K的元素后移，直到小于K元素被找到，找到将K放在该位置，此时序列已经呈现有序状态，元素个数为j+1;没有找到小于K的元素，则将K放在第一位，亦然成立。
   第三步：i=n,此时参照步骤二，同样可以得到长度为n的有序序列，整个序列，排序完毕。算法证明完毕。
2. 代码
   重新调整了测试类，并增加了日志类，该类用来输出数组。

#ifndef TEST_H
#define TEST_H
#include <iostream>
#include <string>
#include <windows.h>
#include <ctime>
#define NULL 0
namespace Test{
    using namespace std;
    enum ArrayType{
        PositiveArray = 0,//正序数组
        NegativeArray = 1,//逆序数组
        RandomArray = 2//随机序列
    };
    template <typename DataType>
    class LogInfo
    {
    public:
        LogInfo(){};
        //输出状态信息
        void ShowState(string strInfo, int nNum, string strOther){
            cout << strInfo << nNum << strOther;
        };
        void ShowState(string strInfo, int nNum){
            cout << strInfo << nNum;
        };
        void ShowState(string strInfo){
            cout << strInfo;
        };
        void ShowLine(){ cout << endl; };
        //展示数组内容
        void ShowArray(DataType pArray[],int nSize){
            for (int i = 0; i < nSize; i++){
                cout << pArray[i] << " ";
            }
            cout << endl;
        };
    };
    template <typename DataType, int nSize>
    class TestDataCreator
    {
    public:
        TestDataCreator(ArrayType nArrayType = PositiveArray){
            Sleep(1000);//暂停一秒，否则产生相同的随机种子
            srand((unsigned int)time(NULL));//产生一个随即种子
            DataType Tbase = DataType();//产生一个初始基准值。
            int nMod = nSize + 1;
            if (nSize == 0) return;
            switch (nArrayType){
            case PositiveArray:
                //正序数组，从前向后递增
                for (int i = 0; i < nSize; i++){
                    if (i != 0){
                        pArray[i] = pArray[i - 1] + rand() % nMod;
                    }
                    else{
                        pArray[i] = Tbase + rand() % nMod;
                    }
                }
                break;
            case NegativeArray:
                //逆序数组从后向前递增
                for (int i = nSize - 1; i >= 0; i--){
                    if (i != nSize - 1){
                        pArray[i] = pArray[i + 1] + rand() % nMod;
                    }
                    else{
                        pArray[i] = Tbase + rand() % nMod;
                    }
                }
                break;
            case RandomArray:
                //正序数组，从前向后递增
                for (int i = 0; i < nSize; i++){
                    pArray[i] = Tbase + rand() % nMod;
                }
                break;
            }
        };
        ~TestDataCreator(){
        };
    private:
        DataType pArray[nSize];
    public:
        //返回数组地址
        DataType* GetArray(){
            return pArray;
        };
        //返回数组长度
        int GetSize(){
            return nSize;
        };
    };
}
#endif

插入排序的算法实现，其中有较多跟踪日志：

#include "Test.h"
namespace MyAlgorithm{
using namespace Test;
template <typename T>
class Sort{
    public:
        Sort(){};
        ~Sort(){};
        void InsertSort(T testArray[],int nSize){
            LogInfo<T> log = LogInfo<T>();
            T key;//哨兵值
            int times(0), j(0), compare(0), move(0);//记录遍历次数,比较次数，移动次数
            log.ShowState("原始数组为 ：");
            log.ShowArray(testArray, nSize);
            for (int i = 1; i < nSize; i++){
                //第一个待排元素小于前面最大的元素就触发排序
                compare++;
                if (testArray[i]<testArray[i - 1]){ 
                    times++;
                    key = testArray[i];//记录待排元素作为哨兵
                    for (j = i - 1; j >= 0 && key<testArray[j]; j--){
                        compare++;
                        testArray[j + 1] = testArray[j];//元素后移，直到找到合适的位置停止
                        move++;
                    }
                    testArray[j + 1] = key;//将元素放在j+1位置，因为j位置就不符合条件了
                    move++;
                    log.ShowState("第" , times , "趟数组为：");
                    log.ShowArray(testArray, nSize);
                }
            }
            log.ShowState("最终数组为 ：");
            log.ShowArray(testArray, nSize);
            log.ShowState("比较次数：" ,compare);
            log.ShowState("  移动次数：" , compare);
            log.ShowLine();
        };
    };
}

调用方式

#include<iostream>
#include"Test.h"
#include"Sort.h"
#define N_MAX 10
int main()
{
    using namespace Test;
    using namespace MyAlgorithm;
    using namespace std;
    LogInfo<double> log = LogInfo<double>();
    Sort<double> sortTest = Sort<double>();
    log.ShowState("测试直接插入排序");
    log.ShowLine();
    log.ShowState("测试正序数组========================");
    log.ShowLine();
    TestDataCreator<double, N_MAX> testArray = TestDataCreator<double, N_MAX>(PositiveArray);
    sortTest.InsertSort(testArray.GetArray(), testArray.GetSize());
    log.ShowState("测试降序数组========================");
    log.ShowLine();
    testArray = TestDataCreator<double, N_MAX>(NegativeArray);
    sortTest.InsertSort(testArray.GetArray(), testArray.GetSize());
    log.ShowState("测试随机数组========================");
    log.ShowLine();
    testArray = TestDataCreator<double, N_MAX>(RandomArray);
    sortTest.InsertSort(testArray.GetArray(), testArray.GetSize());
    int nWait;
    cin >> nWait;
    return 0;
}

1. 遇到难题

   1)想通过模版类的模版参数来将测试数据生成器作为排序的入参，但是无法获取测试数据生成器的类型参数，查询很多资料没有答案。
   2)测试数据生成器无法作为排序入参，因此测试生成器的数据展示无法使用，实用价值不大，因此独立出来生成日志类。
   3)代码耦合性太高，现有经验无法进行进一步精简重构。

2. 经验总结
   1)模版参数的格式template ( template (typename DataType) class thing)
   2)模版参数中的类型参数外部不可见，使用的话可以通过模版继承，用子类的类型参数来初始化父类。
   3)C++没有重载+号作为字符串连接运算，字符串在C++编译器识别为指针。
   4)直接插入排序，最好不产生移动，所有元素都移动。内存操作太频繁，初始序列的状态影响算法效率。
   4.知识延伸

   1)从最坏的情况来看T(n)=1+2+…+n-1=n(n-1)/2 为n^2的时间复杂度。空间复杂度常量级。
   2)算法稳定。

3. 后续
   进行希尔排序的练习，以及选择排序练习。