插入排序
-------------------siwuxie095
插入排序法
它的工作原理如下:
通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入
参考链接:
程序 1:插入排序法的实现
SortTestHelper.h:
#ifndef SORTTESTHELPER_H #define SORTTESTHELPER_H
#include <iostream> #include <string> #include <ctime> #include <cassert> using namespace std;
//辅助排序测试 namespace SortTestHelper {
//生成测试数据(测试用例),返回一个随机生成的数组: //生成有n个元素的随机数组,每个元素的随机范围为[rangeL,rangeR] int *generateRandomArray(int n, int rangeL, int rangeR) { //默认rangeL要小于等于rangeR assert(rangeL <= rangeR);
int *arr = new int[n];
//对于数组中的每一个元素,将之随机成为rangeL和rangeR之间的随机数 //先设置随机种子:这里将当前的时间作为种子来进行随机数的设置 srand(time(NULL));
for (int i = 0; i < n; i++) { //rand()函数+百分号+数的范围,即 取中间的一个随机整数,再加上rangeL即可 arr[i] = rand() % (rangeR - rangeL + 1) + rangeL; } return arr; }
//生成一个近乎有序的数组 int *generateNearlyOrderedArray(int n, int swapTimes) { //先生成完全有序的数组 int *arr = new int[n]; for (int i = 0; i < n; i++) { arr[i] = i; }
//以当前时间为随机种子 srand(time(NULL));
//再随机挑选几对元素进行交换,就是一个近乎有序的数组了 for (int i = 0; i < swapTimes; i++) { int posx = rand() % n; int posy = rand() % n; swap(arr[posx], arr[posy]); }
return arr; }
template<typename T> void printArray(T arr[], int n) { for (int i = 0; i < n; i++) { cout << arr[i] << " "; } cout << endl; }
//经过排序算法排序后,再次确认是否已经完全排序 template<typename T> bool isSorted(T arr[], int n) { for (int i = 0; i < n - 1; i++) { if (arr[i]>arr[i + 1]) { return false; } } return true; }
//衡量一个算法的性能如何,最简单的方式就是看这个算法在特定数据集上的执行时间 //(1)传入排序算法的名字,方便打印输出 //(2)传入排序算法本身,即函数指针 //(3)传入测试用例:数组和元素个数 template<typename T> void testSort(string sortName, void(*sort)(T[], int), T arr[], int n) { //在排序前后分别调用clock()函数 //时间差就是该排序算法执行的时钟周期的个数 clock_t startTime = clock(); sort(arr, n); clock_t endTime = clock();
assert(isSorted(arr, n));
//endTime 减去 startTime 转为double类型,除以 CLOCKS_PER_SEC,其中: // //CLOCKS_PER_SEC 是标准库中定义的一个宏,表示每一秒钟所运行的时钟周期 //的个数,而(endTime-startTime)返回的是运行了几个时钟周期 // //这样,最终的结果就是在这段时间中程序执行了多少秒 cout << sortName << ":" << double(endTime - startTime) / CLOCKS_PER_SEC << "s" << endl; }
//复制数组 int *copyIntArray(int a[], int n) { int *arr = new int[n]; //copy()函数在std中: //第一个参数是原数组的头指针, //第二个参数是原数组的尾指针, //第三个参数是目的数组的头指针 // //注意:copy()函数运行时会报错,需要在: //项目->属性->配置属性->C/C++->预处理器->预处理器定义 //在其中添加:_SCL_SECURE_NO_WARNINGS copy(a, a + n, arr); return arr; } }
#endif |
InsertionSort.h:
#ifndef INSERTIONSORT_H #define INSERTIONSORT_H
//插入排序是 O(n^2) 级别算法复杂度的排序算法,它的思想就类似于 //在玩扑克牌时插入牌的思想,即 将拿到的一张牌插入到合适的位置, //当最后一张牌也插入后,手中的整副扑克牌也就排序完成了
//插入排序:从小到大进行排序 template<typename T> void insertionSort(T arr[], int n) { //对于插入排序来说,第一个元素(索引为0)根本不用考虑 // //因为在插入排序的初始,第一个元素放在那里,它本身就已经 //有序了,不需要再把它插入到前面的任何位置,所以从第二个 //元素(索引为1)开始考察 for (int i = 1; i < n; i++) { //寻找arr[i]合适的插入位置: //对已经排好序的部分,插入时从后向前比较, //最多只会考察到j=1时,因为是从后向前比较 // //写法1: for (int j = i; j > 0; j--) { if (arr[j] < arr[j - 1]) { swap(arr[j], arr[j - 1]); } else { //当arr[i]插入到合适位置后,就跳出当前循环 //继续对下一个元素进行考察 break; } }
////将for循环中的 if 条件加入到for循环中 //(内层循环的两种写法,可替代上面的写法1) //写法2: //for (int j = i; j > 0 && arr[j] > arr[j - 1]; j--) //{ // swap(arr[j], arr[j - 1]); //} } }
#endif |
main.cpp:
#include "SortTestHelper.h" #include "InsertionSort.h"
int main() { int n = 10000;
int *arr = SortTestHelper::generateRandomArray(n, 0, n);
SortTestHelper::testSort("Insertion Sort", insertionSort, arr, n);
//SortTestHelper::printArray(arr, n);
delete []arr;
system("pause"); return 0; } |
运行一览:
程序 2:插入排序法和选择排序法的比较
SortTestHelper.h:
#ifndef SORTTESTHELPER_H #define SORTTESTHELPER_H
#include <iostream> #include <string> #include <ctime> #include <cassert> using namespace std;
//辅助排序测试 namespace SortTestHelper {
//生成测试数据(测试用例),返回一个随机生成的数组: //生成有n个元素的随机数组,每个元素的随机范围为[rangeL,rangeR] int *generateRandomArray(int n, int rangeL, int rangeR) { //默认rangeL要小于等于rangeR assert(rangeL <= rangeR);
int *arr = new int[n];
//对于数组中的每一个元素,将之随机成为rangeL和rangeR之间的随机数 //先设置随机种子:这里将当前的时间作为种子来进行随机数的设置 srand(time(NULL));
for (int i = 0; i < n; i++) { //rand()函数+百分号+数的范围,即 取中间的一个随机整数,再加上rangeL即可 arr[i] = rand() % (rangeR - rangeL + 1) + rangeL; } return arr; }
//生成一个近乎有序的数组 int *generateNearlyOrderedArray(int n, int swapTimes) { //先生成完全有序的数组 int *arr = new int[n]; for (int i = 0; i < n; i++) { arr[i] = i; }
//以当前时间为随机种子 srand(time(NULL));
//再随机挑选几对元素进行交换,就是一个近乎有序的数组了 for (int i = 0; i < swapTimes; i++) { int posx = rand() % n; int posy = rand() % n; swap(arr[posx], arr[posy]); }
return arr; }
template<typename T> void printArray(T arr[], int n) { for (int i = 0; i < n; i++) { cout << arr[i] << " "; } cout << endl; }
//经过排序算法排序后,再次确认是否已经完全排序 template<typename T> bool isSorted(T arr[], int n) { for (int i = 0; i < n - 1; i++) { if (arr[i]>arr[i + 1]) { return false; } } return true; }
//衡量一个算法的性能如何,最简单的方式就是看这个算法在特定数据集上的执行时间 //(1)传入排序算法的名字,方便打印输出 //(2)传入排序算法本身,即函数指针 //(3)传入测试用例:数组和元素个数 template<typename T> void testSort(string sortName, void(*sort)(T[], int), T arr[], int n) { //在排序前后分别调用clock()函数 //时间差就是该排序算法执行的时钟周期的个数 clock_t startTime = clock(); sort(arr, n); clock_t endTime = clock();
assert(isSorted(arr, n));
//endTime 减去 startTime 转为double类型,除以 CLOCKS_PER_SEC,其中: // //CLOCKS_PER_SEC 是标准库中定义的一个宏,表示每一秒钟所运行的时钟周期 //的个数,而(endTime-startTime)返回的是运行了几个时钟周期 // //这样,最终的结果就是在这段时间中程序执行了多少秒 cout << sortName << ":" << double(endTime - startTime) / CLOCKS_PER_SEC << "s" << endl; }
//复制数组 int *copyIntArray(int a[], int n) { int *arr = new int[n]; //copy()函数在std中: //第一个参数是原数组的头指针, //第二个参数是原数组的尾指针, //第三个参数是目的数组的头指针 // //注意:copy()函数运行时会报错,需要在: //项目->属性->配置属性->C/C++->预处理器->预处理器定义 //在其中添加:_SCL_SECURE_NO_WARNINGS copy(a, a + n, arr); return arr; } }
#endif |
InsertionSort.h:
#ifndef INSERTIONSORT_H #define INSERTIONSORT_H
//插入排序是 O(n^2) 级别算法复杂度的排序算法,它的思想就类似于 //在玩扑克牌时插入牌的思想,即 将拿到的一张牌插入到合适的位置, //当最后一张牌也插入后,手中的整副扑克牌也就排序完成了
//插入排序:从小到大进行排序 template<typename T> void insertionSort(T arr[], int n) { //对于插入排序来说,第一个元素(索引为0)根本不用考虑 // //因为在插入排序的初始,第一个元素放在那里,它本身就已经 //有序了,不需要再把它插入到前面的任何位置,所以从第二个 //元素(索引为1)开始考察 for (int i = 1; i < n; i++) { //寻找arr[i]合适的插入位置: //对已经排好序的部分,插入时从后向前比较, //最多只会考察到j=1时,因为是从后向前比较 // //写法1: for (int j = i; j > 0; j--) { if (arr[j] < arr[j - 1]) { swap(arr[j], arr[j - 1]); } else { //当arr[i]插入到合适位置后,就跳出当前循环 //继续对下一个元素进行考察 break; } }
////将for循环中的 if 条件加入到for循环中 //(内层循环的两种写法,可替代上面的写法1) //写法2: //for (int j = i; j > 0 && arr[j] > arr[j - 1]; j--) //{ // swap(arr[j], arr[j - 1]); //} } }
#endif |
SelectionSort.h:
#ifndef SELECTIONSORT_H #define SELECTIONSORT_H
//选择排序:从小到大进行排序 template<typename T> void selectionSort(T arr[], int n) { for (int i = 0; i < n; i++) { //寻找[i,n]区间里的最小值 int minIndex = i;
for (int j = i + 1; j < n; j++) { if (arr[j] < arr[minIndex]) { minIndex = j; } } //swap()函数:交换两个值,对于swap()函数来说: //在C++ 11标准中,它就在std标准命名空间中,即 标准库中,不用包含其它 //如果是比较老的标准,它在algorithm库中,需要include <algorithm> swap(arr[i], arr[minIndex]); } }
#endif |
main.cpp:
#include "SortTestHelper.h" #include "InsertionSort.h" #include "SelectionSort.h"
int main() { int n = 10000;
int *arr1 = SortTestHelper::generateRandomArray(n, 0, n); int *arr2 = SortTestHelper::copyIntArray(arr1, n);
SortTestHelper::testSort("Insertion Sort", insertionSort, arr1, n); SortTestHelper::testSort("Selection Sort", selectionSort, arr2, n);
delete []arr1; delete []arr2;
system("pause"); return 0; }
//插入排序和选择排序的最大区别就是: // //对于 第二重循环,也就是 内层循环,插入排序可以提前结束,而 //选择排序则没有提前中止的机会 // // //所以理论上,插入排序应该比选择排序更快一些,但实际比较时 //却发现插入排序的性能比选择排序还要差,也就是用时更多 // //这是因为:此时的插入排序在遍历的同时,也在不停的交换,而 //交换的操作比简单的比较操作更耗时,每一次交换,背后就有三 //次赋值的操作 |
运行一览:
程序 3:插入排序法的优化
SortTestHelper.h:
#ifndef SORTTESTHELPER_H #define SORTTESTHELPER_H
#include <iostream> #include <string> #include <ctime> #include <cassert> using namespace std;
//辅助排序测试 namespace SortTestHelper {
//生成测试数据(测试用例),返回一个随机生成的数组: //生成有n个元素的随机数组,每个元素的随机范围为[rangeL,rangeR] int *generateRandomArray(int n, int rangeL, int rangeR) { //默认rangeL要小于等于rangeR assert(rangeL <= rangeR);
int *arr = new int[n];
//对于数组中的每一个元素,将之随机成为rangeL和rangeR之间的随机数 //先设置随机种子:这里将当前的时间作为种子来进行随机数的设置 srand(time(NULL));
for (int i = 0; i < n; i++) { //rand()函数+百分号+数的范围,即 取中间的一个随机整数,再加上rangeL即可 arr[i] = rand() % (rangeR - rangeL + 1) + rangeL; } return arr; }
//生成一个近乎有序的数组 int *generateNearlyOrderedArray(int n, int swapTimes) { //先生成完全有序的数组 int *arr = new int[n]; for (int i = 0; i < n; i++) { arr[i] = i; }
//以当前时间为随机种子 srand(time(NULL));
//再随机挑选几对元素进行交换,就是一个近乎有序的数组了 for (int i = 0; i < swapTimes; i++) { int posx = rand() % n; int posy = rand() % n; swap(arr[posx], arr[posy]); }
return arr; }
template<typename T> void printArray(T arr[], int n) { for (int i = 0; i < n; i++) { cout << arr[i] << " "; } cout << endl; }
//经过排序算法排序后,再次确认是否已经完全排序 template<typename T> bool isSorted(T arr[], int n) { for (int i = 0; i < n - 1; i++) { if (arr[i]>arr[i + 1]) { return false; } } return true; }
//衡量一个算法的性能如何,最简单的方式就是看这个算法在特定数据集上的执行时间 //(1)传入排序算法的名字,方便打印输出 //(2)传入排序算法本身,即函数指针 //(3)传入测试用例:数组和元素个数 template<typename T> void testSort(string sortName, void(*sort)(T[], int), T arr[], int n) { //在排序前后分别调用clock()函数 //时间差就是该排序算法执行的时钟周期的个数 clock_t startTime = clock(); sort(arr, n); clock_t endTime = clock();
assert(isSorted(arr, n));
//endTime 减去 startTime 转为double类型,除以 CLOCKS_PER_SEC,其中: // //CLOCKS_PER_SEC 是标准库中定义的一个宏,表示每一秒钟所运行的时钟周期 //的个数,而(endTime-startTime)返回的是运行了几个时钟周期 // //这样,最终的结果就是在这段时间中程序执行了多少秒 cout << sortName << ":" << double(endTime - startTime) / CLOCKS_PER_SEC << "s" << endl; }
//复制数组 int *copyIntArray(int a[], int n) { int *arr = new int[n]; //copy()函数在std中: //第一个参数是原数组的头指针, //第二个参数是原数组的尾指针, //第三个参数是目的数组的头指针 // //注意:copy()函数运行时会报错,需要在: //项目->属性->配置属性->C/C++->预处理器->预处理器定义 //在其中添加:_SCL_SECURE_NO_WARNINGS copy(a, a + n, arr); return arr; } }
#endif |
InsertionSort.h:
#ifndef INSERTIONSORT_H #define INSERTIONSORT_H
//插入排序是 O(n^2) 级别算法复杂度的排序算法,它的思想就类似于 //在玩扑克牌时插入牌的思想,即 将拿到的一张牌插入到合适的位置, //当最后一张牌也插入后,手中的整副扑克牌也就排序完成了
//插入排序:从小到大进行排序 template<typename T> void insertionSort(T arr[], int n) { //对于插入排序来说,第一个元素(索引为0)根本不用考虑 // //因为在插入排序的初始,第一个元素放在那里,它本身就已经 //有序了,不需要再把它插入到前面的任何位置,所以从第二个 //元素(索引为1)开始考察 for (int i = 1; i < n; i++) { //寻找arr[i]合适的插入位置: //对已经排好序的部分,插入时从后向前比较, //最多只会考察到j=1时,因为是从后向前比较 // //先将要插入的元素arr[i]保存到e中,在和已经排好序的部分进行比较时: //(1)如果小于当前被比较的元素arr[j-1],则将当前被比较的元素向后移一位 //(2)如果大于当前被比较的元素arr[j-1],则当前位置j就是要插入的位置 T e = arr[i]; int j;//保存元素e应该插入的位置 for (j = i; j > 0 && arr[j - 1] > e; j--) { arr[j] = arr[j - 1]; } //将之前保存在e中的元素插入到位置j arr[j] = e;
} }
#endif |
main.cpp:
#include "SortTestHelper.h" #include "InsertionSort.h"
int main() { int n = 10000;
//随机数组arr int *arr = SortTestHelper::generateRandomArray(n, 0, n); //近乎有序的数组arrx int *arrx = SortTestHelper::generateNearlyOrderedArray(n, 100);
SortTestHelper::testSort("Insertion Sort", insertionSort, arr, n); SortTestHelper::testSort("Insertion Sort", insertionSort, arrx, n);
delete []arr; delete []arrx;
system("pause"); return 0; }
//此时的插入排序,不但不再使用交换操作,更重要的是插入排序可以提前中止内层循环 // //对于插入排序来说,提前中止内层循环是非常重要的一个性质 // //提前中止的条件是:一旦找到合适的位置就中止 // //假设这个数组本身就基本上是有序的,这种情况下,内层循环可以很快的找到它应该 //插入的位置,此时,插入排序的效率会非常的高 // //可以简单模拟如下: //(1)在生成这个数组时,让这个随机数的范围变小一些 //(2)在生成这个数组时,先生成一个完全有序的数组,再将该数组中的若干对元素交换 // //对于一个近乎有序的数组来说,插入排序的性能要远远的优于选择排序 // //事实上,插入排序对于近乎于有序的数组来说,它的性能比O(n*lgn)的级别的排序算法还 //要快,这也是为什么插入排序是有非常重要的实际意义 // //因为很多时候,我们处理的真实的数据,是近乎有序的 // //比如说:一套系统的日志,它的生成,就是按照时间去生成的,但又可能在中间 //产生了一些错误,或者是某一些任务时间过长,所以存在几个无序的元素,对于 //这样的一个系统日志,使用插入排序进行排序,性能会更好 // //通过代码不难发现,在最优的情况下,即当要排序的内容是一个完全有序的数组时, //插入排序将变成一个O(n)级别的算法,也就是说在内层循环中,每一次都执行一下, //发现当前的位置就是合适的位置,直接结束内层循环,进入下一次循环,这是插入 //排序非常重要的一个性质 // //也正是这个原因,插入排序也会在更加复杂的排序算法中作为一个子过程来进行优化 // // // //选择排序的思想非常简单,它的缺点也非常明显: //对于任何一个数组,选择排序,两层循环,每一层循环都必须完全的执行完成, //正是因为如此,选择排序的效率在任何情况下都是 //非常慢的 // //而插入排序,虽然它的最差的时间复杂度也是O(n^2)级别的,但是在数组近乎 //有序的情况下,插入排序的性能非常的高,甚至比O(n*lgn)级别的排序算法性能 //还要高,这使得插入排序有着非常重要的实际意义 // //对插入排序的深入理解也告诉我们:O(n^2)级别的排序算法并非一无是处, //对于近乎有序的数组,插入排序的效率相对比较高 |
运行一览:
【made by siwuxie095】
posted on 2017-05-26 13:56 siwuxie095 阅读(249) 评论(0) 编辑 收藏 举报