八大基本排序
一、时间复杂度与空间复杂度
二、原理与代码
1、直接插入排序
1）原理：从序列第二个数开始，将一个数插入到前面已经排序好的序列，记录数加一，以此类推。
2）代码：
//直接插入 void insertSort(int a[],int n) { int temp; for (int i = 1; i < n; i++) { for (int j = i; j > 0; j--) { if (a[j] < a[j - 1]) { temp = a[j]; a[j] = a[j - 1]; a[j - 1] = temp; } } } }
2、冒泡排序
1）原理：
（1）比较第一个数和第二个数的大小，若前一个大于后一个，则交换；
（2）接着比较第二个和第三个，以此类推，一轮比较完，得到最大的数放在最后面；
（3）接着下一轮比较，重复（1）（2）操作，直到最后全部排序完
2）代码：
//冒泡排序 void bubbleSort(int a[], int n) { int temp; for (int i = 0; i < n; i++) { for (int j = 0; j <n-1; j++) { if (a[j] > a[j + 1]) { temp = a[j]; a[j] = a[j + 1]; a[j + 1] = temp; } } } }
3、直接选择排序
1）原理：找到最小的数放到序列的最前面，与冒泡排序相比，大大减少了交换次序
2）代码：
//直接选择排序 void sort8(int a[], int n) { for (int i = n-1; i > 0; i--) {for (int j = 0; j <= i; j++) { if (a[j] > a[0]) {
swap(a[j],a[0]); } }
swap(a[0],a[i]); } }
4、堆排序
1）原理：将序列转换为一颗完全二叉树，通过结点与孩子结点的大小比较，最后转换为小顶堆（或者大顶堆）
假设序列为n的序列组，具体步骤如下：
（1）取中间数mid=n/2,从序号为mid的数开始，比较该结点与孩子结点的大小，若孩子结点比父结点大，则交换；
（2）记录数减一，重复（1）（2）操作，直到得到大顶堆；
（3）交换第一个数和最后一个数，序列组长度减一，重复（1）（2）操作，直到全部排序完成。
2）代码：
//堆排序 void heapSort(int a[],int n) { int temp; for (int i = n; i > 0; i--) { pileSort(a,i); temp = a[0]; a[0] = a[i-1]; a[i-1] = temp; } } void pileSort(int a[],int n) { int mid = n / 2; int temp; for (int i = mid; i >= 0; i--) { if (a[i] < a[2 * i + 1] && 2 * i + 1 < n) { temp = a[i]; a[i] = a[2 * i + 1]; a[2 * i + 1] = temp; } if (a[i] < a[2 * i + 2] && 2 * i + 2 < n) { temp = a[i]; a[i] = a[2 * i + 2]; a[2 * i + 2] = temp; } } }
5、希尔排序
1）原理：希尔排序又名缩小增量排序，直接插入排序在序列大部分有序的情况下，效率会非常高，希尔排序则是为了实现这一点，该排序是先把序列划分为若干个子序列，使用直接排序进行排序，最后序列基本有序后再对整个序列进行一次直接插入排序。
2）代码：
//希尔 void shellSort(int a[], int n) { int length = n; while (length > 1) { length = length / 2; for (int i = 0; i < length; i++) { for (int j = i + length; j < n; j = j + length) { int temp = a[j]; int k; for (k = j - length; k >= 0 && a[k] > temp; k = k - length) { a[k + length] = a[k]; } a[k + length] = temp; } } } }
6、快速排序
1）原理：每次操作都找出数据索引位置，形成左边的数都比这个数小，右边的数都比这个数大，再把左边的序列重复该操作，右边的序列也重复该操作。
2）代码：
void quickSort(int a[], int left,int right) { int mid; if (left < right) { mid = partition(a,left,right); quickSort(a, left, mid-1); quickSort(a, mid+1, right); } } int partition(int a[],int left,int right) { int data = a[left]; while (left < right) { while (a[right] >= data && left < right) { right--; } a[left] = a[right]; while (a[left] <= data && left < right) { left++; } a[right] = a[left]; } a[left] = data; return left; }
7、基数排序
1）原理：桶排序的拓展，将整数按位数切分为不同的数字，按每个数的位数比较。
2）代码：
//基排 void baseSort(int a[], int n,int bit) { int c[10][50]; int num = 1; for (int i = 1; i <= bit; i++) { int b[10] = { 0,0,0,0,0,0,0,0,0,0 }; if(i!=1) num = num * 10; for (int j = 0; j < n; j++) { int temp = (a[j] / num) %10; c[temp][b[temp]] = a[j]; b[temp]++; } int m = 0; for (int k = 0; k < 10; k++) { if (b[k] > 0) { int end = b[k]; for (int t = 0; t < end; t++) { a[m] = c[k][t]; m++; } } } } }
8、归并排序
1）原理：该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。
2）代码：
//归并排序 void mergeSort(int a[], int left, int right,int b[]) { int mid = ((right - left) >> 1) + left; if (right <= left) { return; } mergeSort(a, left, mid, b); mergeSort(a, mid + 1, right, b); merge(a,left,right,b); } void merge(int a[],int left,int right,int b[]) { int mid = ((right - left) >> 1) + left; int i = left, j = mid+1,k = left; while (i <= mid && j <= right) b[k++] = a[i] < a[j] ? a[i++] : a[j++]; while (i <= mid) b[k++] = a[i++]; while (j <= right) b[k++] = a[j++]; for (int m = left; m <= right; m++) { a[m] = b[m]; } }
