堆排序——LeetCode703.Kth Largest Element in a Stream

堆排序——LeetCode703.Kth Largest Element in a Stream

题目

Design a class to find the kth largest element in a stream. Note that it is the kth largest element in the sorted order, not the kth distinct element.

Your KthLargest class will have a constructor which accepts an integer k and an integer array nums, which contains initial elements from the stream. For each call to the method KthLargest.add, return the element representing the kth largest element in the stream.

Example:

int k = 3;
int[] arr = [4,5,8,2];
KthLargest kthLargest = new KthLargest(3, arr);
kthLargest.add(3);   // returns 4
kthLargest.add(5);   // returns 5
kthLargest.add(10);  // returns 5
kthLargest.add(9);   // returns 8
kthLargest.add(4);   // returns 8

Note:
You may assume that nums’ length ≥ k-1 and k ≥ 1.

题意

这道题的题意是给一个数组，然后每次向里面插入一个数，要求返回此时数组中的第K大的数。

思路

我的思路是先利用堆排序构建一个只有K个元素的递增的数组，此后每次向这个数组里插入整数，同时保证这个数组始终只有K个元素。

代码

class KthLargest {
public:
    vector<int>number;
    vector<int>ans;
    int kth;

    void heap_maximum(int i, int heap_size) {
        int l, r, m ,temp;
        l = 2*i;
        r = 2*i + 1;
        m = i;
        temp = number[i-1];
        if(l<=heap_size && number[l-1]>number[i-1]) {
            m = l;
            temp = number[l-1];
        }
        if(r<=heap_size && number[r-1]>number[m-1]) {
            m = r;
            temp = number[r-1];
        }
        if(m!=i) {
            number[m-1] = number[i-1];
            number[i-1] = temp;
            heap_maximum(m, heap_size);
        }

    }

    void heap_build() {
        int i, j, heap_size;
        heap_size = number.size();
        for(i=heap_size/2; i>0; i--) {
            heap_maximum(i, heap_size);
        }
    }

    void heap_sort() {
        heap_build();

        int i, j, temp, heap_size;
        heap_size = kth;
        if(number.size()<kth) {
            heap_size = number.size();
        }
        for(i=heap_size; i>1; i--) {
            temp = number[0];
            number[0] = number[i-1];
            number[i-1] = temp;
            heap_maximum(1, i-1);
        }
    }


    KthLargest(int k, vector<int> nums) {
        kth = k;
        int i, j;
        number.clear();
        j = k;
        if(nums.size()<kth) {
            j = nums.size();
        }
        for(i=0; i<j; i++) {
            number.push_back(nums[i]);
        }
        heap_sort();

        for(i=kth; i<nums.size(); i++) {
            add(nums[i]);
        }



    }

     int add(int val) {
         if(number.size()==0) {
            number.push_back(val);
            return val;
         }
        int i, j, k;
        if(number.size() < kth) {
            for(i=0; i<number.size(); i++) {
                if(number[i] > val) {
                    break;
                }
            }
            if(i==number.size()) {
                number.push_back(val);
                return number[0];
            }
            number.push_back(0);
            for(j=number.size()-1; j>i; j--) {
                number[j] = number[j-1];
            }
            number[j] = val;
            return number[0];
        }

        for(i=kth-1; i>=0; i--) {
            if(val > number[i]) {
                break;
            }
        }
        if(i == -1) {
            return number[0];
        }
        for(j=0; j<i; j++) {
            number[j] = number[j+1];
        }
        number[j] = val;
        return number[0];
    }

};