Find median in binary search tree

Question

Write the implementation of the function T ComputeMedian() const that computes the median value in the tree in O(n) time. Assume that the tree is a BST but is not necessarily balanced. Recall that the median of n numbers is defined as follows: If n is odd, the median is x such that the number of values smaller than x is equal to the number of values greater than x. If n is even, then one plus the number of values smaller than x is equal to the number of values greater than x. For example, given the numbers 8, 7, 2, 5, 9, the median is 7, because there are two values smaller than 7 and two values larger than 7. If we add number 3 to the set, the median becomes 5.

Here is the class of binary search tree node:

template <class T>
class BSTNode
{
public:
BSTNode(T& val, BSTNode* left, BSTNode* right);
~BSTNode();
T GetVal();
BSTNode* GetLeft();
BSTNode* GetRight();

private:
T val;
BSTNode* left;
BSTNode* right;  
BSTNode* parent; //ONLY INSERT IS READY TO UPDATE THIS MEMBER DATA
int depth, height;
friend class BST<T>;
};

Binary search tree class:

template <class T>
class BST
{
public:
BST();
~BST();

bool Search(T& val);
bool Search(T& val, BSTNode<T>* node);
void Insert(T& val);
bool DeleteNode(T& val);

void BFT(void);
void PreorderDFT(void);
void PreorderDFT(BSTNode<T>* node);
void PostorderDFT(BSTNode<T>* node);
void InorderDFT(BSTNode<T>* node);
void ComputeNodeDepths(void);
void ComputeNodeHeights(void);
bool IsEmpty(void);
void Visit(BSTNode<T>* node);
void Clear(void);

private:
BSTNode<T> *root;
int depth;
int count;
BSTNode<T> *med; // I've added this member data.

void DelSingle(BSTNode<T>*& ptr);
void DelDoubleByCopying(BSTNode<T>* node);
void ComputeDepth(BSTNode<T>* node, BSTNode<T>* parent);
void ComputeHeight(BSTNode<T>* node);
void Clear(BSTNode<T>* node);

};

I know I should count the nodes of the tree first and then do an inorder traversal until I reach (n/2)th node and return it. I just have no clue how.

In the case of a list, you'd have to start pointers at both ends and work inwards to find the median. But since your tree is not balanced, the worst case reduces to a linked list. Therefor you cannot avoid doing exactly the same. Start pointers at the min and max values, and alternately compute inorder-successor(min) and inorder-predecessor(max) until the are equal. — BadZen, May 01 '15 at 15:31
@BadZen I am not quite familiar with the "inorder-predecessor".. Could you please explain furthermore? — Nat, May 01 '15 at 15:36

score 9 · Accepted Answer · edited Nov 22 '20 at 09:01

9

As you mentioned, it is fairly easy to first find the number of nodes, doing any traversal:

findNumNodes(node):
   if node == null:
       return 0
   return findNumNodes(node.left) + findNumNodes(node.right) + 1

Then, with an inorder traversal that aborts when the node number is n/2:

// index is a global variable / class variable, or any other variable that is constant between all calls
index=0
findMedian(node):
   if node == null:
       return null
   cand = findMedian(node.left)
   if cand != null:
        return cand
   if index == n/2:
       return node
   index = index + 1
   return findMedian(node.right)

The idea is that in-order traversal processes nodes in BST in sorted manner. So, since the tree is a BST, the ith node you process, is the ith node in order, this is of course also true for i==n/2, and when you find it is the n/2th node, you return it.

As a side note, you can add functionality to BST to find ith element efficiently (O(h), where h is the tree's height), using order statistics trees.

edited Nov 22 '20 at 09:01

ivan.ukr

2,853
1
23
41

answered May 01 '15 at 15:39

amit

175,853
27
231
333

thank you for the reply, but I already thought of this. My problem is that my function should look like this `T ComputeMedian() const` so as you can see, it has no parameters (I will edit my post now) Is it possible to do it like this `template T BST::ComputeMedian() const { ComputeMedian(root); }` And I implement `ComputeMedian(BSTNode* node)` just as you said? Will this still be a O(n)? – Nat May 01 '15 at 15:50
@NataliAyoub Yes, you are just wrapping it up with constant operations. – amit May 01 '15 at 16:08
I just edited my post and added the code along with the errors, could you please check it and tell me what's wrong? – Nat May 01 '15 at 16:16
@NataliAyoub It is out of scope of the original question, you should roll back to previous version, and ask a new question - linking to this one and stating what you have done since, and what is the new problem you encounter. – amit May 01 '15 at 16:18
@NataliAyoub The new question is as it sounds - a new question. I removed the edits and got the question back to its original state. You should ask the new question, with how to handle the errors you have, in a new question. – amit May 01 '15 at 16:37
oh lol excuse my ignorance, new here :P how do I roll back to the original post? – Nat May 01 '15 at 17:07

Find median in binary search tree

1 Answers1

Linked