双非本科准备秋招(13.1)—— 力扣 栈、队列与堆

1、103. 二叉树的锯齿形层序遍历

昨天做的二叉树的层序遍历,把代码直接拿过来。

这个题要求的是一个Z型遍历,如下图。

双非本科准备秋招(13.1)—— 力扣 栈、队列与堆_第1张图片

        用一个变量f记录正反顺序,然后使用LinkedList记录答案,下图可以看到LinkedList继承了Deque,所以可以当作双端队列来用。

双非本科准备秋招(13.1)—— 力扣 栈、队列与堆_第2张图片

每次记录答案时,根据f的值选择调用offerLast和offerFirst方法。

class Solution {
    public List> zigzagLevelOrder(TreeNode root) {
        LinkedBlockingQueue q = new LinkedBlockingQueue<>();
        List> list = new ArrayList<>();
        if(root == null) return list;
        q.offer(root);
        int cnt = 1;
        boolean f = true;

        while(!q.isEmpty()){
            LinkedList L = new LinkedList<>();
            int temp = 0;
            for(int i = 0; i < cnt; i++){
                TreeNode t = q.poll();
                if(f) L.offerLast(t.val);
                else L.offerFirst(t.val);
                if(t.left != null){
                    q.offer(t.left);
                    temp++;
                }
                if(t.right != null){
                    q.offer(t.right);
                    temp++;
                }
            }
            cnt = temp;
            list.add(L);
            f = !f;
        }

        return list;
    }
}

2、23. 合并 K 个升序链表

        用优先队列来做,默认排序即可(小顶堆),最后处理一下答案,把队列q中的元素转移到新的链表上。

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        PriorityQueue q = new PriorityQueue<>();
        ListNode head = new ListNode();
        ListNode p = head;
        for(int i = 0; i < lists.length; i++){
            while(lists[i] != null){
                q.offer(lists[i].val);
                lists[i] = lists[i].next;
            }
        }
        while(!q.isEmpty()){
            ListNode t = new ListNode(q.poll());
            p.next = t;
            p = p.next;
        }
        return head.next;
    }
}

3、215. 数组中的第K个最大元素

堆这种数据结构就适合求前几个具有xx特性的元素问题,包括下一个题目和最后一个题目。

这个题用小顶堆做,我们可以手写一个堆的结构class MinHeap。

我们只需要把前k个元素加入堆(offer()方法),然后后面的元素只需要判断是否大于堆中的第一个元素即可,如果大于,就替换第一个元素(replace()方法)。

因为堆中第一个元素是k个中最小的,我们不断加入大的元素,那么最后是不是堆中只剩下最大的k个元素了,k个最大元素中最小的不就是堆的第一个元素嘛。

class Solution {
    public int findKthLargest(int[] nums, int k) {
        MinHeap heap = new MinHeap(k);

        for(int i = 0; i < k; i++){
            heap.offer(nums[i]);
        }

        for(int i = k; i < nums.length; i++){
            if(nums[i] > heap.array[0]){
                heap.replace(nums[i]);
            }
        }

        return heap.array[0];
    }
}

public class MinHeap {
    int[] array;
    int size;

    public MinHeap(int capacity) {
        this.array = new int[capacity];
    }

    public void offer(int offerd){
        up(offerd);
        size++;   
    }

    public void up(int offerd){
        int child = size;
        while(child > 0){
            int parent = (child-1)/2;
            if(array[parent] > offerd){
                array[child] = array[parent];
            }
            else{
                break;
            }
            child = parent;
        }
        array[child] = offerd;
    }

    public void replace(int replaced){
        array[0] = replaced;
        down(0);
    }

    private void down(int parent) {
        int lc = parent*2+1;
        int rc = lc+1;
        int min = parent;
        if(lc < size && array[lc] < array[min]){
            min = lc;
        }
        if(rc < size && array[rc] < array[min]){
            min = rc;
        }
        if(min != parent){
            swap(min, parent);
            down(min);
        }
    }

    private void swap(int i, int j) {
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }
}

4、703. 数据流中的第 K 大元素

与上个题不能说一模一样,只能说完全一致。

需要注意add方法要判断一下堆是不是满了,因为初始化堆的时候有可能提供的元素个数小于k个,如果没满直接加入堆就好。

双非本科准备秋招(13.1)—— 力扣 栈、队列与堆_第3张图片

