Sort

Overview

O(n^2)

Selection Sort

Insertion Sort

O(nlogn)

Merge Sort

Quick Sort

Selection Sort :O(n^2)

int selectionSort(int a[],int target){
  int min；
  for(int i=1;i<n-1;i++){
    min=a[i]；
    for(int j=i+1;j<n;j++){
      if(a[min]>a[j]){
        min=j；
      }
    }
    swap(a[i]，a[min])；
  }
}

有两个循环

第一个循环是选择数组中当前的值a

第二个循环是找到这个值后面比该数字小的最小的值b记录，当内循环结束后与当前值a做交换

Stable Sorting

稳定性：当序列中存在两个或两个以上的关键字相等的时候，如果排序前序列中1领先于2,那么排序后1如果仍旧领先2的话，则是稳定的。（相等的元素排序后相对位置不变）

不稳定性：当序列中存在两个或两个以上的关键字相等的时候，如果排序前序列中1领先于2,那么排序后1如果落后2的话，则是不稳定的。（相等的元素排序后相对位置发生改变）

插入排序 O(n2 )

void insertSort(int a[])
{
    int length=a.length();
    for (int i = 1; i < length; i++)
    {
        for (int j = i - 1; j >= 0 && a[j + 1] < a[j]; j--)
        {
            swap(a[j], a[j + 1]);
        }
    }
}

当数组有序的时候最好，只需要消耗O(n)

并归排序O(nlogn)

void MergeSort (int arr [], int low,int high) {
    if(low>=high) { return; } // 终止递归的条件，子序列长度为1
    int mid =  low + (high - low)/2;  // 取得序列中间的元素
    MergeSort(arr,low,mid);  // 对左半边递归
    MergeSort(arr,mid+1,high);  // 对右半边递归
    merge(arr,low,mid,high);  // 合并
}
  
void Merge(int arr[],int low,int mid,int high){
    //low为第1有序区的第1个元素，i指向第1个元素, mid为第1有序区的最后1个元素
    int i=low,j=mid+1,k=0;  //mid+1为第2有序区第1个元素，j指向第1个元素
    int *temp=new int[high-low+1]; //temp数组暂存合并的有序序列
    while(i<=mid&&j<=high){
        if(arr[i]<=arr[j]) //较小的先存入temp中
            temp[k++]=arr[i++];
        else
            temp[k++]=arr[j++];
    }
    while(i<=mid)//若比较完之后，第一个有序区仍有剩余，则直接复制到t数组中
        temp[k++]=arr[i++];
    while(j<=high)//同上
        temp[k++]=arr[j++];
    for(i=low,k=0;i<=high;i++,k++)//将排好序的存回arr中low到high这区间
      arr[i]=temp[k];
    delete []temp;//释放内存，由于指向的是数组，必须用delete []
}

快速排序O(nlogn)

根据输入值划分输出

在快速排序的每个步骤中，排列数组的元素，A [s]左侧的所有元素均小于或等于A [s]，A [s]右边的所有元素都大于或等于它。A [s]将在已排序数组中处于最终位置

int partition(int arr[], int left, int right)//找基准数 划分
{
    int i = left + 1 ;
    int j = right;
    int temp = arr[left];
    while(i <= j)
    {
        while (arr[i] < temp)
        {
            i++;
        }
        while (arr[j] > temp )
        {
            j--;
        }
        if (i < j)
            swap(arr[i++], arr[j--]);
        else i++;
    }
    swap(arr[j], arr[left]);
    return j;
}


void quick_sort(int arr[], int left, int right)
{
    if (left > right)
        return;
    int j = partition(arr, left, right);
    quick_sort(arr, left, j - 1);
    quick_sort(arr, j + 1, right);
}

Choosing the right sorting algorithm

①If your array has relatively few entries, or if it is nearly sorted, the insertion sort is a good choice

顺序几乎排好，则选择插入排序

②Merge and Quick sorting algorithms is smaller scalable for larger input

数字较大的时候，合并和快速排序算法可扩展性强

③Quick sort is the fastest on average

快速排序平均速度是最快的