Update

Author: ex01tus

README.md

@@ -2,7 +2,7 @@
 
 ![DSA Learning](https://img.shields.io/badge/DSA-Learning-blue?style=for-the-badge&logo=leetcode)
 
-This repository contains solutions for 534 DSA problems from the [LeetCode](https://leetcode.com/)
+This repository contains solutions for 537 DSA problems from the [LeetCode](https://leetcode.com/)
 website.
 
 Problems are separated into 19 topics:
@@ -13,14 +13,14 @@ Problems are separated into 19 topics:
 |  2 | Binary              | [binary](src/binary)                           |       13 |
 |  3 | Binary Search       | [binary_search](src/binary_search)             |       18 |
 |  4 | Binary Search Tree  | [binary_search_tree](src/binary_search_tree)   |       16 |
-|  5 | Binary Tree         | [binary_tree](src/binary_tree)                 |       46 |
+|  5 | Binary Tree         | [binary_tree](src/binary_tree)                 |       47 |
 |  6 | Design              | [design](src/design)                           |       18 |
 |  7 | Dynamic Programming | [dynamic_programming](src/dynamic_programming) |       48 |
-|  8 | Graph               | [graph](src/graph)                             |       65 |
+|  8 | Graph               | [graph](src/graph)                             |       66 |
 |  9 | Greedy Algorithms   | [greedy](src/greedy)                           |       21 |
 | 10 | Heap                | [heap](src/heap)                               |       21 |
 | 11 | Interval            | [interval](src/interval)                       |       11 |
-| 12 | Linked List         | [linked_list](src/linked_list)                 |       32 |
+| 12 | Linked List         | [linked_list](src/linked_list)                 |       33 |
 | 13 | Math                | [math](src/math)                               |       20 |
 | 14 | Matrix              | [matrix](src/matrix)                           |       18 |
 | 15 | Quad Tree           | [quad_tree](src/quad_tree)                     |        1 |

src/binary_tree/BinaryTreeLongestConsecutiveSequence.java

@@ -0,0 +1,31 @@
+package binary_tree;
+
+/**
+ * Description: https://leetcode.com/problems/binary-tree-longest-consecutive-sequence
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class BinaryTreeLongestConsecutiveSequence {
+
+    public int longestConsecutive(TreeNode root) {
+        return findLongestConsecutivePath(root, Integer.MIN_VALUE, 0);
+    }
+
+    private int findLongestConsecutivePath(TreeNode root, int prev, int path) {
+        if (root == null) return path;
+
+        path = (root.val == prev + 1) ? path + 1 : 1;
+
+        int left = findLongestConsecutivePath(root.left, root.val, path);
+        int right = findLongestConsecutivePath(root.right, root.val, path);
+
+        return Math.max(path, Math.max(left, right));
+    }
+
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+    }
+}

src/graph/KillProcess.java

@@ -0,0 +1,41 @@
+package graph;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/kill-process
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class KillProcess {
+
+    public List<Integer> killProcess(List<Integer> pid, List<Integer> ppid, int process) {
+        Map<Integer, List<Integer>> adjList = buildAdjList(pid, ppid);
+
+        List<Integer> killed = new ArrayList<>();
+        kill(process, adjList, killed);
+
+        return killed;
+    }
+
+    private Map<Integer, List<Integer>> buildAdjList(List<Integer> pid, List<Integer> ppid) {
+        Map<Integer, List<Integer>> adjList = new HashMap<>();
+        for (int i = 0; i < pid.size(); i++) {
+            adjList.computeIfAbsent(ppid.get(i), __ -> new ArrayList<>()).add(pid.get(i));
+        }
+
+        return adjList;
+    }
+
+    private void kill(int process, Map<Integer, List<Integer>> adjList, List<Integer> killed) {
+        killed.add(process);
+
+        for (int child : adjList.getOrDefault(process, List.of())) {
+            kill(child, adjList, killed);
+        }
+    }
+}

src/heap/LeastNumberOfUniqueIntegersAfterKRemovals.java

@@ -27,6 +27,7 @@ private Queue<Map.Entry<Integer, Integer>> buildHeap(Map<Integer, Integer> freqM
         for (Map.Entry<Integer, Integer> e : freqMap.entrySet()) {
             minHeap.offer(e);
         }
+
         return minHeap;
     }
 

src/linked_list/InsertIntoSortedCircularLinkedList.java

@@ -0,0 +1,54 @@
+package linked_list;
+
+/**
+ * Description: https://leetcode.com/problems/insert-into-a-sorted-circular-linked-list
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class InsertIntoSortedCircularLinkedList {
+
+    public Node insert(Node head, int insertVal) {
+        if (head == null) return createCircularList(insertVal);
+
+        Node current = findInsertionPosition(head, insertVal);
+        Node next = current.next;
+        Node inserted = new Node(insertVal);
+        current.next = inserted;
+        inserted.next = next;
+
+        return head;
+    }
+
+    private Node findInsertionPosition(Node head, int insertVal) {
+        Node current = head;
+
+        while (current.next != head) {
+            if (current.val <= current.next.val) {
+                if (current.val <= insertVal && current.next.val >= insertVal) break;
+            } else {
+                if (current.val <= insertVal || current.next.val >= insertVal) break;
+            }
+
+            current = current.next;
+        }
+
+        return current;
+    }
+
+    private Node createCircularList(int insertVal) {
+        Node head = new Node(insertVal);
+        head.next = head;
+
+        return head;
+    }
+
+    private static class Node {
+        int val;
+        Node next;
+
+        public Node(int val) {
+            this.val = val;
+        }
+    }
+}