class KthLargest {
    MinHeap heap = null;
    public KthLargest(int k, int[] nums) {
        heap = new MinHeap(k);
        int len = Math.min(k, nums.length);
        for(int i = 0; i < len; i++){
            heap.offer(nums[i]);
        }
        for(int i = k; i < nums.length; i++){
            if(nums[i] > heap.array[0]){
                heap.replace(nums[i]);
            }
        }
    }
    
    public int add(int val) {
        if(heap.size < heap.array.length){
            heap.offer(val);
        }
        else if(val > heap.array[0]){
            heap.replace(val);
        }
        return heap.array[0];
    }
}

public class MinHeap {
    int[] array;
    int size;

    public MinHeap(int capacity) {
        this.array = new int[capacity];
        Arrays.fill(this.array, Integer.MIN_VALUE);
    }

    public void offer(int offerd){
        up(offerd);
        size++;   
    }

    public void up(int offerd){
        int child = size;
        while(child > 0){
            int parent = (child-1)/2;
            if(array[parent] > offerd){
                array[child] = array[parent];
            }
            else{
                break;
            }
            child = parent;
        }
        array[child] = offerd;
    }

    public void replace(int replaced){
        array[0] = replaced;
        down(0);
    }

    private void down(int parent) {
        int lc = parent*2+1;
        int rc = lc+1;
        int min = parent;
        if(lc < size && array[lc] < array[min]){
            min = lc;
        }
        if(rc < size && array[rc] < array[min]){
            min = rc;
        }
        if(min != parent){
            swap(min, parent);
            down(min);
        }
    }

    private void swap(int i, int j) {
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }
}

5、1047. 删除字符串中的所有相邻重复项

解释:
例如,在 "abbaca" 中,我们可以删除 "bb" 由于两字母相邻且相同,这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca",其中又只有 "aa" 可以执行重复项删除操作,所以最后的字符串为 "ca"。

读完解释后,感觉就是明示了栈的数据结构。

我们把a入栈,b入栈,b入栈,b和栈顶重复,b不入了并且弹出栈顶元素,这时候栈只剩下a,然后a入栈,a和栈顶重复,a不入了并且弹出栈顶元素,栈空了,然后c入栈,a入栈。

这时候我们依次弹出,得到ac,那么我们可以倒着遍历字符串,倒着入栈,结果都是一样的,不影响删除相邻重复的字母。

class Solution {
    public String removeDuplicates(String s) {
        Stack stack = new Stack<>();
        for(int i = s.length()-1; i >= 0; i--){
            if(!stack.isEmpty() && stack.peek() == s.charAt(i)){
                stack.pop();
            }
            else{
                stack.push(s.charAt(i));
            }
        }
        String ans = "";
        while(!stack.isEmpty()){
            ans += stack.pop();
        }

        return ans;
    }
}

6、347. 前 K 个高频元素

        元素与元素的次数,让人联想到哈希表。存到哈希表后,对出现的次数进行排序,这应该是第一思路。

        前k个高频元素,有出现了前几个具有xx特性的这种要求,我们就会想到堆,在堆中只存放前k个高频元素,使用小顶堆,我们最后得到的就是前k个最高频的元素了。

        java中的ProrityQueue的底层就是堆,我就不用自己写的了。因为我们的堆中要存储数据和出现的次数,因此可以存个数组,下标0代表是什么数据,下标1代表出现的次数。        

        我们先加入到map中,然后遍历map集合,把cnt大于堆顶的元素替换掉原来的元素,也就是队列出队,这样就得到了前k个高频的元素了。

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        PriorityQueue q = new PriorityQueue<>(k, (o1, o2) -> o1[1] - o2[1]);
        HashMap map = new HashMap<>();

        for(int i = 0; i < nums.length; i++){
            int v = 0;
            if(map.containsKey(nums[i])){
                v = map.get(nums[i]);
            }
            map.put(nums[i], v+1);
        }

        for(Integer n : map.keySet()){
            int cnt = map.get(n);
            if(q.size() < k){
                q.offer(new int[]{n, cnt});
            }
            else if(cnt > q.peek()[1]){
                q.poll();
                q.offer(new int[]{n, cnt});
            }
        }

        int[] ans = new int[k];
        int j = 0;
        while(!q.isEmpty()){
            ans[j++] = q.poll()[0];
        }
        return ans;
    }
}

你可能感兴趣的:(数据结构,算法,leetcode,求职招聘,java,intellij-idea)