《直接插入排序》四部曲

一、直接插入排序——基本版

传入整型数组 a[] 及其元素个数，通过直接插入排序算法实现数组的升序排序。

1. 算法实现

// 1. 直接插入排序（升序）
void insert_sort(int a[], int len)
{
    int i, j, temp;

    for(i=1; i<len; i++)
    {
        temp = a[i];
        for(j=i-1; j>=0 && temp<a[j]; j--)
        {
            a[j+1] = a[j];
        }
        a[j+1] = temp;
    }
}

2. 主函数

#include <iostream>
using namespace std;

// 打印数组的每个元素
void print_array(int a[], int len)
{
    for(int i=0; i<len; i++)
    {
        cout << a[i] << ' ';
    }
    cout << endl;
}

int main()
{
   int a[] = {7, 5, 4, 6, 9, 2, 1, 3, 8};
   int len = sizeof(a)/sizeof(int);
   cout << "before insert sort: ";
   print_array(a, len);
   insert_sort(a, len); // 输出为：1 2 3 4 5 6 7 8 9 
   cout << "after  insert sort: ";
   print_array(a, len);

   return 0;
}

---

二、直接插入排序——仿函数版

如果我想把数组降序排列怎么办呢？

接下来尝试通过 仿函数 实现 排序算法的升降序控制。

1. 算法实现

// 定义仿函数指针类型名
typedef bool (*func_cmp2)(int, int);


// 声明仿函数，用作升降顺序的默认函数指针，默认升序。
bool _less2(int n1, int n2); // return n1 < n2;
// 声明1.2版本的直接插入函数
// 输入参数为：整型数组a，数组元素个数len，仿函数cmp。仿函数默认为升序函数 _less2。
void insert_sort2( int a[], int len, func_cmp2 cmp = _less2 );




// 仿函数，用作升降顺序的默认函数指针，默认升序。
// 升序
bool _less2(int n1, int n2)
{
    return n1 < n2;
}


// 1.2 直接插入排序（默认升序）
// a. 通过 仿函数 实现 自定义升降序，默认升序
void insert_sort2( int a[], int len, func_cmp2 cmp )
{
    int i, j, temp;

    for(i=1; i<len; i++)
    {
        temp = a[i];
        for(j=i-1; j>=0 && cmp(temp, a[j]); j--) // 通过仿函数 cmp 确定元素大小顺序
        {
            a[j+1] = a[j];
        }
        a[j+1] = temp;
    }
}

2. 主函数

#include <iostream>
using namespace std;


// 仿函数，用作升降顺序的默认函数指针。
// 降序
bool _greater2(int n1, int n2)
{
    return n1 > n2;
}



int main()
{
   int a[] = {7, 5, 4, 6, 9, 2, 1, 3, 8};
   int len = sizeof(a)/sizeof(int);
   cout << "before insert sort: ";
   print_array(a, len);

   insert_sort2(a, len); // 默认升序，输出为：1 2 3 4 5 6 7 8 9 
   cout << "after  insert sort: ";
   print_array(a, len);

   insert_sort2(a, len, _greater2); // 降序，输出为：9 8 7 6 5 4 3 2 1 
   cout << "after  insert sort: ";
   print_array(a, len);

   return 0;
}

---

三、直接插入排序——void* 版

通过 void* 实现 不同内置类型数组的数据传入

1. 算法实现

// 定义仿函数指针类型名
typedef bool (*func_cmp3)(const void*, const void*);


// 声明1.3版本的直接插入排序
// 输入参数为：内置类型的数组a，数组元素个数len，数据类型字节数type_sz，仿函数cmp。
void insert_sort3( void* a, size_t len, size_t type_sz, func_cmp3 cmp );



// 1.3 直接插入排序
// a. 通过 仿函数 实现 自定义升降序，需要自己实现仿函数
// b. 通过 void* 实现 可传入不同内置类型的数组
void insert_sort3( void* a, size_t len, size_t type_sz, func_cmp3 cmp )
{
    size_t i, j;
    void* temp = malloc(type_sz); // ！！注意：指针操作，需要申请内存。记得末尾要释放该内存。

    for(i=1; i<len; i++)
    {
        // temp = a + i * sz;
        memcpy(temp, a + i * type_sz, type_sz);
        // for(j=i-1; j>=0 && cmp(temp, (a+j*sz)); j--) // ！！注意，size_t为unsigned int，永远大于0，所以(0-1+1)!=0，所以 j>=0 条件将判定错误
        for(j=i; j>0 && cmp(temp, (a+(j-1)*type_sz)); j--)
        {
            memcpy(a + j * type_sz, a + (j-1) * type_sz, type_sz);
        }
        memcpy(a + j * type_sz, temp, type_sz);
    }
    free(temp); // 释放内存
    temp = nullptr; // 指针赋空，防止野指针
}

2. 主函数

#include <iostream>
#include <cstring>
using namespace std;


// 定义仿函数，用作升降顺序的默认函数指针。
// 升序
bool _less3(const void* p1, const void* p2)
{
    return *(int*)p1 < *(int*)p2;
}

// 降序
bool _greater3(const void* p1, const void* p2)
{
    return *(int*)p1 > *(int*)p2;
}



int main()
{
   int a[] = {7, 5, 4, 6, 9, 2, 1, 3, 8};
   int len = sizeof(a)/sizeof(int);
   cout << "before insert sort: ";
   print_array(a, len);

   insert_sort3(a, len, sizeof(int), _less3); // 升序，输出为：1 2 3 4 5 6 7 8 9 
   cout << "after  insert sort: ";
   print_array(a, len);

   insert_sort3(a, len, sizeof(int), _greater3); // 降序，输出为：9 8 7 6 5 4 3 2 1 
   cout << "after  insert sort: ";
   print_array(a, len);

   return 0;
}

---

四、直接插入排序——函数模板版

没能实现……

想尝试通过 函数模板 实现 不同类型数组的排序，奈何技术有限，没做出来。模板函数与仿函数一起用的时候，就搞不定了。希望大神看到能指点一下，谢谢！