Added Maps and Queue

Author: Prashant Jain

src/in/knowledgegate/dsa/linkedlist/MergeTwoSortedList.java

@@ -0,0 +1,58 @@
+package in.knowledgegate.dsa.linkedlist;
+
+/**
+ * You are given the heads of two sorted linked
+ * lists list1 and list2.
+ *
+ * Merge the two lists in a one sorted list.
+ * The list should be made by splicing together
+ * the nodes of the first two lists.
+ *
+ * Return the head of the merged linked list.
+ *
+ * Example 1:
+ * Input: list1 = [1,2,4], list2 = [1,3,4]
+ * Output: [dummy, 1,1,2,3,4,4]
+ *
+ * Example 2:
+ * Input: list1 = [], list2 = []
+ * Output: []
+ *
+ * Example 3:
+ * Input: list1 = [], list2 = [0]
+ * Output: [0]
+ *
+ * Constraints:
+ * The number of nodes in both lists is in the
+ * range [0, 50].
+ * -100 <= Node.val <= 100
+ * Both list1 and list2 are sorted in
+ * non-decreasing order.
+ */
+public class MergeTwoSortedList {
+  private class ListNode {
+    int val;
+    ListNode next;
+  }
+
+  public ListNode mergeTwoLists(ListNode list1,
+                                ListNode list2) {
+    ListNode temp = new ListNode();
+    ListNode dummy = temp;
+
+    while (list1 != null && list2 != null) {
+      if (list1.val <= list2.val) {
+        temp.next = list1;
+        list1 = list1.next;
+      } else {
+        temp.next = list2;
+        list2 = list2.next;
+      }
+      temp = temp.next;
+    }
+
+    temp.next = list1 != null ? list1 : list2;
+    return dummy.next;
+  }
+}
+

src/in/knowledgegate/dsa/maps/IntersectionOfTwoArrays.java

@@ -0,0 +1,45 @@
+package in.knowledgegate.dsa.maps;
+
+import java.util.HashSet;
+
+/**
+ * Given two integer arrays nums1 and nums2,
+ * return an array of their intersection.
+ * Each element in the result must be unique
+ * and you may return the result in any order.
+ *
+ * Example 1:
+ * Input: nums1 = [1,2,2,1], nums2 = [2,2]
+ * Output: [2]
+ *
+ * Example 2:
+ * Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
+ * Output: [9,4]
+ * Explanation: [4,9] is also accepted.
+ *
+ * Constraints:
+ * 1 <= nums1.length, nums2.length <= 1000
+ * 0 <= nums1[i], nums2[i] <= 1000
+ */
+public class IntersectionOfTwoArrays {
+  public int[] intersection(int[] nums1, int[] nums2) {
+    HashSet<Integer> set = new HashSet<>();
+    for (int num : nums1) {
+      set.add(num);
+    }
+
+    HashSet<Integer> result = new HashSet<>();
+    for (int num : nums2) {
+      if (set.contains(num)) {
+        result.add(num);
+      }
+    }
+
+    int[] resultArr = new int[result.size()];
+    int i = 0;
+    for (Integer num : result) {
+      resultArr[i++] = num;
+    }
+    return resultArr;
+  }
+}

src/in/knowledgegate/dsa/queue/RecentCounter.java

@@ -0,0 +1,65 @@
+package in.knowledgegate.dsa.queue;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * You have a RecentCounter class which counts the
+ * number of recent requests within a certain time
+ * frame.
+ *
+ * Implement the RecentCounter class:
+ *
+ * RecentCounter() Initializes the counter with
+ * zero recent requests.
+ *
+ * int ping(int t) Adds a new request at time t,
+ * where t represents some time in milliseconds,
+ * and returns the number of requests that has
+ * happened in the past 3000 milliseconds
+ * (including the new request). Specifically,
+ * return the number of requests that have happened
+ * in the inclusive range [t - 3000, t].
+ *
+ * It is guaranteed that every call to ping uses
+ * a strictly larger value of t than the previous
+ * call.
+ *
+ * Example 1:
+ * Input
+ * ["RecentCounter", "ping", "ping", "ping", "ping"]
+ * [[], [1], [100], [3001], [3002]]
+ * Output
+ * [null, 1, 2, 3, 3]
+ *
+ * Explanation
+ * RecentCounter recentCounter = new RecentCounter();
+ * recentCounter.ping(1);     // requests = [1], range is [-2999,1], return 1
+ * recentCounter.ping(100);   // requests = [1, 100], range is [-2900,100], return 2
+ * recentCounter.ping(3001);  // requests = [1, 100, 3001], range is [1,3001], return 3
+ * recentCounter.ping(3002);  // requests = [1, 100, 3001, 3002], range is [2,3002], return 3
+ *
+ *
+ * Constraints:
+ *
+ * 1 <= t <= 109
+ * Each test case will call ping with strictly
+ * increasing values of t.
+ * At most 104 calls will be made to ping
+ */
+public class RecentCounter {
+
+  private Queue<Integer> queue;
+
+  RecentCounter() {
+    queue = new LinkedList<>();
+  }
+
+  public int ping(int t) {
+    queue.offer(t);
+    while (queue.peek() < t - 3000) {
+      queue.poll();
+    }
+    return queue.size();
+  }
+}