Leetcode 215&347&973 最大堆排序

class Solution {
    public int findKthLargest(int[] nums, int k) {
        int n=nums.length-1;
        for(int i=(n-1)/2;i>=0;i--)
        {
            heapjust(nums,i,n);
        }
        for(int i=n;i>0;i--)
        {
            int temp=nums[0];
            nums[0]=nums[i];
            nums[i]=temp;
            heapjust(nums,0,i-1);
        }
        
        return nums[n-k+1];
    }
    public void heapjust(int[]nums,int parent,int n)
    {
        int temp=nums[parent];
        for(int i=2*parent+1;i<=n;i=i*2+1)
        {
            if(i<n&&nums[i]<nums[i+1]) i++;
            if(temp>=nums[i]) break;
            nums[parent]=nums[i];
            parent=i;
        }
        nums[parent]=temp;
    }    
}

接下来两大题我都用了key-value的思想。347题参考[leetcode]堆排序 求前k大的数。然后直到那时候，我才新认识了一种数据结构PriorityQueue，该结构直接实现最小堆排序。

class Solution {
    class keyvalue
    {
        Integer key;
        Integer value;
        public keyvalue(Integer key,Integer value)
        {
            this.key=key;
            this.value=value;
        }
    }
    public List<Integer> topKFrequent(int[] nums, int k) {
        Map<Integer,Integer>map=new HashMap<>();
        for(int i=0;i<nums.length;i++)//保存次数
        {
            if(map.containsKey(nums[i]))
            {
                map.put(nums[i],map.get(nums[i])+1);
            }
            else
            {
                map.put(nums[i],1);
            }
        }
        //定义一个priorityqueue
        Queue<keyvalue> queue=new PriorityQueue<keyvalue>(k,new Comparator<keyvalue>(){
            public int compare(keyvalue v1,keyvalue v2)
            {
                return v1.value-v2.value;
            }
        });
        Iterator iter=map.entrySet().iterator();
        int count=0;
        while(iter.hasNext())
        {
            Map.Entry entry=(Map.Entry)iter.next();
            keyvalue temp=new keyvalue((Integer)entry.getKey(),(Integer)entry.getValue());
            if(count<k)
            {
                queue.add(temp);
            }
            else if(temp.value>queue.peek().value)
            {
                queue.poll();
                queue.add(temp);
            }
            count++;              
        }
        List<Integer> list=new ArrayList<Integer>();
        for(int i=0;i<k;i++)
        {
            list.add(0,queue.poll().key);
        }
        return list;
        
    }        
}

class Solution {
    class keyvalue
    {
        Integer key;
        Integer value;
        public keyvalue(Integer key,Integer value)
        {
            this.key=key;
            this.value=value;
        }
    }
    public int[][] kClosest(int[][] points, int K) {
        int count=0;
        Queue<keyvalue>queue=new PriorityQueue<>(K,new Comparator<keyvalue>(){
            public int compare(keyvalue v1,keyvalue v2)
            {
                return v1.value-v2.value;
            }
        });
        for(int i=0;i<points.length;i++)
        {
            keyvalue temp=new keyvalue(i,points[i][0]*points[i][0]+points[i][1]*points[i][1]);
            if(count<K)
            {
                queue.add(temp);
                
            }
            else
            {
                keyvalue top=queue.peek();
                if(top.value<points[i][0]*points[i][0]+points[i][1]*points[i][1])
                {
                    queue.poll();
                    queue.add(temp);
                }
            }
        }
        int [][]result=new int[K][2];
        for(int i=0;i<K;i++)
        {
            keyvalue temp=queue.poll();
            result[i][0]=points[temp.key][0];
            result[i][1]=points[temp.key][1];
        }
                                                 
         return result;                                        
    }
}