Question

(20 points) Suppose you are given a binary search tree T of n nodes (as discussed in class. each node v has v.left, v.right, and v.key). We assume that no two keys in T are equal. Given a value x, the rank operation rank() is to return the rank of x in T, which is defined to be one plus the number of keys of T smaller than 2. For example, if T has 3 keys smaller than r, then rank(0) = 4. Note that I may or may not be a key in T. For examples, in Figure 1, rank(16) = 3, rank(21) = 6, rank(25) = 7, rank(26) = 8. Let h be the height of T. We know that I can support the ordinary search, insert, and delete operations, each in O(h) time. You are asked to augment T, such that the rank operation, as well as the normal search, insert, and delete operations, all take O(h) time each. You must present: (1) the design of your data structure (i.e., how you augment T); (2) the algorithm for implementing the rank(x) operation (please give the pseudocode); (3) briefly explain why the operations search, insert, and delete can still be performed in O(h) time each (you do not need to provide the details of these operations).

Answer 1

The implementation is as follows,

class Node:

    def __init__(self, data):

        self.key = data

        self.left = None

        self.right = None

def KSmallestUsingMorris(root, k):

    count = 0

  

    ksmall = -9999999999

    curr = root

  

    while curr != None:

if curr.left == None:

            count += 1

if count == k:

                ksmall = curr.key

curr = curr.right

        else:

pre = curr.left

            while (pre.right != None and

                   pre.right != curr):

                pre = pre.right

if pre.right == None:

                pre.right = curr

                curr = curr.left

            else:

                pre.right = None

  

                count += 1

                if count == k:

                    ksmall = curr.key

          

                curr = curr.right

    return ksmall

### So far we have implemented the ranking part of the BST and the return value is the kth smallest elements if you need to have +1 to it it's totally fine to get the rank instead of the index of the Elem in a sorted form which is required in the question

def insert(node, key):

    if node == None:

        return Node(key)

    if key < node.key:

        node.left = insert(node.left, key)

    elif key > node.key:

        node.right = insert(node.right, key)

    return node

The complexity here is O(h) for a very simple reason that if you want to check the worse case we'll be moving till the end of the tree that is to the leaf node to insert but the problem is regardless of the result of the comparison, we'll get the same result in complexity that is either it goes to the left side or the right we'll go a level down and that can happen in any scenario only 'h' times, which is the height of the tree.

Exactly same analogy works for search and delete as well.

def search(root,key):

    if root is None or root.val == key:

        return root

    if root.val < key:

        return search(root.right,key)

    return search(root.left,key)

def deletion(root, key):

    if root == None :

        return None

    if root.left == None and root.right == None:

        if root.key == key :

            return None

        else :

            return root

    key_node = None

    q = []

    q.append(root)

    while(len(q)):

        temp = q.pop(0)

        if temp.data == key:

            key_node = temp

        if temp.left:

            q.append(temp.left)

        if temp.right:

            q.append(temp.right)

    if key_node :

        x = temp.data

        deleteDeepest(root,temp)

        key_node.data = x

    return root

Hope it helps, if need explaination ask in comments