Added priority queue problem solutions

Author: Avdeev99

AlgorithmsAndDS/AlgorithmsAndDS/PriorityQueue/Easy/KthLargestElementInStream.cs

@@ -0,0 +1,38 @@
+using System.Collections.Generic;
+
+namespace ConsoleApp1.PriorityQueue.Easy;
+
+// 703. Kth Largest Element in a Stream
+public class KthLargest
+{
+    private PriorityQueue<int, int> _priorityQueue;
+    private int k;
+
+    public KthLargest(int k, int[] nums)
+    {
+        _priorityQueue = new PriorityQueue<int, int>();
+        this.k = k;
+        InitQueue(nums);
+    }
+
+    // Time complexity: O(log(n));
+    public int Add(int val)
+    {
+        if (_priorityQueue.Count < k)
+            _priorityQueue.Enqueue(val, val);
+        else if (val > _priorityQueue.Peek())
+        {
+            _priorityQueue.Dequeue();
+            _priorityQueue.Enqueue(val, val);
+        }
+
+        return _priorityQueue.Peek();
+    }
+
+    // Time complexity: O(nlog(k)); Space complexity: O(k).
+    public void InitQueue(int[] nums)
+    {
+        foreach (var item in nums)
+            Add(item);
+    }
+}

AlgorithmsAndDS/AlgorithmsAndDS/PriorityQueue/Easy/LastStoneWeight.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ConsoleApp1.PriorityQueue.Easy;
+
+// 1046. Last Stone Weight
+public class LastStoneWeight
+{
+    // Time complexity: O(nlog(n)); Space complexity: O(n).
+    public int GetLastStoneWeight(int[] stones)
+    {
+        var stonesWithPriority = stones.Select(item => (item, item));
+        var priorityQueue = new PriorityQueue<int, int>(
+            stonesWithPriority,
+            Comparer<int>.Create((x,y) => y-x)
+        );
+
+        while (priorityQueue.Count > 1)
+        {
+            var stone1 = priorityQueue.Dequeue();
+            var stone2 = priorityQueue.Dequeue();
+
+            var diff = stone1 - stone2;
+
+            if (diff != 0) priorityQueue.Enqueue(diff, diff);
+        }
+
+        return priorityQueue.Count > 0 ? priorityQueue.Peek() : 0;
+    }
+}

AlgorithmsAndDS/AlgorithmsAndDS/Trees/Easy/SymmetricTree.cs

@@ -3,8 +3,10 @@
 
 namespace ConsoleApp1.Trees.Easy;
 
+// 101. Symmetric Tree
 public class SymmetricTree
 {
+    // Time complexity: O(n); Space complexity: O(h) - height of the tree.
     public bool IsSymmetric(TreeNode root)
     {
         if (root == null) return true;
@@ -32,4 +34,24 @@ public bool IsSymmetric(TreeNode root)
 
         return true;
     }
+    
+    // Time complexity: O(n); Space complexity: O(h) - height of the tree.
+    public bool IsSymmetric2(TreeNode root)
+    {
+        if (root == null)
+            return true;
+
+        return IsMirror(root.left, root.right);
+    }
+    
+    private bool IsMirror(TreeNode node1, TreeNode node2)
+    {
+        if (node1 == null && node2 == null)
+            return true;
+
+        if (node1 == null || node2 == null)
+            return false;
+
+        return node1.val == node2.val && IsMirror(node1.left, node2.right) && IsMirror(node1.right, node2.left);
+    }
 }

README.md

@@ -14,6 +14,7 @@
 - [Binary Search](#binary-search)
 - [Linked List](#linked-list)
 - [Trees](#trees)
+- [Priority Queue](#priority-queue)
 - [Hints](#hints)
 
 ## Arrays & Hashing
@@ -97,6 +98,7 @@
 | ------- | ---------- | --------------- | ---------------- | -------------- |
 | [94. Binary Tree Inorder Traversal](AlgorithmsAndDS/AlgorithmsAndDS/Trees/Easy/BinaryTreeInorderTraversal.cs) | Easy | O(n) | O(n) | - For iterative approach use stack (while stack.Any || currNode != null) <br /> - If currNode != null - push node to stack, go left  <br /> - If currNode == null - get prevNode from stack, add value to result,go the prevNode.right |
 | [100. Same Tree](AlgorithmsAndDS/AlgorithmsAndDS/Trees/Easy/SameTree.cs) | Easy | O(n) | O(n) | Check that values of trees nodes are equal, use recursion to repeat for each node (left and right) |
+| [101. Symmetric Tree](AlgorithmsAndDS/AlgorithmsAndDS/Trees/Easy/SymmetricTree.cs) | Easy | O(n) | O(h) | - Start to check from root left and right children <br /> - If both null - return true, if onle one is null - false, then if left.val != right.val - return false  <br /> - Then we need to check node1.left with node2.right and node1.right with node2.left (repeat recursively) |
 | [104. Maximum Depth of Binary Tree](AlgorithmsAndDS/AlgorithmsAndDS/Trees/Easy/MaximumDepthOfBinaryTree.cs) | Easy | O(n) | O(n) | - DFS iterative - use stack to store nodes and depth <br /> - BFS iterative - use queue to count levels <br /> - Recursion - return Max of recursive calls of left and right children + 1 |
 | [108. Convert Sorted Array to Binary Search Tree](AlgorithmsAndDS/AlgorithmsAndDS/Trees/Easy/ConvertSortedArrayToBinarySearchTree.cs) | Easy | O(n) | O(log(n)) | - Use **Divide and Conquer** approach: mid value - node value, left subarray - left subtree, right subarray - right subtree <br /> - Use recursion for both left and right subtrees |
 | [110. Balanced Binary Tree](AlgorithmsAndDS/AlgorithmsAndDS/Trees/Easy/MaximumDepthOfBinaryTree.cs) | Easy | O(n) | O(n) | - Find max depth of left and right children <br /> - Difference should be <= 1 <br /> - Repeat recursively for each node, if diff is invalid - mark result flag|
@@ -108,6 +110,13 @@
 | [572. Subtree of Another Tree](AlgorithmsAndDS/AlgorithmsAndDS/Trees/Easy/SubtreeOfAnotherTree.cs) | Easy | O(nm) | O(nm) | For each node where value = subroot.value we need to check if it is SameTree(problem 100) or node.left/node.right is SameTree as subroot |
 | [606. Construct String from Binary Tree](AlgorithmsAndDS/AlgorithmsAndDS/Trees/Easy/ConstructStringFromBinaryTree.cs) | Easy | O(n) | O(n) | Use DFS to recursively build string with PreOrder Traversal |
 
+## Priority Queue
+
+| Problem | Complexity | Time Complexity | Space Complexity | Solution Hints |
+| ------- | ---------- | --------------- | ---------------- | -------------- |
+| [703. Kth Largest Element in a Stream](AlgorithmsAndDS/AlgorithmsAndDS/PriorityQueue/Easy/KthLargestElementInStream.cs) | Easy | O(log(n)) | O(k) | - Put elements to MinHeap always maintaining k elements  <br /> - During adding peek element from queue and compare with value, dequeue and enqueue new value if it is greater |
+| [1046. Last Stone Weight](AlgorithmsAndDS/AlgorithmsAndDS/PriorityQueue/Easy/LastStoneWeight.cs) | Easy | O(nlog(n)) | O(n) | - Put all elements into a priority queue <br /> - Pop out the two biggest, push back the difference, until there are no more two elements left |
+
 ## Hints
 
 - Find range sum/sum in array - prefix/postfix sum of array