Merge pull request #2280 from se6816/main

[se6816] WEEK 10 solutions

Author: se6816

invert-binary-tree/se6816.java

@@ -0,0 +1,21 @@
+class Solution {
+    public TreeNode invertTree(TreeNode root) {
+        if(root == null) return root;
+        Queue<TreeNode> que = new ArrayDeque<>();
+        que.add(root);
+
+        while(!que.isEmpty()) {
+            TreeNode node = que.poll();
+            TreeNode tempNode = node.left;
+            node.left = node.right;
+            node.right = tempNode;
+            if(node.left != null) {
+                que.add(node.left);
+            }
+            if(node.right != null) {
+                que.add(node.right);
+            }
+        }
+        return root;
+    }
+}

jump-game/se6816.java

@@ -0,0 +1,27 @@
+class Solution {
+    public boolean canJump(int[] nums) {
+        boolean[] visited= new boolean[nums.length];
+        dfs(visited, nums, 0);
+        return visited[nums.length - 1];
+    }
+    public void dfs(boolean[] visited, int[] nums, int target) {
+        if(visited[nums.length -1]) {
+            return;
+        }
+        if(visited[target]) {
+            return;
+        }
+
+        visited[target] = true;
+
+        int maxDist = nums[target];
+        for(int i = maxDist; i > 0; i--) {
+            int nextIdx = target + i;
+            if(nextIdx > nums.length - 1) {
+                continue;
+            }
+
+            dfs(visited, nums, nextIdx);
+        }
+    }
+}

merge-k-sorted-lists/se6816.java

@@ -0,0 +1,28 @@
+
+class Solution {
+    public ListNode mergeKLists(ListNode[] lists) {
+            ListNode list= new ListNode(0); // head
+            ListNode curr=list;
+            PriorityQueue<ListNode> pq=new PriorityQueue<ListNode>((l1, l2)->{
+                return l1.val - l2.val;
+            });
+            for(int i=0; i<lists.length;i++){
+                if(lists[i]!=null){
+                    pq.offer(lists[i]);
+                }
+            }
+            while(!pq.isEmpty()){
+                ListNode temp = pq.poll();
+                curr.next=new ListNode(temp.val);
+                curr=curr.next;
+                temp=temp.next;
+                if(temp!=null){
+                    pq.offer(temp);
+                }
+
+            }
+            return list.next;
+                
+        
+    }
+}

search-in-rotated-sorted-array/se6816.java

@@ -0,0 +1,46 @@
+class Solution {
+    public int search(int[] nums, int target) {
+        int firstIdx = binarySearch(nums);
+        int result = 0;
+        if (firstIdx == 0) {
+            return binarySearch(target, nums, 0, nums.length - 1);
+        } else if (target >= nums[0]) {
+            return binarySearch(target, nums, 0, firstIdx);
+        } else {
+            return binarySearch(target, nums, firstIdx, nums.length - 1);
+        }
+    }
+
+    public int binarySearch(int[] nums) {
+            int start = 0;
+            int end = nums.length -1;
+            while(start < end) {
+                int mid = (start + end) / 2;
+                if(nums[mid] < nums[end]) {
+                    end = mid;
+                } else {
+                    start = mid + 1;
+                }
+            }
+            return start;
+    }
+
+    public int binarySearch(int target, int[] nums, int start, int end) {
+            int result = -1;
+            while(start <= end) {
+                int mid = (start + end) / 2;
+                if(nums[mid] > target) {
+                    end = mid - 1;
+                } else if(nums[mid] < target){
+                    start = mid + 1;
+                } else {
+                    result = mid;
+                    break;
+                }
+            }
+
+            return result;
+    }
+        
+    
+}