高级数据结构

并查集

用数组实现简单的并查集：

#include "util.h"
using namespace std;
class DisjointSet{
public:
    DisjointSet(int n){
        for (int i = 0; i < n; ++i) {
            _id.push_back(i);
        }
    }
    int find(int p){
        return _id[p];
    }
    void union_(int p, int q){
        int pid = find(p);
        int qid = find(q);
        if(pid == qid){
            return;
        }
        for (int i = 0; i < _id.size(); ++i) {
            if (_id[i] == pid){
                _id[i] = qid;
            }
        }
    }
private:
    vector<int>_id;//数组中的元素就是下标对应的集合
};
int main(){

    return 0;
}

森林法实现并查集

class DisjointSet{
public:
    DisjointSet(int n){
        for (int i = 0; i < n; ++i) {
            _id.push_back(i);//一个元素的时候，集合就是本身
            _size.push_back(1);
        }
        _count = n;
    }
    //在查找的时候，有个路径的优化
    int find(int p){
        while (p != _id[p]){
            _id[p] = _id[_id[p]];
            p = _id[p];
        }
        return p;
    }
    void union_(int p, int q){
        int i = find(p);
        int j = find(q);
        if (i == j){
            return;
        }
        if (_size[i] < _size[j]){
            _id[i] = j;
            _size[j] += _size[i];
        }
        else{
            _id[j] = i;
            _size[i] += _size[j];
        }
        --_count;
    }
private:
    vector<int>_id;//
    vector<int>_size;//对应的子树的规模
    int _count;//现在有几个朋友圈，几个集合
};

线段数的实现

#include "util.h"
using namespace std;
void build_segment_tree(vector<int>& value, vector<int>& nums, int pos, int left, int right){
    if(left == right){
        value[pos] = nums[left];
        return;
    }
    int mid = (left + right) / 2;
    build_segment_tree(value,nums,pos*2+1,left,mid);
    build_segment_tree(value,nums,pos*2+2,mid+1,right);
    value[pos] = value[pos*2+1] + value[pos*2+2];
}
void print_segment_tree(vector<int>& value, int pos, int left, int right, int layer){
    for (int i = 0; i < layer; ++i) {
        printf("---");
    }
    printf("[%d %d] [%d]",left,right,pos,value[pos]);
    if (left == right){
        return;
    }
    int mid = (left + right) / 2;
    print_segment_tree(value,pos*2+1,left,mid,layer+1);
    print_segment_tree(value,pos*2+2,mid+1,right,layer+1);
}
int sum_range_segment_tree(vector<int> & value,int pos,int left, int right,int qleft, int qright){
    if(qleft > right || qright < left){
        return 0;
    }
    if(qleft <= left && qright >= right){
        return value[pos];
    }
    int mid = (left + right) / 2;
    return sum_range_segment_tree(value,pos*2+1,left,mid,qleft,qright)
    + sum_range_segment_tree(value,pos*2+2,mid+1,right,qleft,qright);
}
void update_segment_tree(vector<int>& value, int pos, int left, int right,int index, int new_value ){
    if(left == right && left == index){
        value[pos] = new_value;
    }
    int mid = (left + right) / 2;
    if (index <= mid){
        update_segment_tree(value,pos*2+1,left,mid,index,new_value);
    }
    else{
        update_segment_tree(value,pos*2+2,mid+1,right,index,new_value);
    }
    value[pos] = value[pos*2+1] + value[pos*2+2];
}
int main(){

    return 0;
}

字典树

待完善