labuladong算法小抄-⼆叉堆-leetcode23、leetcode215、leetcode295、leetcode703

二叉堆

二叉堆的思想其实就是堆排序！！！

 public void heapSort(int []nums){
        int len = nums.length;
        initHeap(nums,len);
        int index = len - 1;
        for (int i = 0 ;i < len ;i++){
            swap(nums,i,index);
            heapfying(nums,0,index);
            index --;
        }
    }

    private void initHeap(int[] nums, int len) {
        for ( int i = len / 2  -1 ; i >= 0; i -- ){
            heapfying(nums,i,len);
        }
    }

    private void heapfying(int[] nums, int i, int len) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int max_index = i;
        if(left < len && nums[left] > nums[max_index]){
            max_index = left;
        }
        if(right < len && nums[right] > nums[max_index]){
            max_index = right;
        }
        if( max_index != i){
            swap(nums,i,max_index);
            heapfying(nums,max_index,len);
        }
    }

    private void swap(int[] nums, int i, int j) {
        int tep = nums[i];
        nums[i] = nums[j];
        nums[j] = tep;
    }

例题

leetcode23

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        ListNode res = new ListNode();
        res.next =null;
        ListNode tail = res;
        PriorityQueue<ListNode> que = new PriorityQueue<>((o1, o2)->o1.val-o2.val);
        for (ListNode i : lists){
            ListNode tep = i;
            while(tep != null){
                que.add(tep);
                tep = tep.next;
            }
        }
        while(!que.isEmpty()){
            ListNode peek = que.peek();
            tail.next = peek;
            peek.next = null;
            tail = peek;
            que.poll();
        }
        return res.next;
    }
}

leetcode215

class Solution {
    public int findKthLargest(int[] nums, int k) {
        return selectFind(nums,0,nums.length-1,k);
    }
    int selectFind(int []nums,int left, int right,int k){
        int len = nums.length;
        while(left < right){
            int mid = partition(nums,left,right);

            if(len - k == mid){
                return nums[mid];
            }else if(mid > len - k){
                right = mid -1;
            }else{
                left = mid + 1;
            }
        }
        return nums[left];
    }

    int partition(int nums[] , int left , int right){
        int flag = left;
        int index = left + 1;
        for (int i = index ; i <= right; i++){
            if(nums[i]<nums[flag]){
                swap(nums,i,index);
                index++;
            }
        }
        swap(nums,left,index-1);
        return index - 1;
    }
    void swap(int []nums , int i, int j){
        int tep = nums[i];
        nums[i] = nums[j];
        nums[j] = tep;
    }
}

leetcode295

class MedianFinder {

    // 递增 末尾后半段
    
    PriorityQueue<Integer> que1 = new PriorityQueue<>((o1,o2)->o1-o2);

    //递减 前半部分
    PriorityQueue<Integer> que2 = new PriorityQueue<>((o1,o2)->o2-o1);

    public MedianFinder() {
        
    }

    public void addNum(int num) {
        // que1.add(num);
      

        int t = num;
        if(!que2.isEmpty()&&que2.peek()>num){
            t = que2.peek();
            que2.poll();
            que2.add(num);
        }
            que1.add(t);
            if(que1.size() - que2.size() >= 2){
            int tt = que1.peek();
            que1.poll();
            que2.add(tt);
        

        }
    }

    public double findMedian() {
        
        if((que1.size() + que2.size())%2 == 0){
            return (double)(que1.peek()+que2.peek())/2;
        }else {
            return  (double)(que1.peek());
        }
    }
}
/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder obj = new MedianFinder();
 * obj.addNum(num);
 * double param_2 = obj.findMedian();
 */

 

leetcode703

class KthLargest {

    PriorityQueue<Integer> que = new PriorityQueue<>();
    int k ;

    public KthLargest(int k, int[] nums) {
        this.k = k;
        for (int i :nums){
            que.add(i);
            if(que.size()>k){
                que.poll();
            }
        }
    }
    
    public int add(int val) {
        que.add(val);
         if(que.size()>k){
                que.poll();
        }
        return que.peek();
    }
}

/**
 * Your KthLargest object will be instantiated and called as such:
 * KthLargest obj = new KthLargest(k, nums);
 * int param_1 = obj.add(val);
 */