直接插入排序(Straight Insertion Sort)

知识背景与目的

进行直接插入排序算法练习，使用上篇的数据生成测试。

插入排序：将待排序的元素插入到已经排序好的有序序列中。

插入排序常见的有：直接插入排序(straight Insertion Sort)与希尔排序(shell’s Sort)

直接插入排序：逐个将元素插入带已经排序好的有序序列中。

归纳法证明：

第一步：i=1,单个元素，肯定是已经排序好的。

第二步：i=j,将第j+1位元素（记为K)，插入到前面n个已经排好的序列中。将大于K的元素后移，直到小于K元素被找到，找到将K放在该位置，此时序列已经呈现有序状态，元素个数为j+1;没有找到小于K的元素，则将K放在第一位，亦然成立。

第三步：i=n,此时参照步骤二，同样可以得到长度为n的有序序列，整个序列，排序完毕。算法证明完毕。

代码

重新调整了测试类，并增加了日志类，该类用来输出数组。

#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[]
4000
,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)想通过模版类的模版参数来将测试数据生成器作为排序的入参，但是无法获取测试数据生成器的类型参数，查询很多资料没有答案。

2)测试数据生成器无法作为排序入参，因此测试生成器的数据展示无法使用，实用价值不大，因此独立出来生成日志类。

3)代码耦合性太高，现有经验无法进行进一步精简重构。

经验总结

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)算法稳定。

后续

进行希尔排序的练习，以及选择排序练习。