大整数的构建

struct Bigint{
    int fu;//表示数是否是负数
    vector<int>s;
    Bigint(){                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           
        fu=0;
    }
    Bigint(const Bigint& a){                                         
        this->s=a.s;
        this->fu=a.fu;
    } 
    Bigint(string str){
        int dex=0;
        if(str[0]=='-'){
            this->fu=1;
            dex++;
        }else{
            this->fu=0;
        }
        int num=0;                             
        for(;dex<str.size();++dex){
            int n=str[dex]-'0';
            n=num+n;
            if(n>9){
                num=n/10;
                n=n%10;
            }
            s.push_back(n);
        }
        reverse(s.begin(),s.end());//反转方便后面的运算
    }
    Bigint (long long num){
        s.clear();
        do{
            s.push_back(num%10);
            num/=10;
        }while(num>0);
    }
    Bigint (int num){
        s.clear();
        do{
            s.push_back(num%10);
            num/=10;
        }while(num>0);
    }
};

大整数加法（仅考虑了正数相加）

Bigint operator + (Bigint a,Bigint b){
    Bigint c;
    int num=0;
    for(int i=0;i<min(a.s.size(),b.s.size());++i){
        int n=a.s[i]+b.s[i]+num;
        if(n>9){
            num=n/10;
            n=n%10;
        }else{
            num=0;
        }
        c.s.push_back(n);
    }
    if(a.s.size()>b.s.size()){
        for(int i=b.s.size();i<a.s.size();++i){
            int n=a.s[i]+num;
        if(n>9){
            num=n/10;
            n=n%10;
        }else
        {
            num=0;
        }
        c.s.push_back(n);
        }
    }else{
        for(int i=a.s.size();i<b.s.size();++i){
            int n=b.s[i]+num;
        if(n>9){
            num=n/10;
            n=n%10;
        }else{
            num=0;
        }
        c.s.push_back(n);
        }
    }
    if(num!=0)
    c.s.push_back(num);
    return c;
}
void operator += (Bigint& a,Bigint& b){
    a.s=(a+b).s;
}

大整数比较（先比较长度，在反向比较大小）

bool operator>(Bigint& a,Bigint& b){
    if(a.s.size()>b.s.size()){
        return true;
    }else if(a.s.size()<b.s.size()){
        return false;
    }else{
        int dex=a.s.size()-1;
        while(dex!=0&&a.s[dex]==b.s[dex]){
            dex--;
        }
        if(dex<=0)
        return false;
        if(a.s[dex]>b.s[dex]){
            return true;
        }else
        return false;
    }
}
bool operator ==(Bigint& a,Bigint& b){
    if(a.s.size()!=b.s.size()){
        return false;
    }
    else{
        int dex=a.s.size()-1;
        while(dex!=0&&a.s[dex]==b.s[dex]){
            dex--;
        }
        if(dex<0)
        return true;
        else
        return false;
    }
}
bool operator<(Bigint &a,Bigint &b){
    return b>a;
}

减法（与加法相同）

Bigint operator -(Bigint&a ,Bigint& b){
    if(a<b){
        Bigint c(b-a);
        c.fu=1;
        return c;
    }
    Bigint c; 
    int num=0;
    for(int i=0;i<b.s.size();++i){
        int n=a.s[i]-b.s[i]+num;
        
        if(n<0){
            num=-1;
            n=10+n;
        }else{
            num=0;
        }
        c.s.push_back(n);
    }
    int dex=b.s.size();
    for(;dex<a.s.size();++dex){
        int n=a.s[dex]+num;
        if(n<0){
            num=-1;
            n=10+n;
        }else{
            num=0;
        }
        c.s.push_back(n);
    }
    return c;
}

乘法（一个一个的数相乘，再相加）

Bigint operator*(Bigint a,Bigint b){
    Bigint c("0");
    for(int i=0;i<b.s.size();++i){
        string s="";
        int n=b.s[i];
        int num=0;
        for(int j=0;j<a.s.size();++j){
            n=b.s[i]*a.s[j]+num;
            if(n>9){
                num=n/10;
                n=n%10;
            }else{
                num=0;
            }
            s+=char(n+'0');
        }
        if(num!=0)
        s+=char(num+'0');
        reverse(s.begin(),s.end());
        for(int j=0;j<i;++j){
            s+="0";
        }
        Bigint tmp(s);
        c+=tmp;
    }
    return c;
}
void operator*=(Bigint& a,Bigint& b){
    a.s=(a*b).s;
}

输出（注意反向输出与前导0的问题）

ostream& operator << (ostream &out,const Bigint&x){
    if(x.fu){
        out<<'-';
    }
    int i=x.s.size()-1;
    while(x.s[i]==0&&i>0){
        i--;
    }//去除前导0
    for(;i>=0;--i){
        out<<x.s[i];
    }
    return out;
}

-------------------------------------------------------------------------------

树的构建和打印

struct node {
    int val;
    node* left;
    node* right;
    node() {
        val = 0;
        left = NULL;
        right = NULL;
    }
};//树的构建
void treeprint(node* head, int lev) {
    if (head == NULL) {
        return;
    }
    treeprint(head->right, lev + 1);
    for (int i = 0; i < lev; ++i) {
        cout << "\t";
    }
    cout << head->val << endl;
    treeprint(head->left, lev + 1);
}//打印树

树的三种遍历

void dfs(node* head) {
    if (head == NULL) {
        return;
    }
        //这里打印为先序（头左右）
    dfs(head->left);
        //这里为中序（左头右）
    dfs(head->right);
        //这里为后序（左右头）
}

树的横向遍历（宽度遍历）

 1 void bfs(node* head) {
 2     queue<node*>q;
 3     q.push(head);
 4     while (!q.empty()) {
 5         node* tmp = q.front();
 6         q.pop();
 7         if (tmp->left != NULL) {
 8             q.push(tmp->left);
 9         }
10         if (tmp->right != NULL) {
11             q.push(tmp->right);
12         }
13     }
14 }

根据先序中序或后序中序来构建树

原理是先序第一个是头节点，可以在中序查找这个元素，那么以前就是左树，以后就是右树，可以根据递归构建

int in[N];//中序数组
int pre[N];//先序数组
node* creat(int inl, int inr, int prel, int prer) {
    if (prer < prel||inl>inr) {
        return NULL;
    }
    node* head = new node;
    head->val = pre[prel];
    int dex = 0;
    //在中序中查找此元素（可以进行map优化快速查找）
    for (; dex <= inr; ++dex) {
        if (in[dex] == pre[prel])
            break;
    }
    head->left = creat(inl, dex - 1, prel + 1, dex - prel + inl);
    head->right = creat(dex + 1, inr, dex - prel + inl + 1, prer);
    return head;
}