Bst with particular characteristics; Bst which keeps nodes with multiple interactions at the root

I have to implement a particular type of BST that: keeps the nodes with multiple interactions in the upper part.
In particular:
1 Each time a K key is inserted or searched for in the tree, it is moved to the root (maintaining the property of being a BST), through a succession of ascent operations called CLIMB.
2 If the K element is searched in the FST and is found in a given node N, the CLIMB operation is applied on it. If element K is not present, the operation is applied on the leaf where the search ends.
3 If a node is removed, the CLIMB operation is applied on the parent node of the removed node.

I've been trying to implement it for days but I'm not capable. I thought of an algorithm:
Replace the old root with the new one and hook the old root to the left of the new one, if it is smaller, or to the right if it is larger. Also if it is the old root is smaller than the new one, look for the first largest element of the new root on the right branch of the old root, and move it by hooking it as the new root right branch. Vice versa if it is bigger.

But I can't implement. Can anyone help me?
I am sure that for an expert it is a triviality, but for me it is a nightmare.

It is not the first question I ask about it, in a past question I had also entered the code, however even if it was voted positively nobody was able to answer me, and the code presented now I am aware that it is not the right way.

https://stackoverflow.com/questions/61069856/i-dont-understand-how-to-move-portions-of-a-tree

Help.

Suppose we're calling climb(n). Remove the subtree with n as root from the tree and place it as the new root. Unfortunately we can't place the entire old tree in any child of n and call it a day.

The only thing we can say for sure is that if [l, u] is the range of values stored in the subtree with root n, then all nodes outside of that subtree lie outside of that range. This applies to all subtrees in fact. Here however also the crux with your approach lies: you're assuming that all values in the "old tree" lie on one side of that range, when in fact they can be arranged around that range. I.e. imagine calling climb on the left child of the right child of root (7):

                        5
            3                     8
           ...                7        9
           ...             6             ...

No matter on which side of node 7 you place 5, it'll be wrong. Either 5 or 8 must be misplaced.

Using this fact, we can backtrack from parent(n) until we reach the old root and place all subtrees encountered along the path in the new tree using a standard BST-insert:

climb(n):
    // get the new-root and remove it from the tree rooted at old_root
    old_root = root(n)
    new_root = n
    remove_node(old_root, n)
    
    // iterate ancestors of n up to root
    node = parent(n)
    while node != nil do
        // remove current ancestor (node) from the original tree
        next = parent(node)
        remove_child(parent(node), node)
        
        // insert node into the new tree (all nodes that are still appended remain children of node)
        insert_node(new_root, node)
        node = next
    done

    return new_root

Thanks to the above stated rule about ranges, this will produce a valid BST after each iteration. However in each iteration a new subtree will be added as either right-most child of the right-most leaf or left-most child of the left-most leaf of the tree rooted at new_root, so it might be a good idea to rebalance the subtrees rooted at left_child(new_root) and right_child(new_root), since the tree will become rather imbalanced pretty soon.