Update

ex01tus · ex01tus · commit cacb2e778e3b · 2023-02-12T19:29:31.000+04:00
diff --git a/src/binary_tree/ConstructBinaryTreeFromPreorderAndInorderTraversal.java b/src/binary_tree/ConstructBinaryTreeFromPreorderAndInorderTraversal.java
@@ -0,0 +1,45 @@
+package binary_tree;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class ConstructBinaryTreeFromPreorderAndInorderTraversal {
+
+    private Map<Integer, Integer> inorderValueToIndexMap;
+    private int rootIndexInPreorderArray;
+
+    public TreeNode buildTree(int[] preorder, int[] inorder) {
+        rootIndexInPreorderArray = 0;
+        inorderValueToIndexMap = new HashMap<>();
+        for (int i = 0; i < inorder.length; i++) {
+            inorderValueToIndexMap.put(inorder[i], i);
+        }
+
+        return toTree(preorder, 0, preorder.length - 1);
+    }
+
+    private TreeNode toTree(int[] preorder, int left, int right) {
+        if (left > right) return null;
+
+        TreeNode root = new TreeNode();
+        root.val = preorder[rootIndexInPreorderArray++];
+        int rootIndexInInorderArray = inorderValueToIndexMap.get(root.val);
+
+        root.left = toTree(preorder, left, rootIndexInInorderArray - 1);
+        root.right = toTree(preorder, rootIndexInInorderArray + 1, right);
+
+        return root;
+    }
+
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+    }
+}
diff --git a/src/heap/KClosestPointsToOrigin.java b/src/heap/KClosestPointsToOrigin.java
@@ -10,15 +10,6 @@
  */
 public class KClosestPointsToOrigin {
 
-    /**
-     * Time complexity: O(nlog n)
-     * Space complexity: O(log n)
-     */
-    public int[][] kClosestViaSorting(int[][] points, int k) {
-        Arrays.sort(points, (p1, p2) -> Integer.compare(distance(p1), distance(p2)));
-        return Arrays.copyOfRange(points, 0, k);
-    }
-
     /**
      * Time complexity: O(nlog k)
      * Space complexity: O(k)
@@ -41,6 +32,56 @@ public int[][] kClosestViaMaxHeap(int[][] points, int k) {
         return result;
     }
 
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    public int[][] kClosestViaQuickSelect(int[][] points, int k) {
+        return quickSelect(points, 0, points.length - 1, k);
+    }
+
+    private int[][] quickSelect(int[][] points, int left, int right, int k) {
+        int partition = lomutoPartition(points, left, right);
+        if (partition == k - 1) return Arrays.copyOfRange(points, 0, k);
+
+        if (partition > k - 1) {
+            return quickSelect(points, left, partition - 1, k);
+        } else {
+            return quickSelect(points, partition + 1, right, k);
+        }
+    }
+
+    private int lomutoPartition(int[][] points, int left, int right) {
+        int pivotDistance = distance(points[right]);
+        int pivotPointer = left;
+
+        for (int i = left; i < right; i++) {
+            if (distance(points[i]) < pivotDistance) {
+                swap(points, i, pivotPointer);
+                pivotPointer++;
+            }
+        }
+
+        swap(points, right, pivotPointer);
+
+        return pivotPointer;
+    }
+
+    private void swap(int[][] points, int i, int j) {
+        int[] tmp = points[i];
+        points[i] = points[j];
+        points[j] = tmp;
+    }
+
+    /**
+     * Time complexity: O(nlog n)
+     * Space complexity: O(log n)
+     */
+    public int[][] kClosestViaSorting(int[][] points, int k) {
+        Arrays.sort(points, (p1, p2) -> Integer.compare(distance(p1), distance(p2)));
+        return Arrays.copyOfRange(points, 0, k);
+    }
+
     private int distance(int[] point) {
         return point[0] * point[0] + point[1] * point[1];
     }
diff --git a/src/heap/KthLargestElementInArray.java b/src/heap/KthLargestElementInArray.java
@@ -0,0 +1,67 @@
+package heap;
+
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+/**
+ * Description: https://leetcode.com/proiblems/kth-largest-element-in-an-array
+ * Difficulty: Medium
+ */
+public class KthLargestElementInArray {
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    public int findKthLargestViaQuickSelect(int[] nums, int k) {
+        return quickSelect(nums, 0, nums.length - 1, k);
+    }
+
+    private int quickSelect(int[] nums, int left, int right, int k) {
+        int pivotPointer = lomutoPartition(nums, left, right);
+
+        if (pivotPointer == k - 1) return nums[pivotPointer];
+
+        if (pivotPointer > k - 1) {
+            return quickSelect(nums, left, pivotPointer - 1, k);
+        } else {
+            return quickSelect(nums, pivotPointer + 1, right, k);
+        }
+    }
+
+    private int lomutoPartition(int[] nums, int left, int right) {
+        int pivot = nums[right];
+        int pivotPointer = left;
+
+        for (int i = left; i < right; i++) {
+            if (nums[i] > pivot) {
+                swap(nums, i, pivotPointer);
+                pivotPointer++;
+            }
+        }
+
+        swap(nums, pivotPointer, right);
+
+        return pivotPointer;
+    }
+
+    private void swap(int[] nums, int l, int r) {
+        int tmp = nums[l];
+        nums[l] = nums[r];
+        nums[r] = tmp;
+    }
+
+    /**
+     * Time complexity: O(nlog k)
+     * Space complexity: O(k)
+     */
+    public int findKthLargestViaMinHeap(int[] nums, int k) {
+        Queue<Integer> minHeap = new PriorityQueue<>();
+        for (int num : nums) {
+            minHeap.offer(num);
+            if (minHeap.size() > k) minHeap.poll();
+        }
+
+        return minHeap.peek();
+    }
+}
diff --git a/src/linked_list/SwapNodesInPairs.java b/src/linked_list/SwapNodesInPairs.java
@@ -0,0 +1,34 @@
+package linked_list;
+
+
+/**
+ * Description: https://leetcode.com/problems/swap-nodes-in-pairs
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class SwapNodesInPairs {
+
+    public ListNode swapPairs(ListNode head) {
+        if (head == null || head.next == null) return head;
+
+        ListNode dummy = new ListNode();
+        ListNode current = head;
+        ListNode prev = dummy;
+
+        while (current != null && current.next != null) {
+            prev.next = current.next;
+            current.next = current.next.next;
+            prev.next.next = current;
+
+            prev = current;
+            current = current.next;
+        }
+
+        return dummy.next;
+    }
+
+    private static class ListNode {
+        ListNode next;
+    }
+}
diff --git a/src/matrix/SetMatrixZeroes.java b/src/matrix/SetMatrixZeroes.java
@@ -0,0 +1,110 @@
+package matrix;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Description: https://leetcode.com/problems/set-matrix-zeroes
+ * Difficulty: Medium
+ */
+public class SetMatrixZeroes {
+
+    /**
+     * Time complexity: O(m * n)
+     * Space complexity: O(1)
+     */
+    public void setZeroesWithConstantSpace(int[][] matrix) {
+        // Use separate flags for the first col and row
+        boolean isFirstColZeroed = isFirstColZeroed(matrix);
+        boolean isFirstRowZeroed = isFirstRowZeroed(matrix);
+
+        // Use the first col and row cells as flags
+        markZeroedRowsAndCols(matrix);
+
+        // Set zeroes, but not in the first row and col
+        setZeroesInInnerMatrix(matrix);
+
+        if (isFirstColZeroed) setZeroesInFirstCol(matrix);
+        if (isFirstRowZeroed) setZeroesInFirstRow(matrix);
+    }
+
+    private static boolean isFirstColZeroed(int[][] matrix) {
+        for (int i = 0; i < matrix.length; i++) {
+            if (matrix[i][0] == 0) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static boolean isFirstRowZeroed(int[][] matrix) {
+        for (int j = 0; j < matrix[0].length; j++) {
+            if (matrix[0][j] == 0) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static void markZeroedRowsAndCols(int[][] matrix) {
+        for (int i = 1; i < matrix.length; i++) {
+            for (int j = 1; j < matrix[0].length; j++) {
+                if (matrix[i][j] == 0) {
+                    matrix[i][0] = 0;
+                    matrix[0][j] = 0;
+                }
+            }
+        }
+    }
+
+    private static void setZeroesInInnerMatrix(int[][] matrix) {
+        for (int i = 1; i < matrix.length; i++) {
+            for (int j = 1; j < matrix[0].length; j++) {
+                if (matrix[i][0] == 0 || matrix[0][j] == 0) {
+                    matrix[i][j] = 0;
+                }
+            }
+        }
+    }
+
+    private static void setZeroesInFirstCol(int[][] matrix) {
+        for (int i = 0; i < matrix.length; i++) {
+            matrix[i][0] = 0;
+        }
+    }
+
+
+    private static void setZeroesInFirstRow(int[][] matrix) {
+        for (int j = 0; j < matrix[0].length; j++) {
+            matrix[0][j] = 0;
+        }
+    }
+
+    /**
+     * Time complexity: O(m * n)
+     * Space complexity: O(m + n)
+     */
+    public void setZeroesViaTwoSets(int[][] matrix) {
+        Set<Integer> zeroedCols = new HashSet<>();
+        Set<Integer> zeroedRows = new HashSet<>();
+
+        for (int i = 0; i < matrix.length; i++) {
+            for (int j = 0; j < matrix[0].length; j++) {
+                if (matrix[i][j] == 0) {
+                    zeroedCols.add(i);
+                    zeroedRows.add(j);
+                }
+            }
+        }
+
+        for (int i = 0; i < matrix.length; i++) {
+            for (int j = 0; j < matrix[0].length; j++) {
+                if (zeroedCols.contains(i) || zeroedRows.contains(j)) {
+                    matrix[i][j] = 0;
+                }
+            }
+        }
+    }
+}
