Added sorting and heap problems

Author: Prashant Jain

src/in/knowledgegate/dsa/heap/KthLargestElement.java

@@ -0,0 +1,45 @@
+package in.knowledgegate.dsa.heap;
+
+import java.util.PriorityQueue;
+
+/**
+ * Given an integer array nums and an integer k,
+ * return the kth largest element in the array.
+ *
+ * Note that it is the kth largest element in the
+ * sorted order, not the kth distinct element.
+ *
+ * Example 1:
+ * Input: nums = [3,2,1,5,6,4], k = 2
+ * Output: 5
+ *
+ * Example 2:
+ * Input: nums = [3,2,3,1,2,4,5,5,6], k = 4
+ * Output: 4
+ *
+ * Constraints:
+ * 1 <= k <= nums.length <= 104
+ * -104 <= nums[i] <= 104
+ */
+public class KthLargestElement {
+  public static void main(String[] args) {
+    KthLargestElement kthLargest =
+        new KthLargestElement();
+    int[] nums = new int[]{3,2,3,1,2,4,5,5,6};
+    System.out.println("Kth largest is:" +
+        kthLargest.findKthLargest(nums, 6));
+  }
+
+  public int findKthLargest(int[] nums, int k) {
+    PriorityQueue<Integer> kLargest =
+        new PriorityQueue<>();
+    for (int num : nums) {
+      kLargest.add(num);
+      if (kLargest.size() > k) {
+        kLargest.poll();
+      }
+    }
+
+    return kLargest.peek();
+  }
+}

src/in/knowledgegate/dsa/sorting/problems/KthLargestElement.java

@@ -0,0 +1,60 @@
+package in.knowledgegate.dsa.sorting.problems;
+
+/**
+ * Given an integer array nums and an integer k,
+ * return the kth largest element in the array.
+ *
+ * Note that it is the kth largest element in the
+ * sorted order, not the kth distinct element.
+ *
+ * Example 1:
+ * Input: nums = [3,2,1,5,6,4], k = 2
+ * Output: 5
+ *
+ * Example 2:
+ * Input: nums = [3,2,3,1,2,4,5,5,6], k = 4
+ * Output: 4
+ *
+ * Constraints:
+ * 1 <= k <= nums.length <= 104
+ * -104 <= nums[i] <= 104
+ */
+public class KthLargestElement {
+  public static void main(String[] args) {
+    KthLargestElement kthLargest =
+        new KthLargestElement();
+    int[] nums = new int[]{3,2,3,1,2,4,5,5,6};
+    System.out.println("Kth largest is:" +
+        kthLargest.findKthLargest(nums, 4));
+  }
+
+  public int findKthLargest(int[] nums, int k) {
+    return quickSelect(nums, 0, nums.length-1, k);
+  }
+
+  private int quickSelect(int[] nums, int beg,
+                          int end, int k) {
+    int pivot = beg;
+    for (int i = pivot; i < end; i++) {
+      if (nums[i] <= nums[end]) {
+        swap(nums, i, pivot);
+        pivot++;
+      }
+    }
+    swap(nums, pivot, end);
+    int count = end - pivot + 1;
+    if (count == k) return nums[pivot];
+    if (count > k) {
+      return quickSelect(nums, pivot + 1, end, k);
+    } else {
+      return quickSelect(nums, beg, pivot - 1,
+          k - count);
+    }
+  }
+
+  private void swap(int[] nums, int i, int j) {
+    int temp = nums[i];
+    nums[i] = nums[j];
+    nums[j] = temp;
+  }
+}

src/in/knowledgegate/dsa/sorting/problems/ThreeSum.java

@@ -0,0 +1,60 @@
+package in.knowledgegate.dsa.sorting.problems;
+
+import java.util.*;
+
+/**
+ * Given an integer array nums, return all the
+ * triplets [nums[i], nums[j], nums[k]] such that
+ * i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0.
+ *
+ * Notice that the solution set must not contain
+ * duplicate triplets.
+ *
+ * Example 1:
+ * Input: nums = [-1,0,1,2,-1,-4]
+ * Output: [[-1,-1,2],[-1,0,1]]
+ *
+ * Example 2:
+ * Input: nums = []
+ * Output: []
+ *
+ * Example 3:
+ * Input: nums = [0]
+ * Output: []
+ *
+ * Constraints:
+ * 0 <= nums.length <= 3000
+ * -105 <= nums[i] <= 105
+ */
+public class ThreeSum {
+  public static void main(String[] args) {
+    ThreeSum threeSum = new ThreeSum();
+    int[] nums = new int[]{-1,0,1,2,-1,-4};
+    System.out.println("Possible Triplets:" +
+        threeSum.threeSum(nums));
+  }
+
+  public Set<List<Integer>> threeSum(int[] nums) {
+    Arrays.sort(nums);
+    Set<List<Integer>> res = new HashSet<>();
+    for (int i = 0; i < nums.length - 2; i++) {
+      int beg = i + 1;
+      int end = nums.length - 1;
+      while (beg < end) {
+        int sum = nums[i] + nums[beg] + nums[end];
+        if (sum == 0) {
+          res.add(Arrays.asList(nums[i],
+              nums[beg], nums[end]));
+          beg++;
+          end--;
+        } else if (sum < 0) {
+          beg++;
+        } else {
+          end--;
+        }
+      }
+    }
+
+    return res;
+  }
+}