常用排序与查找算法大全

1 选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

• 稳定性：不稳定
• 时间复杂度：$O(n^2)$
• 空间复杂度：$O(1)$

void SelectSort(int r[],int n){//简单选择
    int index,i;
    for(i=0;i<n;i++){
        index = i;
        for(int j=i+1;j<n;j++){
            if(r[j]<r[index]){
                index = j;
            }
        }
        if(index!=i){
            int temp = r[i];
            r[i] = r[index];
            r[index] = temp;
        }
    }
}

2 插入排序

• 直接插入排序

  每一趟将一个待排序的记录，按其关键字的大小插入到已经排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。

  • 稳定性：稳定
  • 时间复杂度：$O(n^2)$
  • 空间复杂度：$O(1)$

  void InsertSort(int r[],int n){//直接插入排序
      int j=0;
      for(int i=2;i<n;i++){
          r[0]=r[i];          //哨兵
          for(j=i-1;r[0]<r[j];j--){
              r[j+1]=r[j];
          }
          r[j+1]=r[0];
      }
  }
  

• 折半插入排序

  折半插入排序（binary insertion sort）是对插入排序算法的一种改进，由于排序算法过程中，就是不断的依次将元素插入前面已排好序的序列中。由于前半部分为已排好序的数列，这样我们不用按顺序依次寻找插入点，可以采用折半查找的方法来加快寻找插入点的速度。

  • 稳定性：稳定
  • 时间复杂度：$O(n^2)$
  • 空间复杂度：$O(1)$

  void BinSort(int r[],int n){//折半插入排序
      int low,high,mid;
      for(int i=2;i<n;i++){
          r[0]=r[i];
          low=1;
          high=i-1;
          while(low<=high){
              mid =(low+high)/2;
              if(r[0]<r[mid]){
                  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）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

• 稳定性：稳定
• 时间复杂度：$O(n^2)$
• 空间复杂度：$O(1)$

void BubbleSort(int r[],int n){//冒泡排序
    int temp;
    for(int i=0;i<n-1;i++){
        for(int j=0;j<n-i-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 时，整个文件恰被分成一组，算法便终止。

• 稳定性：不稳定
• 时间复杂度：$O(n^1.3)$到$O(n^2)$
• 空间复杂度：$O(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<n;i++){
            r[0]=r[i];
            for(j=i-d;j>0&&r[0]<r[j];j=j-d){
                r[j+d]=r[j];
            }
            r[j+d]=r[0];
        }
    }
}

5 归并排序

归并排序（Merge Sort）是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

• 稳定性：稳定
• 时间复杂度：$O(nlogn)$
• 空间复杂度：$O(n)$

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<n1;i++)
        L[i]=a[left+i];
    for(int i=0;i<n2;i++)
        R[i]=a[mid+i];
    L[n1]=10000000;
    R[n2]=10000000;
    int i=0,j=0;
    for(int k=left;k<right;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<right)
    {
        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．再对左右区间重复第二步，直到各区间只有一个数。

• 稳定性：不稳定

• 时间复杂度：$O(nlogn)$

• 空间复杂度：$O(logn)$

int Partition(int r[],int first,int end){//快速排序一次划分算法
    int i=first,j=end;
    int temp;
    while(i<j){
        while(i<j&&r[i]<r[j])
            j--;
        if(i<j){
            temp = r[i];
            r[i] = r[j];
            r[j] = temp;
        }
        while(i<j&&r[i]<r[j])
            i++;
        if(i<j){
            temp = r[i];
            r[i] = r[j];
            r[j] = temp;
            j--;
        }
    }
    return i;
}

void QuickSort(int r[],int first,int end){
    if(first<end){
        int pivot = Partition(r,first,end);
        QuickSort(r,first,pivot-1);
        QuickSort(r,pivot+1,end);
    }
}

7 堆排序

堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为$O(nlogn)$，它也是不稳定排序。首先简单了解下堆结构。

堆排序的基本思想是：将待排序序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根节点。将根节点与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个大顶堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列。

• 稳定性：不稳定
• 时间复杂度：$O(nlogn)$
• 空间复杂度：$O(1)$

// 堆排序
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(j<m&&a[j]<a[j+1]) 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<n){
        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®m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。

• 稳定性：稳定
• 时间复杂度：$O(nlog(r)m)$，其中r为所采取的基数，而m为堆数
• 空间复杂度：$O(n)$

//获取数字的位数
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 < n; 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 < n; 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步才能找到。

• 时间复杂度：$O(n)$
• 空间复杂度：$O(1)$

int findLinear(int* p,int n,int k){
    for(int i=0;i<n;i++){
        if(p[i]==k){
            return i;
        }
    }
    //查找失败，返回-1
    return -1;
}

10 折半查找

二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。

首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

• 时间复杂度：$O(logn)$
• 空间复杂度：看实现方式，递归$O(logn)$，非递归$O(1)$

// 折半查找
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] < k) {
                low= cur + 1;
            } else {// 如果中间值大于待查找的值，则将查找的最大上限值设为中间值下标-1
                high = cur - 1;
            }
        }
    }
}