C++中vector和堆的常用使用方法&例题：数据流中的中位数

vector常用函数：

（1）a.size();//返回a中元素的个数；

（2）a.push_back(5);//在a的最后一个向量后插入一个元素，其值为5

（3）a[i]; //返回a的第i个元素，当且仅当a[i]存在

（4）a.empty();//判断a是否为空，空则返回ture,不空则返回false

（5）a.clear();//清空a中的元素

（6）a.back();//返回a的最后一个元素

（7）a.erase(a.begin()+1,a.begin()+3);//删除a中第1个（从第0个算起）到第2个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+3（不包括它）

（8）a.insert(a.begin()+1,5);//在a的第1个元素（从第0个算起）的位置插入数值5，如a为1,2,3,4，插入元素后为1,5,2,3,4

（9）a.insert(a.begin()+1,3,5);//在a的第1个元素（从第0个算起）的位置插入3个数，其值都为5

（10）a.insert(a.begin()+1,b+3,b+6);//b为数组，在a的第1个元素（从第0个算起）的位置插入b的第3个元素到第5个元素（不包括b+6），如b为1,2,3,4,5,9,8，插入元素后为1,4,5,9,2,3,4,5,9,8

（11）a.pop_back();//删除a向量的最后一个元素

（15）a.capacity();//返回a在内存中总共可以容纳的元素个数

添加：vector作为形参时的使用方法

1.fun(vector<int>a) //传值

调用：fun(a) 

发生拷贝构造 

2.fun(vector<int>&a)//传引用

fun(a)

不发生拷贝构造（改变原有vector）

3.fun(vector<int>*a)//传指针

fun(&a)

不发生拷贝构造（改变原有vector）

2,3区别不知道。。。只是引用指针区别？ 知道了再改

堆常用函数：

1.先建立vector<int> nums = {9, 6, 2, 4, 7, 0, 1, 8, 3, 5};

make_heap(nums.begin(), nums.end(), less<int>());（堆首为最大值）

或make_heap(nums.begin(), nums.end(), greater<int>());(堆首为最小值）

2.更新堆（貌似不建立，直接push——heap也行）

nums.push_back(10);

push_heap(nums.begin(), nums.end(), less<int>());

3.删除堆首元素：pop_heap()  注意：先pop_heap()，vector后pop_back()：

pop_heap(nums.begin(), nums.end(), less<int>())；

nums.pop_back();

原理：堆其实就是把vector内的元素最大值或最小值转移到nums[0]上。而pop_heap()是将nums[0]放到堆尾部，继而调用vector清除队尾

问题：push_heap()并没有传递指针这一类的东西，怎么做到改变vector的？nums.begin()传的可能是地址？

最后附上一道剑指offer题目：数据流中的中位数

void Insert(int num)
    {
        int k=max.size()+min.size();
        //数组进前两个元素
        if(k<2){
            //max.push_back(num);
            //前两个不需要建堆
            if(k==0){
                max.push_back(num);
            }
            if(k==1){
                if(num>max[0]){
                    int tmp;
                    tmp=max[0];
                    max[0]=num;
                    min.push_back(tmp);
                    return;
                }
                min.push_back(num);
            }
        }
        //自前两个元素开始//保证大堆永远仅比小堆大1或0
        //所有元素判断是否比小堆（从大到小3 2 1）min[0]还小，小的话进小堆，通过倾倒机制保证小堆一直比大堆小0或1
        //若不比小堆min[0]小，则 进大堆（从小到大4 5 6），大堆有倾倒机制保证大堆一直比小堆大0或1
        //倾倒机制：（若大堆元素比小堆大两个则分一个给小堆，或小堆比大堆大时把min[0]放入大堆)
        if(k>1){
            //元素判断是否比小堆（从大到小3 2 1）min[0]还小
            if(num<min[0]){
                //小的话开始处理
                min.push_back(num);
                int flag=min.size()-max.size();
                if(flag>0){
                    //把min[0]拿到max[0]位置上了
                    max.push_back(min[0]);
                    pop_heap(min.begin(),min.end(),less<int>());
                    min.pop_back();
                    push_heap(max.begin(),max.end(),greater<int>());
                }
            }
            //不小则进大堆通过倾倒机制分配
            else{
                max.push_back(num);
                push_heap(max.begin(),max.end(),greater<int>());
                int pool=max.size()-min.size();
                if(pool>1){
                    //当max数量较min大2时，开始倾倒
                    min.push_back(max[0]);
                    pop_heap(max.begin(),max.end(),greater<int>());
                    max.pop_back();
                    push_heap(min.begin(),min.end(),less<int>());
                }
            }
            return;
        }
    }

    double GetMedian()
    {
        int k1=max.size();
        int k2=min.size();
        //大堆比小堆多1时。直接返回max[0]
        if(k1>k2){
            return max[0];
        }
        else{
            double avg=(max[0]+min[0])/2.0;
            return avg;
        }
    }
    vector<int>max;
    vector<int>min;

 内容参考：

1.https://www.jianshu.com/p/13a56502e217

2.https://blog.csdn.net/rxm1989/article/details/39549689

3.https://www.nowcoder.com/ta/coding-interviews?asc=true&order=difficulty