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;            }        }    }}