Could you please briefly explain how your removal works?

I have written this one, but i cannot complete those two lines; also I am not sure about the time complexity. Do you think it is O(logn) for removal?

        public void removal(int num){       
        if(num == maxHeap.peek()){
            maxHeap.remove();
            numberOfElements--;
            return;
        }       
        if(num == minHeap.peek()){
            minHeap.remove();
            numberOfElements--;
            return;
        }       
        if(numberOfElements % 2 == 0){
            int median = (maxHeap.peek() + minHeap.peek())/2;
            if(num < median){
                // should be removed from maxheap, but how????
                // ?????

                // before: maxHeap: N & minheap: N - Now: maxHeap: N-1 & minheap: N
                // So, one element from minheap should add to maxheap
                maxHeap.add(minHeap.remove());
                // Now: maxHeap: N & minheap: N-1, so it's fine
            }else{ 
                // should be removed from minheap, but how????
                // ?????

                // before: maxHeap: N+1 & minheap: N - Now: maxHeap: N+1 & minheap: N-1
                // So, one element from maxheap should add to minheap
                maxHeap.add(minHeap.remove());
                // Now: maxHeap: N & minheap: N, so we are fine
            }
        }else{
            int median = maxHeap.peek();
            if(num < median){
                // should be removed from max heap
            }else{ 
                // should be removed from min heap
            }
        }
        numberOfElements--;
    }

Here discussed same question, but not 'delete', it is 'delete median', which is possible in O(logn). what do you think?
http://www.cs.cmu.edu/afs/cs/academic/class/15750-s11/www/hw/hw1-sol.pdf

The logic goes like that. First we need to check if the number that we want to remove is greater than the root element of the max heap. If it is, than we need to try to remove it from the min heap, otherwise we remove from max heap. Keep in mind that min and max heap are implemented as PriorityQueue, which means that removal of specified object is done in linear time. If the removal is successful we need to check for the number of elements in heap and fix it.

Also watch out what the paper you linked states. It says the following:

deleteMedian(D): Delete the median of D in time O(log n).

They only want to delete the median of structure D, where in my case the user can remove arbitrary number from stream. I see you are trying to implement the removal of only median element, as it is stated in the paper. Just follow the solution specified in the paper. Will take a look at your code later, as I am currently busy.

Thanks for explanation 👍

Hi - is it possible to public this under an ASF 2.0 license?

Here is a little cleaner and little more optimized version of addNumberToStream():

    public void addNumberToStream(Integer num) {
        if (numOfElements % 2 == 0) {
            maxHeap.add(num); //no more need for minHeap.isEmpty() check
        } else {
            minHeap.add(num); //no more need for maxHeap.poll()
            if (maxHeap.peek() > minHeap.peek()) {
                Integer maxHeapRoot = maxHeap.poll();  //only one variable is needed for swap
                maxHeap.add(minHeap.poll());
                minHeap.add(maxHeapRoot);
            }
        }
        numOfElements++; //only need one  numOfElements++
    }