1.自己写一个库：和建工程是一样的，但是建的项目是DLL文件，然后再其工程下添加源文件和头文件，源文件正常写，头文件是有要求的，__declspec(dllexport)的加入，程序在下面是给出的，所以往下读，你会有所得的！！最终得到DLL,LIB，以及.h文件（.h文件只是一个路径，在用的时候）
2.源文件----库文件（.h文件，lib文件，dll文件）
H文件和lib和opencv中的添加过程一样的，dll是要添加到debug文件夹中的，和.exe文件要放在一起的，在opencv中dll是放在环境变量中的，H是包含头文件中，lib是库目录中，lib中的lib是添加依赖项的，如果库不是很大的话，可以添加到项目路径下，直接在项目中#include”头文件”，#pragma comment(lib,”lib所在的路径下”)，这样就可以用库了，接着把dll复制到debug中去,整个工程就可以用库了，lib和头文件是编译的时候用，dll是程序运行的时候用，所以要和.exe放在一起使用的。
本人在vs2017中把之前写的排序库进行了一次跨平台编译，然后这个工程我们就来建一个（工程的库，供本人以后的开发使用的） Sortlib是已经编译好了的工程文件，接着把这个文件来生成dll lib .h 文件，
库里导出头文件：__declspec(dllexport) 放在头文件中的，不用就不用导出来的
生成成功之后dll和lib文件在debug文件中
然后就是在其他的工程中去使用他：和（2）中的操作是一致的
对于我这种比较差的人配置这个还真是挺难的，从写源代码，到生成自己的库，然后测试自己的库，真的挺多问题。
分成三部分完成的
（1）源文件的编写
（2）dll库文件的编写（用里面产生的dll,lib,头文件（导出的那部分）），
（3）测试，简单的方法就是把库文件放在自己建的项目里面，然后调用头文件，调用库文件，最后运行时把dll放到.exe可执行文件中去（放在一起的）
（4）对于非常大的库，我们就和配置opencv那样的进行配置（opencv是大库所以它的配置是可以直接在网上看到的）
（1）.cpp文件的编写（是我自己总结的几种排序的写法）（也叫自己的排序库）
#include “sortLib.h”
#include
#include
void show(int array[], int len)
{
int i = 0;
for (i = 0; i < len; i++)
{
printf("%d\t", array[i]);
}
printf("\n");
}
void swap(int array[], int i, int j)
{
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
/选择排序，选择关键字小的元素来进行交换/
void chooseSort(int array[], int len)
{
int i = 0, j = 0, k = 0;
for (i = 0; i < len; i++)
{
k = i;
for (j = i; j < len; j++)
{
if (array[k] > array[j])
{
k = j; //对于关键字的排序
}
}
swap(array, i, k); //每次交换都不需要进行交换的，每一扫描找出最小元素的下标的
}
//show(array,len);
}
/选择排序是一种稳定的排序算法/
/插入排序的办法，这种排序还是很厉害的是基于插入位置的一种插入算法/
void insertSort(int array[], int len)
{
int temp = 0, i = 0, j = 0, k = 0;
for (i = 1; i < len; i++)
{
k = i;
temp = array[i];
for (j = i - 1; (j >= 0) && (array[j] > temp); j–)
{
array[j + 1] = array[j];
k = j; //找位置的程序
}
array[k] = temp; //把元素插入到找到的位置中间
}
// show(array,len);
}
/插入排序是一种稳定的排序算法，2，2还是之前的2,2，对于数据元素是公平的/
/冒泡排序的用法，冒泡排序是一种在比较中进行交换的过程，第一趟进行n-1次排序。。。/
void bubbleSort(int array[], int len)
{
int i = 0, j = 0;
for (i = 0; i < len; i++)
{
for (j = len - 1; j > i; j–)
{
if (array[j] < array[j - 1])
{
swap(array, j, j - 1);
}
}
}
}
/冒泡排序也是一种稳定的排序算法，对于排序是相对公平的/
/以上是简版的冒泡排序算法，对于简版的排序算法可以进行优化处理的/
//加一个程序控制变量
void bubbleOptimizeSort(int array[], int len)
{
int i = 0, j = 0;
int control = 1;
for (i = 0; i < len && control; i++)
{
control = 0;
for (j = len - 1; j > i; j–) //切记不能等于的
{
if (array[j] < array[j - 1])
{
swap(array, j, j - 1);
control = 1;
}
}
}
}
/优化参数的说明，优化参数是针对程序的运行来说的，如果一趟下来程序中并没有发生交换就说明，这个数组或者其他是排好顺序的，优化参数在此时就决定不再进行程序的执行/
/快速排序的程序分解，快速排序是不稳定的对于快速算法就是对序列进行划分的过程的/
/进行一次划分/
int onceQuickSort(int array[], int low, int high)
{
int temp = array[low];//把第一个元素取出来作为基准元素的
while (low < high)
{
while ((low < high) && (array[high] >= temp))
{
high–;
}
swap(array, low, high);
while ((low < high) && (array[low] <= temp))
{
low++;
}
swap(array, low, high);
}
//进行完这次的划分之后会把基准元素划分好啦
array[low] = temp;
return low;
}
/在这里就完成了数据的第一次简单的划分/
/这里是对子序列进行递归的操作的/
void Qsort(int array[], int low, int high)
{
if (low < high)
{
int pv = onceQuickSort(array, low, high);
Qsort(array, low, pv - 1);
Qsort(array, pv + 1, high);
}//这里的操作都是在一个完整的空间里面操作的在一个完整的空间里面实现递归的操作过程
}
void QuickSort(int array[], int len)
{
Qsort(array, 0, len - 1);
}
/快速排序是一种不稳定的排序算法,在这里快速排序基于的原理就是不断的划分区间的/
/归并排序的用法，基于的思想也是分组的思想，在两个已经排好序的基础上进行排序/
//两组序列归并成一组的子程序
void Merge(int array[], int des[], int low, int med, int high)
{
int i = low; //左边序列的开始下标
int j = med + 1;//右边序列的开始下标
int k = low;//空数组的下标
while (i <= med && j <= high)
{
if (array[i] <= array[j])
{
des[k] = array[i];
k++;
i++;
}
else {
des[k] = array[j];
k++;
j++;
}
}
while (i <= med)
{
des[k++] = array[i++]; //左边的序列长
}
while (j <= high)
{
des[k++] = array[j++]; //两个序列的长度不等，右边的序列长
}
//把两个排好的子序列排成一个完整的序列
}
void MergeSort(int array[], int des[], int low, int high, int max)
{
if (low == high)
{
des[low] = array[high];
}
else {
int med = (low + high) / 2;
int* space = (int*)malloc(sizeof(int)*max);
if (space != NULL)
{
MergeSort(array, space, low, med, max);
MergeSort(array, space, med + 1, high, max);
Merge(space, des, low, med, high);
}
}
}
void MergeSortDisplay(int array[], int len)
{
MergeSort(array, array, 0, len - 1, len);
}
/归并排序是一种不稳定的排序算法，其排序思想是在递归的思想上进行的，对于两组有序的序列，进行排序笔记本上有归并排序的模型的/
/排序中的大神–希尔排序算法简单版本，基于插入排序的思想/
void shellSort(int array[], int len)
{
int i = 0, j = 0, gap = len;
do {
gap = gap / 3 + 1;//gap必须要收敛于1的
for (i = gap; i < len; i += gap)
{
int k = i;
int temp = array[k];
for (j = i - gap; (j >= 0) && array[j] > temp; j -= gap)
{
array[j + gap] = array[j];
k = j;
}
array[k] = temp;
}
} while (gap > 1);
}
/希尔排序是一种不稳定的排序算法，基于最简单的插入排序算法/
/希尔排序高级实现形式 对每一组进行希尔排序的利用的，gap在变分的组数就是在变的/
void ShellSort(int array[], int len)
{
int i, j, k, temp, m, l;
int gap = len;
for (gap = len / 2; gap > 0; gap = gap / 2) //对gap进行收敛递减的过程 如果最终能收敛到1也就是整个排序就是完美的
{
for (i = 0; i < gap; i++) //对于每一个gap分成gap组来进行插入排序
{
for (j = i + gap; j < len; j += gap) //每一组内进行排序的
{
if (array[j] < array[j - gap])
{
temp = array[j];
k = j - gap;
while (k >= 0 && array[k] > temp) {
array[k + gap] = array[k];
k = k - gap;
}
array[k + gap] = temp;
}
}
}
}
}
/希尔排序的原理是基于分组排序的原理进行的成功应用/
/希尔排序的自己实现方法/
void ShellSort1(int array[], int len)
{
int i, j, temp, gap, m, l;
for (gap = len / 2; gap > 0; gap = gap / 2) //最终一定要收敛到1的 ，不然算法退步出来的
{
for (i = 0; i < gap; i++) //对于每一个gap都会把数据分成gap组来进行处理的
{
for (j = i + gap; j < len; j += gap) //对于每一组内进行的排序
{
int l = j;
temp = array[l]; //这一步是非常关键的，不然在之后的数据复制会出错的，以后在多变量的程序中要注意的问题就是每一个变量的初值问题
for (m = j - gap; (m >= 0) && (array[m] > temp); m -= gap)
{
array[m + gap] = array[m];
l = m; ;
}
array[l] = temp;
}
}
}
}
/变量的初值问题 ，对于每一个变量不要突然的出现在某个位置上，一定要进行赋初值处理的/
以上就是整个源文件的
2.下面是头文件.h：最关键了
__declspec(dllexport) void show(int array[], int len);
__declspec(dllexport) void swap(int array[], int i, int j);
__declspec(dllexport) void chooseSort(int array[], int len);
__declspec(dllexport) void insertSort(int array[], int len);
__declspec(dllexport) void bubbleSort(int array[], int len);
__declspec(dllexport) void bubbleOptimizeSort(int array[], int len);
__declspec(dllexport) int onceQuickSort(int array[], int low, int high);
__declspec(dllexport) void Qsort(int array[], int low, int high);
__declspec(dllexport) void QuickSort(int array[], int len);
__declspec(dllexport) void Merge(int array[], int des[], int low, int med, int high);
__declspec(dllexport) void MergeSort(int array[], int des[], int low, int high, int max);
__declspec(dllexport) void MergeSortDisplay(int array[], int len);
__declspec(dllexport) void shellSort(int array[], int len);
__declspec(dllexport) void ShellSort(int array[], int len);
__declspec(dllexport) void ShellSort1(int array[], int len);
//导出头文件的方法：__declspec(dllexport)添加到头文件之前的 在项目下重新生成在debug文件夹下就去看看dll,和lib文件
3.把上面的源文件和头文件放到自己的工程中去，编译就可以产生 LIB AND DLL
4.测试自己的写的库文件，也就是相当于你调用别人的库是一样的，是不是感觉自己特别的牛逼！！哈哈测试代码如下：
#include “include\sortLib.h”
#pragma comment(lib,“include\sortDll.lib”)
int main(int argc, char *argv[])
{
int array[] = { 12,12,8,4,9,5,62,33 };
int len = sizeof(array) / sizeof(*array);
show(array, len);
ShellSort1(array, len);
show(array, len);
}
这里调用的是自己库中的希尔排序，自己测试下吧！！在写代码的过程中要沉住气！！