排序算法
选择排序
简介：
选择排序（Selection sort）是一种简单直观的排序算法。
基本思想：
1、选择一个元素与其之后的元素进行比较，选出最小值。
2、对剩下的元素重复第一步。
demo:
#include <iostream> #include <algorithm> using namespace std; int SelectionSort(int array[], int len) { int minIdex = -1; if (array == NULL) return -1; for (int i = 0; i < len; i++) { minIdex = i; for (int j = i + 1; j < len; j++) { if (array[j] < array[minIdex]) minIdex = j; } swap(array[i], array[minIdex]); } return 0; } int main() { int array[] = { 2, 9, 45, 1, 77, 32 }; SelectionSort(array, sizeof(array) / sizeof(*array)); for_each(begin(array), end(array), [](int data){cout << data << " "; }); system("pause"); }
插入排序
简介：
插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。
基本思想：
1、选择一个元素与其之前的元素比较，若比之前原数大则直接插入至原位，否则比之大的元素后移。
2、对剩下的元素重复第一步。
demo:
#include <iostream> #include <algorithm> using namespace std; int InertionSort(int array[], int len) { if (array == NULL) return -1; for (int i = 1, index, tmp; i < len; i++) { index = i; tmp = array[index]; for (int j = i - 1; (j >= 0) && (array[j]>tmp);j--) { array[j + 1] = array[j]; index = j; } array[index] = tmp; } return 0; } int main() { int array[] = { 2, 9, 45, 1, 77, 32 }; InertionSort(array, sizeof(array) / sizeof(*array)); for_each(begin(array), end(array), [](int data){cout << data << " "; }); system("pause"); }
冒泡排序
简介：
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
基本思想：
1、相邻元素进行比较，冒泡出一个最小值或最大值。
2、对剩下的元素重复第一步。
改进：
若第一步没有进行元素交换，则排序已完成。
demo:
int BubbleSort() { int exchange = 0;//0代表已排好序，1代表没有排好序 for (int i = 0; i < len; i++) { for (int j = len - 1; j > i; j--) { if (elem[j] < elem[j - 1]) { swap(elem[j], elem[j - 1]); exchange = 1; } } if (0 == exchange) break; } return 0; }
希尔排序
简介：
希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。
基本思想：
1、算出步长，将数组分组。
2、对各组进行直接插入排序。
3、重复第一步和第二步，直至步长为1。
demo:
#include <iostream> #include <algorithm> using namespace std; int ShellSort(int array[], int len) { int gap = len; if (array == NULL) return -1; do { gap = gap / 3 + 1; for (int i = gap, tmp; i < len; i++) { tmp = array[i]; int j; for (j = i - gap; j >= 0 && array[j] > tmp; j -= gap) array[j + gap] = array[j]; array[j + gap] = tmp; } } while (gap > 1); return 0; } int main() { int array[] = { 49, 38, 65, 97, 76, 13, 27, 48, 55, 4 }; ShellSort(array, sizeof(array) / sizeof(*array)); for_each(begin(array), end(array), [](int data){cout << data << " "; }); system("pause"); }
快速排序
简介：
快速排序（Quicksort）是对冒泡排序的一种改进。
基本思想：
1、先从数列中取出一个数作为基准数。
2、把数组分为两部分，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3、再对左右区间重复第二步，直到各区间只有一个数，即排序完成。
demo:
第一次分区
|
|||||
原始数组
|
low
|
|
|
|
high
|
21
|
100
|
7
|
4
|
48
|
|
第一次比较
|
low
|
|
|
high
|
|
21
|
100
|
7
|
4
|
48
|
|
第一次交换
|
low
|
|
|
high
|
|
4
|
100
|
7
|
21
|
48
|
|
第二次比较
|
|
low
|
|
high
|
|
4
|
100
|
7
|
21
|
48
|
|
第二次交换
|
|
low
|
|
high
|
|
4
|
21
|
7
|
100
|
48
|
|
第三次比较
|
|
low
|
high
|
|
|
4
|
21
|
7
|
100
|
48
|
|
第三次交换
|
|
low
|
high
|
|
|
4
|
7
|
21
|
100
|
48
|
|
第四次比较
|
|
|
low high
|
|
|
4
|
7
|
21
|
100
|
48
|
|
第二次分区
|
|||||
原始数组
|
low
|
high
|
原始数组
|
low
|
high
|
4
|
7
|
100
|
48
|
||
第一次比较
|
low high
|
|
第一次交换
|
low
|
high
|
4
|
7
|
48
|
100
|
||
第一次交换
|
low high
|
|
第一次比较
|
|
low high
|
4
|
7
|
48
|
100
|
||
#include <iostream> #include <algorithm> using namespace std; int PoatitionTwoPart(int array[], int low, int high) { int pv = array[low]; while (low < high) { while ((low < high) && (array[high] >= pv)) high--; if (low != high) swap(array[low], array[high]); while ((low < high) && (array[low] <= pv)) low++; if (low != high) swap(array[low], array[high]); } return low; } int QSort(int array[], int low, int high) { if (array == NULL) return -1; if (low < high) { int pivot = PoatitionTwoPart(array, low, high); QSort(array, low, pivot - 1); QSort(array, pivot + 1, high); } return 0; } int main() { int array[] = { 21, 100, 7, 4, 48 }; QSort(array, 0, sizeof(array) / sizeof(*array) - 1); for_each(begin(array), end(array), [](int data){cout << data << " "; }); system("pause"); return 0; }
二路归并排序
简介：
归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。二路归并排序是将两个按值有序序列合并成一个按值有序序列。
基本思想：
1、将数组一分为二，并且递归此步骤， 直至分解为单个元素一组。
2、将二组合并为一组有序序列，递归返回后形成一组有序序列。
demo:
#include <iostream> #include <algorithm> using namespace std; void Merge(int src[], int des[], int low, int mid, int high) { int lowIndex = low; int midIndex = mid + 1; int desIndex = low; while ((lowIndex <= mid) && (midIndex <= high)) //选择大的元素放入 src[lowIndex] < src[midIndex] ? des[desIndex++] = src[lowIndex++] : des[desIndex++] = src[midIndex++]; while (lowIndex <= mid) //将剩下的元素放入 des[desIndex++] = src[lowIndex++]; while (midIndex <= high) des[desIndex++] = src[midIndex++]; } void Msort(int src[], int des[], int low, int high, int max) { if (low == high) des[low] = src[low]; else { int mid = (low + high) >> 1; int *space = (int *)malloc(sizeof(int)* max); if (space != NULL) { Msort(src, space, low, mid, max); Msort(src, space, mid + 1, high, max); Merge(space, des, low, mid, high); } free(space); } } int MergeSort(int array[], int len) { if (array == NULL) return -1; Msort(array, array, 0, len - 1, len); return 0; } int main() { int array[] = { 52, 23, 80, 36, 68, 14 }; MergeSort(array, sizeof(array) / sizeof(*array)); for_each(begin(array), end(array), [](int data){cout << data << " "; }); system("pause"); }
