Google 面试题：Java实现用最大堆和最小堆查找中位数 Find median with min heap and max heap in Java

Google面试题

股市上一个股票的价格从开市开始是不停的变化的，需要开发一个系统，给定一个股票，它能实时显示从开市到当前时间的这个股票的价格的中位数（中值）。

SOLUTION 1:

1.维持两个heap,一个是最小堆，一个是最大堆。

2.一直使maxHeap的size大于minHeap.

3. 当两边size相同时，比较新插入的value,如果它大于minHeap的最大值，把它插入到minHeap。并且把minHeap的最小值移动到maxHeap。

...具体看代码

/**************************************************************
 * 
 * 08-722 Data Structures for Application Programmers
 * Lab 7 Heaps and Java PriorityQueue class
 * 
 * Find median of integers using Heaps (maxHeap and minHeap)
 * 
 * Andrew id:  yuzhang
 * Name: Yu Zhang
 * 
 **************************************************************/

import java.util.*;

public class FindMedian {
    private static PriorityQueue<Integer> maxHeap, minHeap;

    public static void main(String[] args) {

        Comparator<Integer> revCmp = new Comparator<Integer>() {
            @Override
            public int compare(Integer left, Integer right) {
                return right.compareTo(left);
            }
        };

        // Or you can use Collections' reverseOrder method as follows.
        // Comparator<Integer> revCmp = Collections.reverseOrder();

        maxHeap = new PriorityQueue<Integer>(20, revCmp);
        minHeap = new PriorityQueue<Integer>(20);

        addNumber(6);
        addNumber(4);
        addNumber(3);
        addNumber(10);
        addNumber(12);
        System.out.println(minHeap);
        System.out.println(maxHeap);
        System.out.println(getMedian());

        addNumber(5);
        System.out.println(minHeap);
        System.out.println(maxHeap);
        System.out.println(getMedian());

        addNumber(7);
        addNumber(8);
        System.out.println(minHeap);
        System.out.println(maxHeap);
        System.out.println(getMedian());
    }

    /*
     * Note: it maintains a condition that maxHeap.size() >= minHeap.size()
     */
    public static void addNumber(int value) {
        if (maxHeap.size() == minHeap.size()) {
            if (minHeap.peek() != null && value > minHeap.peek()) {
                maxHeap.offer(minHeap.poll());
                minHeap.offer(value);
            } else {
                maxHeap.offer(value);
            }
        } else {
            if (value < maxHeap.peek()) {
                minHeap.offer(maxHeap.poll());
                maxHeap.offer(value);
            } else {
                minHeap.offer(value);
            }
        }
    }

    /*
     * If maxHeap and minHeap are of different sizes, 
     * then maxHeap must have one extra element.
     */
    public static double getMedian() {
        if (maxHeap.isEmpty()) {
            return -1; 
        }
        
        if (maxHeap.size() == minHeap.size()) {
            return (double)(minHeap.peek() + maxHeap.peek())/2;
        } else {
            return maxHeap.peek();
        }
    }
}

 

SOLUTION 2:

比起solution 1 ，进行了简化

maxHeap保存较小的半边数据，minHeap保存较大的半边数据。

1.无论如何，直接把新值插入到maxHeap。

2. 当minHeap为空，直接退出。

3. 当maxHeap比minHeap多2个值，直接移动一个值到maxHeap即可。

4. 当maxHeap比minHeap多1个值，比较顶端的2个值，如果maxHeap的最大值大于minHeap的最小值，交换2个值即可。

5. 当maxHeap较大时，中值是maxHeap的顶值，否则取2者的顶值的中间值。

/**************************************************************
 * 
 * 08-722 Data Structures for Application Programmers
 * Lab 7 Heaps and Java PriorityQueue class
 * 
 * Find median of integers using Heaps (maxHeap and minHeap)
 * 
 * Andrew id:  yuzhang
 * Name: Yu Zhang
 * 
 **************************************************************/

import java.util.*;

public class FindMedian_20150122 {
    private static PriorityQueue<Integer> maxHeap, minHeap;

    public static void main(String[] args) {
        // Or you can use Collections' reverseOrder method as follows.
        // Comparator<Integer> revCmp = Collections.reverseOrder();

        maxHeap = new PriorityQueue<Integer>(20, new Comparator<Integer>(){
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        
        minHeap = new PriorityQueue<Integer>(20);

        addNumber(6);
        addNumber(4);
        addNumber(3);
        addNumber(10);
        addNumber(12);
        System.out.println(minHeap);
        System.out.println(maxHeap);
        System.out.println(getMedian());

        addNumber(5);
        System.out.println(minHeap);
        System.out.println(maxHeap);
        System.out.println(getMedian());

        addNumber(7);
        addNumber(8);
        System.out.println(minHeap);
        System.out.println(maxHeap);
        System.out.println(getMedian());
    }

    /*
     * Note: it maintains a condition that maxHeap.size() >= minHeap.size()
     */
    public static void addNumber1(int value) {
        if (maxHeap.size() == minHeap.size()) {
            if (!maxHeap.isEmpty() && value > minHeap.peek()) {
                // put the new value in the right side.
                maxHeap.offer(minHeap.poll());
                minHeap.offer(value);
            } else {
                // add the new value into the left side.
                maxHeap.offer(value);
            }
        } else {
            if (value < maxHeap.peek()) {
                // add the new value into the left side.
                minHeap.offer(maxHeap.poll());
                maxHeap.offer(value);
            } else {
                // add the new value into the right side.
                minHeap.offer(value);
            }
        }
    }
    
    /*
     * Note: it maintains a condition that maxHeap.size() >= minHeap.size()
     * solution 2:
     */
    public static void addNumber(int value) {
        maxHeap.offer(value);
        
        // For this case, before insertion, max-heap has n+1 and min-heap has n elements.  
        // After insertion, max-heap has n+2 and min-heap has n elements, so violate!  
        // And we need to pop 1 element from max-heap and push it to min-heap  
        if (maxHeap.size() - minHeap.size() == 2) {
            // move one to the right side.
            minHeap.offer(maxHeap.poll());
        } else {
            if (minHeap.isEmpty()) {
                return;
            }
            
            // If the newly inserted value is larger than root of min-heap  
            // we need to pop the root of min-heap and insert it to max-heap.  
            // And pop root of max-heap and insert it to min-heap 
            if (minHeap.peek() < maxHeap.peek()) {
                // exchange the top value in the minHeap and the maxHeap.
                minHeap.offer(maxHeap.poll());
                maxHeap.offer(minHeap.poll());
            }
        }
    }

    /*
     * If maxHeap and minHeap are of different sizes, 
     * then maxHeap must have one extra element.
     */
    public static double getMedian() {
        if (maxHeap.isEmpty()) {
            return -1;
        }
        
        if (maxHeap.size() > minHeap.size()) {
            return maxHeap.peek();
        } else {
            return (double)(maxHeap.peek() + minHeap.peek()) / 2;
        }
    }
}

GITHUB: https://github.com/yuzhangcmu/08722_DataStructures/blob/master/08722_LAB7/src/FindMedian_20150122.java

 

ref: http://blog.csdn.net/fightforyourdream/article/details/12748781

http://www.ardendertat.com/2011/11/03/programming-interview-questions-13-median-of-integer-stream/

http://blog.sina.com.cn/s/blog_979956cc0101hab8.html

http://blog.csdn.net/ajaxhe/article/details/8734280

http://www.cnblogs.com/remlostime/archive/2012/11/09/2763256.html