二叉树（二）

二叉树的其他操作

利用遍历创建二叉树

前序遍历和中序遍历创建二叉树

TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder){
    return buildT(preorder,inorder,0,preorder.size()-1,0,inorder.size()-1);
}
TreeNode* build(vector<int>& preorder, vector<int>& inorder, int ps,int pe, int is, int ie){
    if(ps>pe) return NULL;
    TreeNode* node=new TreeNode(preorder[ps]);
    int pos=0;
    for(int i=is;i<=ie;i++){
        if(inorder[i]==preorder[ps]){
            pos=i;
            break;
        }
    }
    node->left=buildT(preorder,inorder,ps+1,ps+is-pos;is,pos-1);
    node->right=buildT(preorder,inorder,pe-ie+pos+1,pe,pos+1,ie);
    return node;
}

中序遍历和后序遍历创建二叉树

TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) {
        return buildTree(inorder, postorder, 0, inorder.size()-1,  0, postorder.size()-1);
    }
    TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder, int is, int ie, int ps, int pe) {
        if(is>ie || ps>pe) return NULL;
        TreeNode* node=new TreeNode(postorder[pe]);
        int pos=0;
        for(int i=is;i<=ie;i++){
            if(inorder[i]==postorder[pe]){
                pos=i;
                break;
            }
        }
        node->left=buildTree(inorder,postorder,is,pos-1,ps,ps+pos-is-1);
        node->right=buildTree(inorder,postorder,pos+1,ie,pe-ie+pos,pe-1);
        return node;
    }

最低公共祖先

BT

TreeNode *LCA(TreeNode*root,TreeNode*p,TreeNode*q){
    if(root==NULL || root==p||root==q)
    return root;
    TreeNode* left=LCA(root->left,p,q);
    TreeNode* right=LCA(root->right,p,q);

    if(left&&right) return root;
    return left?left:right;
}

BST

TreeNode * LCAofBST(TreeNode* root,TreeNode* p,TreeNode* q){
    if(root->val>q->val && root->val>p->val)
    return LCAofBST(root->left,p,q);
    else if(root->val<q->val && root->val<p->val)
    return LCAofBST(root->right,p,q);
    else return root;
}

将二叉树拆成单链表

void BTtoList(TreeNode* root){
    while(root){
        if(root->right && root->left){
            TreeNode* temp=root->left;
            while(temp->right){
                temp=temp->right;
            }
            temp->right=root->right;
        }
        if(root->left)
            root->right=root->left;
        root->left=NULL;
        root=root->right;
    }
}

子树

bool isSubtree(TreeNode* T1,TreeNode* T2){
    if(T2==NULL) return false;
    if(T1==NULL) return true;
    return isIdentical(T1,T2) || isSubtree(T1->left,T2) || isSubtree(T1->right,T2);
}
bool isIdentical(TreeNode* T1,TreeNode* T2){
    if(T1==NULL && T2==NULL) return true;
    if(T1==NULL || T2==NULL) return false;
    if(T1->val!=T2->val) return false;
    return isIdentical(T1->left,T2->left) && isIdentical(T1->right,T1->right);
}

二叉树的序列化和反序列化

string serializeBT(TreeNode* root){
    ostringstream out;
    serial(root,out);
    return out.str();
}
TreeNode* deserializeBT(string s){
    istringstream in(s);
    return deserial(s)
}
void serial(TreeNode* root, ostringstream &out){
    if(root){
        out<<root->val<<' ';
        serial(root->left,out);
        serial(root->right,out);
    }
    else out<<"# ";
}
TreeNode* deserial(istringstream &in){
    string s;
    in>>s;
    if(s=="#") return NULL;
    TreeNode *root=new TreeNode(stoi(s));
    root->left=deserial(in);
    root->right=deserial(in);
    return root;
}