2019/08/25 leetcode

2019/08/25: L230, L226, L18, L234, L23

1. L230 Kth smallest element in BST

借助 Stack 或 LinkedList inorder traveresal, LinkedList会更快

ArrayList, LinkedList, Vector, Stack  https://blog.csdn.net/iteye_11495/article/details/82618748 

 

2. L226 Invert Binary Tree

3. L18 4Sum

   Two pointers

public List<List<Integer>> fourSum(int[] nums, int target) {
        
        List<List<Integer>> res = new LinkedList<>();
        if(nums == null || nums.length < 4) return res;
        Arrays.sort(nums);
        int k, z;
        for(int i = 0; i<nums.length-1;i++){
            if(i>0 && nums[i]==nums[i-1]) continue;
            
            //pruning
            if(nums[i]*4 > target) break;
            if(nums[i] + 3* nums[nums.length-1]<target) continue;
            
            for(int j =i+1; j<nums.length;j++){
                if(j>i+1 && nums[j]==nums[j-1]) continue;
                
                //pruning
                if(nums[i]+ nums[j]*3 >target) break;
                if(nums[i] + nums[j]+ 2* nums[nums.length-1]<target) continue;
                
                k = j+1;
                z = nums.length -1;
                while(k<z){
                    int sum = nums[i] + nums[j] + nums[k] + nums[z];
                    if(sum == target){
                        List<Integer> list = new ArrayList<>();
                        list.add(nums[i]);
                        list.add(nums[j]);
                        list.add(nums[k]);
                        list.add(nums[z]);
                        res.add(list);
                        while(k<z && nums[k]==nums[k+1])k++;
                        k++;
                        while(k<z && nums[z]==nums[z-1])z--;
                        z--;
                    }else if(sum > target) z--;
                    else k++;
                }
            }
        }  
        return res;
    }

加上pruning代码，beat 100%。

 

4. L234 Palindrome Linked List

slow fast pointers, 后半段reverse

Time O(n) spaceO(1)

 public boolean isPalindrome(ListNode head) {
        if( head==null || head.next==null ) return true;
        
        ListNode slow = head;
        ListNode fast = head.next;
        while(fast!=null && fast.next!=null){
            slow = slow.next;
            fast = fast.next.next;
        }
        ListNode pre = null;
        slow = slow.next;
        //reveres node after slow
        while(slow!=null){
            ListNode next = slow.next;
            slow.next = pre;
            pre = slow;
            slow = next;
        }
        
        while(pre!=null && head!=null){
            if(head.val!=pre.val) return false;
            head = head.next;
            pre = pre.next;
        }
        return true;
    }

 

5. L23. Merge k Sorted Lists

min heap

public ListNode mergeKLists(ListNode[] lists) {
        if(lists == null || lists.length == 0) return null;
        if(lists.length ==1) return lists[0];
        PriorityQueue<ListNode> pq = new PriorityQueue<ListNode>(new Comparator<ListNode>(){
            public int compare(ListNode l1, ListNode l2){
                return l1.val - l2.val;
            }
        });
        for(ListNode l : lists){
            if(l!=null) pq.offer(l);
        }
        ListNode head = new ListNode(0);
        ListNode curr = head;
        while(!pq.isEmpty()){
            ListNode newNode = pq.poll();
            curr.next = newNode;
            curr = curr.next;
            if(newNode.next!=null){
                pq.offer(newNode.next);
            }
        }
        return head.next;
    }