1 选择排序
选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小(大)元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。
- 稳定性：不稳定
- 时间复杂度：
- 空间复杂度：
void SelectSort(int r[],int n){//简单选择
int index,i;
for(i=0;i index = i;
for(int j=i+1;j if(r[j] index = j;
}
}
if(index!=i){
int temp = r[i];
r[i] = r[index];
r[index] = temp;
}
}
}
2 插入排序
直接插入排序
每一趟将一个待排序的记录，按其关键字的大小插入到已经排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。
void InsertSort(int r[],int n){//直接插入排序
int j=0;
for(int i=2;i r[0]=r[i]; //哨兵
for(j=i-1;r[0] r[j+1]=r[j];
}
r[j+1]=r[0];
}
}- 稳定性：稳定
- 时间复杂度：
- 空间复杂度：
折半插入排序
折半插入排序(binary insertion sort)是对插入排序算法的一种改进，由于排序算法过程中，就是不断的依次将元素插入前面已排好序的序列中。由于前半部分为已排好序的数列，这样我们不用按顺序依次寻找插入点，可以采用折半查找的方法来加快寻找插入点的速度。
void BinSort(int r[],int n){//折半插入排序
int low,high,mid;
for(int i=2;i r[0]=r[i];
low=1;
high=i-1;
while(low<=high){
mid =(low+high)/2;
if(r[0] high = mid-1;
}else{
low = mid+1;
}
}
for(int j=i-1;j>=high+1;j--){
r[j+1]=r[j];
}
r[high+1]=r[0];
}
}- 稳定性：稳定
- 时间复杂度：
- 空间复杂度：
3 冒泡排序
冒泡排序(Bubble Sort)，是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序(如从大到小、首字母从Z到A)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列)，就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
- 稳定性：稳定
- 时间复杂度：
- 空间复杂度：
void BubbleSort(int r[],int n){//冒泡排序
int temp;
for(int i=0;i-1;i++){for(int j=0;j-1;j++){if(r[j]>r[j+1]){
temp = r[j];
r[j]=r[j+1];
r[j+1]=temp;
}
}
}
}4 希尔排序
希尔排序(Shell's Sort)是插入排序的一种，又称“缩小增量排序”(Diminishing Increment Sort)，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因 D.L.Shell 于 1959 年提出而得名。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止。
- 稳定性：不稳定
- 时间复杂度：到
- 空间复杂度：
void ShellSort(int r[],int n){//希尔排序
int j=0;
for(int d =n/2;d>=1;d=d/2){//以增量为d进行直接插入排序
for(int i=d+1;i r[0]=r[i];
for(j=i-d;j>0&&r[0] r[j+d]=r[j];
}
r[j+d]=r[0];
}
}
}
5 归并排序
归并排序(Merge Sort)是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
- 稳定性：稳定
- 时间复杂度：
- 空间复杂度：
void merge(int a[],int n,int left,int mid,int right){
int n1=mid-left,n2=right-mid;
int *L = new int[n1+1];
int *R = new int[n2+1];
for(int i=0;i L[i]=a[left+i];
for(int i=0;i R[i]=a[mid+i];
L[n1]=10000000;
R[n2]=10000000;
int i=0,j=0;
for(int k=left;k {
if(L[i]<=R[j])
a[k]=L[i++];
else
a[k]=R[j++];
}
delete[] L;
delete[] R;
}
void MergeSort(int a[],int n,int left,int right){
if(left+1 {
int mid=(left+right)/2;
MergeSort(a,n,left,mid);
MergeSort(a,n,mid,right);
merge(a,n,left,mid,right);
}
}
6 快速排序
快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略。
该方法的基本思想是：
1．先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。
稳定性：不稳定
时间复杂度：
空间复杂度：
int Partition(int r[],int first,int end){//快速排序一次划分算法
int i=first,j=end;
int temp;
while(i while(i j--;
if(i temp = r[i];
r[i] = r[j];
r[j] = temp;
}
while(i i++;
if(i temp = r[i];
r[i] = r[j];
r[j] = temp;
j--;
}
}
return i;
}
void QuickSort(int r[],int first,int end){
if(first int pivot = Partition(r,first,end);
QuickSort(r,first,pivot-1);
QuickSort(r,pivot+1,end);
}
}
7 堆排序
堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为，它也是不稳定排序。首先简单了解下堆结构。
堆排序的基本思想是：将待排序序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根节点。将根节点与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个大顶堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列。
- 稳定性：不稳定
- 时间复杂度：
- 空间复杂度：
// 堆排序
void HeapAdjust(int a[],int s,int m)//一次筛选的过程{
int rc,j;
rc=a[s];
for(j=2*s+1;j<=m;j=j*2+1)//通过循环沿较大的孩子结点向下筛选
{
if(j1]) j++;//j为较大的记录的下标if(rc>a[j]) break;
a[s]=a[j];s=j;
}
a[s]=rc;//插入
}void HeapSort(int a[],int n){int temp,i,j;//找最接近的点int s =0;while(2*s+1 s++;
}for(i=s;i>=0;i--)//通过循环初始化顶堆
{
HeapAdjust(a,i,n);
}for(i=n;i>=0;i--)
{
temp=a[0];
a[0]=a[i];
a[i]=temp;//将堆顶记录与未排序的最后一个记录交换
HeapAdjust(a,0,i-1);//重新调整为顶堆
}
}8 基数排序
基数排序(radix sort)属于“分配式排序”(distribution sort)，又称“桶子法”(bucket sort)或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。
- 稳定性：稳定
- 时间复杂度：，其中r为所采取的基数，而m为堆数
- 空间复杂度：
//获取数字的位数
int getLoopTimes(int num){
int count = 1;
int temp = num / 10;
while(temp != 0){
count++;
temp /= 10;
}
return count;
}
//查询数组中的最大数
int findMaxNum(int *p, int n){
int max = p[0];
for(int i = 0; i if(p[i] > max){
max = p[i];
}
}
return max;
}
//将数字分配到各自的桶中，然后按照桶的顺序输出排序结果
void sortSingle(int *p, int n, int loop){
//建立一组桶此处的20是预设的根据实际数情况修改
int buckets[10][20] = {};
//求桶的index的除数
//如798个位桶index=(798/1)%10=8
//十位桶index=(798/10)%10=9
//百位桶index=(798/100)%10=7
//tempNum为上式中的1、10、100
int tempNum = (int)pow(10, loop - 1);
int i, j;
for(i = 0; i int row_index = (p[i]/tempNum) % 10;
for(j = 0; j 20; j++){
if(buckets[row_index][j] == NULL){
buckets[row_index][j] = p[i];
break;
}
}
}
//将桶中的数，倒回到原有数组中
int k = 0;
for(int i = 0; i 10; i++){
for(int j = 0; j 20; j++){
if(buckets[i][j] != NULL){
p[k] = buckets[i][j];
buckets[i][j] = NULL;
k++;
}
}
}
}
void BucketSort(int *p, int n){
//获取数组中的最大数
int maxNum = findMaxNum(p, n);
//获取最大数的位数，次数也是再分配的次数。
int loopTimes = getLoopTimes(maxNum);
//对每一位进行桶分配
for(int i = 1; i <= loopTimes; i++){
sortSingle(p, n, i);
}
}
9 线性查找
在常规无序数组中，设数组项个数为N，则一个数组项平均查找长度为N/2。极端情况下，查找数据项在数组最后，则需要N步才能找到。
- 时间复杂度：
- 空间复杂度：
int findLinear(int* p,int n,int k){
for(int i=0;i if(p[i]==k){
return i;
}
}
//查找失败，返回-1
return -1;
}
10 折半查找
二分查找也称折半查找(Binary Search)，它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。
首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
- 时间复杂度：
- 空间复杂度：看实现方式，递归，非递归
// 折半查找
int BinarySearch(int* p ,int n,int k) {
int low = 0;
int high = n - 1;
int cur;
while(low<=high){
// 取中间值
cur = (low + high) / 2;
// 待查找的值与中间值匹配则返回
if (p[cur] == k) {
return cur;
}else{
// 如果中间值小于待查找的值，则将查找的最小下限值设为中间值下标+1
if (p[cur] low= cur + 1;
} else {// 如果中间值大于待查找的值，则将查找的最大上限值设为中间值下标-1
high = cur - 1;
}
}
}
}
