在 O(h) 时间复杂度内将二叉搜索树一分为二

Question

I am practicing binary search trees and i have to answer a problem: A tree struct is given as

struct tree{
    int key;
    int lcnt;
    struct tree *lc;
    struct tree *rc;
};

where lcnt is an integer holding the number of the nodes at the left subtree of each node. The problem is to split the tree in half updating every time the lcnt with the valid value. The split algorith must take O(h) time where h is the tree's hight. I found the solution down below and it works for the most trees. But consider now this tree

          170
         /
       45
        \
         30

the result will be: tree1: 170, tree2: 45. I have no idea how to fix it because if i try something like "dont split if the node is a leaf" or something then i have problems with other trees. The split function takes the parameter root which is the root of the primary tree, an integer which is the trees lenght/2 and it returns the 2 new trees. The one with return and the other by reference using a third parameter double pointer tree. I am also using updt function and some calculations to update the lcnt at every split.

the code is here:

struct tree* split(struct tree *root, struct tree **new_tree, int collect){
     struct tree *new_root_1, *new_root_2, *link1=NULL, *link2=NULL;
     struct tree *current=root, *prev=NULL, *temp=NULL;
     if(!root)
         return NULL; //empty tree
     int collected=0, created_root1=0, created_root2=0;
     int decrease;
     while(current!=NULL && collected<collect){
         if(collected+current->lcnt+1<=collect){
             // there is space for the left subtree so take it all and move to the right
             collected=collected+current->lcnt+1;  //update the number of the collected nodes
             if(!created_root1){
                 //create the root for the one tree
                 created_root1=1;
                 new_root_1=current;
                 link1=current;
             }else{
                 link1->rc=current;
                 link1=current;
             }
             if(!created_root2 && collect==collected)
                 //in case the tree must be splited in half
                 new_root_2=current->rc;
             prev=current;
             current=current->rc;
             //break the node link
             prev->rc=NULL;
         }else{
             // there is no space for the left subtree so traverse it until it becomes small enough
             if(!created_root2){
                 //create the root for the second tree
                 created_root2=1;
                 new_root_2=current;
                 link2=current;
             }else{
                 link2->lc=current;
                 // at every link at left the count_total_tasks will help to update the lcnt of the 
                 parent node
                 temp=new_root_2;
                 while(temp!=NULL){
                     temp->lcnt=count_total_tasks(temp->lc);
                     temp=temp->lc;
                 }
                 
                 link2=current;
             }
             prev=current;
             current=current->lc;
 
             //break the node link
             prev->lc=NULL;
             //update the lcnt
             decrease=prev->lcnt;
             updt(new_root_2, decrease);         
         }
     }
     *new_tree=new_root_2;
 
     return new_root_1; 
 }

And this is the updt function:

void updt(struct tree* root, int decrease){
    struct tree *temp;
    temp=root;
    while(temp!=NULL){
    temp->lcnt=temp->lcnt-decrease;
        temp=temp->lc;
    }
}

Answer 1

Your test case,

     170
     /
   45
    \
     30

is not a valid binary search tree.