内部排序算法总结（一）
内部排序算法总结（一）
注：以下所有排序代码中都是通过简单的仿函数实现通用。该部分的代码实现是以下所有排序算法的基础
//filename： stdafx.h #pragma once #include<iostream> using namespace std; #include<assert.h> template<class T> struct Great { bool operator()(const T&x, const T&y) { return x > y; } }; template<class T> void PrintArr(T *arr, size_t n) { for (int i = 0; i < n; i++) { cout << arr[i] << " "; } cout << endl; }
一.插入排序
①简单插入排序
原理：对给定数组，遍历之并将之插入到已有的空组中（其实就是遍历点之前的已存有序组）
//filename： InsertSort.h
#pragma once
#include"stdafx.h"
template<class T,template <class>class Cmp = Great > void InsertSort(T *arr, size_t n) { assert(arr); ///1532685 for (int beg = 1; beg < n; ++beg) { int end = beg - 1; while (end >= 0 && Cmp<T>()(arr[end], arr[end+1])) { swap(arr[end], arr[end + 1]); end--; } } } void TestInsertSort() { int arr[10] = { 1, 4, 7, 5, 2, 3, 6, 8, 9, 0 }; //ShellSort<int>(arr, 10); InsertSort<int>(arr, 10); PrintArr<int>(arr, 10); }
②希尔排序（缩小增量排序）
原理：希尔排序是对插入排序的进一步优化提升。
先将整个待排序序列分割成若干个子序列，分别进行直接插入排序，待整个序列中的数据“整体有序“时，再对整个序列进行一次 直接插入排序。
//filename：InsertSort.h //希尔排序 template<class T, template <class>class Cmp = Great > void ShellSort(T*arr, size_t n) { assert(arr); int gap = n; while (gap > 1) { gap = gap / 3 + 1; for (int beg = gap; beg < n; ++beg) { int end = beg-gap; while (end >= 0 && Cmp<T>()(arr[end], arr[end + gap])) { swap(arr[end], arr[end + gap]); end-=gap; } } } } void TestShellSort() { int arr[10] = { 1, 4, 7, 5, 2, 3, 6, 8, 9, 0 }; ShellSort<int>(arr, 10); //InsertSort<int>(arr, 10); PrintArr<int>(arr, 10); }
二.选择排序
①直接选择排序
原理：通过两层循环控制，外层确定次数为查找次数，内层找到当前最值放在最右或者左。
//filename:SelectSort.h
#include"stdafx.h" template<class T, template<class> class Cmp = Great> void SelectSort(T*arr, size_t n) { assert(arr); for (int beg = 0; beg < n; ++beg) { int flag = beg; for (int j = beg + 1; j < n; ++j) { if (Cmp<T>()(arr[flag], arr[j])) flag = j; } swap(arr[beg], arr[flag]); } } /////////////////////Test void TestSelectSort() { int arr[10] = { 1, 4, 7, 5, 2, 3, 6, 8, 9, 0 }; //ShellSort<int>(arr, 10); SelectSort<int>(arr, 10); PrintArr<int>(arr, 10); }
②直接选择排序的优化
改进：对于直接插入排序中的每次知道到最大/小值放在合适的位置这个点，进行加强：每次找到最大，最小值，放在两侧。从而减少交换次数
//filename:SelectSort.h template<class T, template<class> class Cmp = Great> void BetSelectSort(T*arr, size_t n) { assert(arr); int beg = 0; int end = n - 1; while(beg<end) { int leftF = beg; int rightF = end; for (int j = beg; j <=end; ++j) { if (Cmp<T>()(arr[leftF], arr[j])) swap(arr[leftF], arr[j]); if (!Cmp<T>()(arr[rightF], arr[j])) swap(arr[rightF], arr[j]); } ++beg; --end; } } //Test void TestBetSelectSort() { int arr[10] = { 1, 4, 7, 5, 2, 3, 6, 8, 9, 0 }; //ShellSort<int>(arr, 10); BetSelectSort<int>(arr, 10); PrintArr<int>(arr, 10); }
③堆排序
原理：根据最大堆最小堆可以快速求得最值的策略。利用堆进行排序。取堆顶元素放在适当位置
//filename:SelectSort.h
int Arr[10] = { 1, 4, 7, 5, 2, 3, 6, 8, 9, 0 }; template<class T, template<class> class Cmp = Great> void AdjustDown(T*arr, int n, int root) { if (n <=1) return; while (root <= (n - 2) / 2) { int child= root * 2 + 1; child = child + 1 < n ? Cmp<T>()(arr[child + 1], arr[child]) ? child + 1 : child : child; if (Cmp<T>()(arr[child], arr[root])) { swap(arr[child], arr[root]); } root = child; } } template<class T, template<class> class Cmp = Great> void heapSort(T*arr, size_t n) { //建堆 for (int i = (n - 2) / 2; i >= 0;--i) { AdjustDown(arr, n, i); } //排序 int end = n - 1; while (end > 0) { swap(arr[0], arr[end]); AdjustDown<T>(arr, end, 0); end--; } } void TestheapSort() { heapSort<int>(Arr, 10); PrintArr<int>(Arr, 10); }
三.快速排序
①冒泡排序
原理：通过N次遍历，每一次数据从头往后遍历，和相邻位置比较，如果顺序不正确就交换。直到全部有序
//filename: FastSort.h #pragma once #include"stdafx.h" template<class T, template <class>class Cmp = Great > void BubbSort(T *arr, size_t n) { for (int beg = 0; beg < n; ++beg) { for (int j = 0; j < n - beg - 1; ++j) { if (Cmp<T>()(arr[j], arr[j + 1])) { swap(arr[j], arr[j + 1]); } } } } void TestBubbSort() { int arr[10] = { 1, 4, 7, 5, 2, 3, 6, 8, 9, 0 }; BubbSort<int>(arr, 10); PrintArr<int>(arr, 10); }
②冒泡排序优化
改进点：对冒泡排序，当某次冒泡的遍历过程中，发现遍历过程数据都是有序的，那么剩余的遍历冒泡就是非必要的。
//filename:FastSort.h
void BubbSort_B(T *arr, size_t n) { for (int beg = 0; beg < n; ++beg) { int flag = 0; for (int j = 0; j < n - beg - 1; ++j) { if (Cmp<T>()(arr[j], arr[j + 1])) { swap(arr[j], arr[j + 1]); //交换了那么设置调整开关为1 flag = 1; } } //如果遍历过程中不曾修改，那么说明序列有序，不在遍历 if (flag == 0) break; } }
③快速排序
思想原理：通过一趟排序将待排序记录分割成独立的两部分，其一部分比另一部分关键字小，则可以对这两部分数据继续递归进行排序，直到有序
template<class T, template <class>class Cmp = Great > void FastSort(T *arr, size_t n, int first, int last) { if (first < 0 || last >= n||first>last) return; int beg = first; int end = last; while (beg < end) { while (beg < end&&Cmp<T>()(arr[end], arr[beg])) { --end; } swap(arr[beg], arr[end]); while (beg < end && (Cmp<T>()(arr[end], arr[beg]))) { ++beg; } swap(arr[beg], arr[end]); } //beg == end == 中间元素 FastSort(arr, n, first, beg - 1); FastSort(arr, n, beg + 1, last); } void TestFastSort() { int arr[10] = { 1, 4, 7, 5, 2, 3, 6, 8, 9, 0 }; FastSort<int>(Arr, 10,0,9); PrintArr<int>(Arr, 10); }
四.归并排序
归并：将两个或者两个以上的有序表组合成一个新的有序表
2-路归并排序的核心操作：将一维数组中的相邻两个有序序列归并为一个有序序列
// 归并排序中的合并算法 void Merge(int array[], int start, int mid, int end) { int temp1[10], temp2[10]; int n1, n2; n1 = mid - start + 1; n2 = end - mid; // 拷贝前半部分数组 for (int i = 0; i < n1; i++) { temp1[i] = array[start + i]; } // 拷贝后半部分数组 for (int i = 0; i < n2; i++) { temp2[i] = array[mid + i + 1]; } // 把后面的元素设置的很大 temp1[n1] = temp2[n2] = 1000; // 逐个扫描两部分数组然后放到相应的位置去 for (int k = start, i = 0, j = 0; k <= end; k++) { if (temp1[i] <= temp2[j]) { array[k] = temp1[i]; i++; } else { array[k] = temp2[j]; j++; } } } // 归并排序 void MergeSort(int array[], int start, int end) { if (start < end) { int i; i = (end + start) / 2; // 对前半部分进行排序 MergeSort(array, start, i); // 对后半部分进行排序 MergeSort(array, i + 1, end); // 合并前后两部分 Merge(array, start, i, end); } } void TestMSort2() { int arr[10] = { 1, 4, 7, 5, 2, 3, 6, 8, 9, 0 }; MergeSort(arr, 0, 9); PrintArr<int>(arr, 10); }
②归并中的改进优化，对函数Merge进行改进，上边的方案中，只是静态的在栈上定义临时数组。大小固定。我们应当是用动态new来申请保存的
而且，对于数组的临时保存，我们只需要保存头后者尾中的一半，然后反向归并即可。
#include"stdafx.h" //[)[) template<class T,template<class>class Cmp = Great> void MerGe(int * arr, int start, int cir, int end) { assert(arr); int newLen = end - cir; int * newArr = new int[newLen]; //保存后半部分值 for (int i = cir; i < end; ++i) { newArr[i-cir] = arr[i]; } //将后半部分并入元数组 while (newLen&&cir) { //if (newArr[newLen - 1]>arr[cir - 1]) if (Cmp<T>()(newArr[newLen - 1], arr[cir - 1])) { arr[--end] = newArr[newLen - 1]; newLen--; } else { arr[--end] = arr[cir - 1]; cir--; } } //如果后半部分有剩余，那么直接加入前半部分 //否则就不处理，因为本身就是在原数组中处理的 if (newLen) { for (int i = 0; i < newLen; ++i) { arr[i] = newArr[i]; } } delete[]newArr; } // 归并排序 template<class T,template<class> class Cmp = Great> void MergeSort(int array[], int start, int end) { if (start < end) { int i; i = (end + start) / 2; // 对前半部分进行排序 MergeSort<T>(array, start, i); // 对后半部分进行排序 MergeSort<T>(array, i + 1, end); // 合并前后两部分 MerGe<T>(array, start, i, end); } } void TestMerge() { int arr[10] = { 1, 4, 7, 5, 2, 3, 6, 8, 9, 0 }; MergeSort<int>(arr, 0, 10); PrintArr<int>(arr, 10); }
