归并排序

基础：二分法

二分法查找思想：（适用于有序数组）

（1）首先确定整个区间的中间位置 mid = (right - left) / 2 + left;

  (2)   用待查关键字与中间位置关键字值进行比较；

若相等，则查找成功；

若大于，则在后半个区域中继续进行折半查找。

若小于，则在前半个区域中继续进行折半查找。

查找成功，返回关键字所在数组下标，没找到返回 -1；

#include<iostream>
#include<vector>
using namespace std;

int HalfSearch(vector<int>& vec, int target) {
    int L = 0;
    int R = vec.size() - 1;
    while (L <= R) {
        int mid = (R - L) / 2 + L;
        if (target < vec[mid]) {
            R = mid - 1;
        }
        else if (target > vec[mid]) {
            L = mid + 1;
        }
        else {
            return vec[mid];
        }
    }
    return -1;
}

int main() {
    vector<int>vec = { 0,1,2,3,4,5,6,7,8,9 };
    int n = HalfSearch(vec, 8);
    cout << n;
    return 0;
}

时间复杂度：O(logn)

归并排序思想：将两个有序数组合并成一个有序数组。

1、将数组进行分解，当分解成单个元素为一组的时候才是组内有序的（将目标数组拆分成两个数组，设初始数组最小下标为 L,最大下标为 R，控制项 mid = (R - L) / 2 + L,得到两个子数组

{ ( vec[L],...,vec[mid] } 和 { vec[mid+1],...,vec[R] },对两个子数组再次进行拆分递归，递归结束条件：L == R，即单个数值。）

2、将两两有序的数组进行合并，先申请等于两个数组合并后大小的空间，然后将两个排序好的数组逐一比较，向申请的空间中放入较小元素，直至两个有序数组组合成为一个有序数组。重复第二步，直至排序完成。

代码：

#include<iostream>
#include<vector>
using namespace std;

void Merg(vector<int>& vec, int L, int mid, int R) {
    //先申请一个辅助数组大小为 R-L+1
    vector<int>temp(R - L + 1);
    int i = L, j = mid + 1, index = 0;
    //利用while循环比较两个有序数组分别为：L到mid  和 mid+1到R
    while (i <= mid && j <= R) {
        if (vec[i] <= vec[j]) {
            temp[index++] = vec[i++];
        }
        else {
            temp[index++] = vec[j++];
        }
    }
    //经历过上一个步骤一定有剩余元素，利用两个while循环判断
    while (i <= mid) {
        temp[index++] = vec[i++];
    }
    while (j <= R) {
        temp[index++] = vec[j++];
    }
    //将辅助数组中的元素还原到原数组中，还原到对应的位置上L到R
    index = L;
    for (int i = 0; i < temp.size(); i++) {
        vec[index++] = temp[i];
    }
}

void MergSort(vector<int>& vec, int L, int R) {
    if (L >= R)return;
    int mid = (R + L) / 2;
    MergSort(vec, L, mid);
    MergSort(vec, mid + 1, R);
    Merg(vec, L, mid, R);
}

int main() {
    vector<int>vec = { 49,38,65,97,76,13,27};
    MergSort(vec, 0, vec.size() - 1);
    for (auto it : vec) {
        cout << it << " ";
   }
    return 0;
}

平均时间复杂度：O(n*logn)

空间复杂度：O(n)

稳定性：稳定