第二章-vector

二分法查找

版本A

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

int binaSearch(int e, vector<int> vec) {
    int lo = 0, hi = vec.size();
    while (lo<hi)
    {
        int mid = (lo + hi) >> 1;
        cout << vec[mid] << endl;
        if (e < vec[mid])
            hi = mid;
        else if (e > vec[mid])
            lo = mid+1;
        else
            return mid;
    }
    return -1;
}

int main()
{
    vector<int> vec = {0,1,2,3,4,5,6,7,8,9,10};
    cout<< binaSearch(11, vec)<<endl;
    system("pause");
    return 0;
}

如何理解lo = mid+1？
假如为lo = mid则会陷入死循环中。
一种理解方式：因为区间范围是左闭右开，既然已经判断e>vec[mid]，说明已经排除mid的值，所以lo应从mid+1处开始。
为什么会陷入死循环？
在找不到的情况下会陷入死循环。假如找不到某个值，随着程序的运行hi-lo的值会逐渐减为1，此时经过计算的mid等于lo，vec[lo]中保存区间较小的值，因而会进入e > vec[mid]的分支中，进而执行lo = mid，由此进入死循环，此时lo的索引为小于e的值中最大的那个。

版本二A
特点：平衡判断的成本，使得在最坏情况下效果好于版本一，但最好的情况下不如版本一，因为版本一找到值就返回mid，而这种算法必须运行完整个while循环。

int binaSearch(int e, vector<int> vec) {
    int lo = 0, hi = vec.size();
    while (hi-lo>1)
    {
        int mid = (lo + hi) >> 1;
        cout << vec[mid] << endl;
        if (e < vec[mid])
            hi = mid;
        else 
            lo=mid;
    }
    return vec[lo]==e?lo:-1;
}

版本二B（斐波拉契搜索）：
因为判断为true的成本更小，所以给它分配更大的空间。数据的空间大小取做大于它中最小的f(k)-1，以f(k-1)-1为分割点。{f(k-1)-1}/{f(k)-1}约等于黄金分割比。

//0 1   2   3   4   5
//0 1   1   2   3   4
int  fib(int n) {
    int a = 0, b = 1;
    while (0 < n--) {
        a += b;
        b = a - b;
    }
    return a;
}
//返回大于nearest的fib数列中最小的一个
int  preFib(int near) {
    int a = 0, b = 1;
    while (true) {
        if (a > near)
            break;
        a += b;
        b = a - b;
    }   
    return b;
}

int fibSearch(int e, vector<int> vec) {
    int lo = 0, hi = vec.size();
    while (hi>lo)
    {
        int mid = lo + preFib(hi - lo)-1;
        if (e < vec[mid])
            hi = mid;
        else if(e>vec[mid])
            lo = mid+1;
        else
            return mid;
    }
    return -1;
}

int main()
{
    vector<int> vec = {0,1,2,3,4,5,6,7,8,9,10};
    cout<< fibSearch(4, vec)<<endl;
    system("pause");
    return 0;
}

版本三：
优点：稳点性好于上述版本，当有多个重复值是返回值最大的那个（有利于降低插入成本）。当没有该值，-1处有负的无穷大的哨兵，返回值为小于该值中最大的那个值得索引。始终为了insert(1+search(e),e)服务。

int binaSearch(int e, vector<int> vec) {
    int lo = 0, hi = vec.size();
    while (hi>lo)
    {
        int mid = (lo + hi) >> 1;
        cout << vec[mid] << endl;
        if (e < vec[mid])
            hi = mid;
        else 
            lo=mid+1;
    }
    return --lo;
}

冒泡排序

时间复杂度O(n2)

版本一

void bubbleSort(vector<int> &vec) {
    bool sorted = false;
    while (!sorted) {
        sorted = true;
        for (int i =1; i < vec.size(); i++) {
            if (vec[i - 1] > vec[i])
            {
                swap(vec[i - 1], vec[i]);
                sorted = false;
            }
        }
    }
}

int main()
{
    vector<int> vec = {10,9,8,7,6,5,4,3,2,1};
    bubbleSort(vec);
    for (auto a : vec)
        cout << a << endl;
    system("pause");
    return 0;
}

版本二

void bubbleSort(vector<int> &vec) {
    bool sorted = false;
    int n = vec.size();
    while (!sorted) {
        sorted = true;
        for (int i =1; i < n; i++) {
            if (vec[i - 1] > vec[i])
            {
                swap(vec[i - 1], vec[i]);
                sorted = false;
            }
        }
        n--;
    }
}

版本三

部分的输入有序，时间复杂度O(n)       

void bubbleSort(vector<int> &vec) {
    int lo = 0, hi = vec.size();
    while (lo<hi)
    {
        int last = lo,ll=lo;
        while (++ll < hi) {
            if (vec[ll] < vec[ll - 1]) {
                last = ll;
                swap(vec[ll], vec[ll - 1]);
            }
        }
        hi = last;
    }
}

归并排序

先分再和，重点在和
时间复杂度O(nlogn)
分而治之
可用于分布式系统中