上面那个Go语言的有问题，他不能保证一直都是满足小顶堆的限制的，因为push的时候调用的是自己的方法而不是堆的方法，所以不会检测。下面是我写的
type IntHead []int
func (i IntHead) Len() int { return len(i)}
func (In IntHead) Less(i ,j int) bool {
    return In[i] < In[j]}
func (In IntHead) Swap(i, j int) {
    In[i], In[j] = In[j], In[i]
}
func (In *IntHead) Push(x interface{}) {
    *In = append(*In, x.(int))
}
func (In *IntHead) Pop() interface{} {
    old := *In
    n := len(old)
    x := old[n -1]
    *In = old[0:n-1]
    return x
  
}
type KthLargest struct {
    K int
    H *IntHead
}


func Constructor(k int, nums []int) KthLargest {
    min := &IntHead{}
    
    heap.Init(min)
    kth := KthLargest{K:k, H:min}
    for _, num := range nums {
        kth.Add(num)
    }
    return kth
}


func (this *KthLargest) Add(val int) int {
    if this.H.Len() == 1 && (*this.H)[0] == 0 && val == -1 {
         min := &IntHead{-1,0}
         heap.Init(min)
        this.H = min
    }
    if this.H.Len() < this.K {
        heap.Push(this.H, val)
    } else if (*this.H)[0] < val {
        heap.Pop(this.H)
    heap.Push(this.H, val)
    }
    return (*this.H)[0]
}

}

Go 简单版本:
package main

import (
    "container/heap"
    "fmt"
)

type IntSlice []int

func (s *IntSlice) Len() int {
    return len(*s)
}

func (s *IntSlice) Less(i, j int) bool {
    return (*s)[i] < (*s)[j]
}

func (s *IntSlice) Swap(i, j int) {
    (*s)[i], (*s)[j] = (*s)[j], (*s)[i]
}

func (s *IntSlice) Push(x interface{}) {
    *s = append(*s, x.(int))
}

func (s *IntSlice) Pop() interface{} {
    length := s.Len()

    last := (*s)[length-1]
    *s = (*s)[:length-1]
    return last
}

type KthLargest struct {
    minHeap IntSlice
    kth int
}

func Constructor(k int, nums []int) KthLargest {
    kthLargest := KthLargest{
        minHeap: make(IntSlice, 0),
        kth: k,
    }

    for _, v := range nums {
        kthLargest.Add(v)
    }

    return kthLargest
}

func (k *KthLargest) Add(val int) int {
    if k.minHeap.Len() < k.kth { // 如果还没有满, 无论如何插入元素
        heap.Push(&k.minHeap, val)
    } else {
        if val > k.minHeap[0] { // 判断插入元素 大于 当前元素里面的最小值, 则插入
            heap.Pop(&k.minHeap)
            heap.Push(&k.minHeap, val)
        }
    }

    return k.minHeap[0]
}

func main() {
    kthLargest := Constructor(3, []int{
        4, 5, 8, 2,
    })

    fmt.Println(kthLargest.Add(3))
    fmt.Println(kthLargest.Add(5))
    fmt.Println(kthLargest.Add(10))
    fmt.Println(kthLargest.Add(9))
    fmt.Println(kthLargest.Add(4))
}

PHP 最小堆实现第K大元素
class MinHeap extends SplHeap
{
    //用最小堆存储第K大元素
    public function compare( $value1, $value2 ) {
        return ( $value2 - $value1 );
  }
}
class KthLargest {
    public $k;
    public $heap;
    /**
     * @param Integer $k
     * @param Integer[] $nums
     */
    function __construct($k, $nums) {
        $this->k = $k;
        $this->heap = new MinHeap();
        foreach($nums as $num)
        {
            $this->add($num);
        }
    }
  
    /**
     * @param Integer $val
     * @return Integer
     */
    function add($val) {
        if($this->heap->count()<$this->k){
            $this->heap->insert($val);
        }else{
            if($val>$this->heap->top()){
                $this->heap->insert($val);
                $this->heap->extract();
            }
        }
        return $this->heap->top();
    }
}

老师那个构造函数有点问题，可改为（仅供参考）：
```
public KthLargest(int k, int[] nums) {
        this.k = k;
        heap = new PriorityQueue<Integer>();
        for (int i = 0; i < nums.length; i++) {
            if (i < k) {
                heap.offer(nums[i]);
                continue;
            }
            else {
                if (nums[i] > heap.peek()) {
                    heap.poll();
                    heap.offer(nums[i]);
                    continue;
                }
            }
        }
    }
```