diff --git a/README.md b/README.md
index 99444f5..409cca5 100644
--- a/README.md
+++ b/README.md
@@ -7,17 +7,20 @@
This repository contains awesome LeetCode resources to learn Data Structures and Algorithms (DSA) and prepare for Coding interviews.
+👉 If you want to master DSA patterns, checkout [AlgoMaster.io](https://algomaster.io)
+
## 💡 Tips
-- [How to Start LeetCode](https://www.youtube.com/watch?v=Nx4bvwU0DqE)
- [How I Mastered DSA](https://blog.algomaster.io/p/how-i-mastered-data-structures-and-algorithms)
+- [How to Start LeetCode](https://blog.algomaster.io/p/how-to-start-leetcode-in-2025)
+- [15 Leetcode Patterns](https://blog.algomaster.io/p/15-leetcode-patterns)
## 📌 Fundamental Concepts
- [Algorithmic Complexity](https://blog.algomaster.io/p/57bd4963-462f-4294-a972-4012691fc729)
- [Big-O Cheat Sheet](https://www.bigocheatsheet.com/)
+- [Arrays](https://www.youtube.com/watch?v=SlNq09scdWE&list=PLK63NuByH5o9odyBT7nfYkHZyvGQ5oVp2)
- [Bit Manipulation Techniques](https://blog.algomaster.io/p/c650df76-f978-46ee-a572-eb13c354905d)
- [Sorting Algorithms](https://medium.com/jl-codes/understanding-sorting-algorithms-af6222995c8)
-- [Linked List](https://leetcode.com/discuss/study-guide/1800120/become-master-in-linked-list)
- - [Dummy Node Technique](https://blog.algomaster.io/p/5d7a1368-7a0c-461a-93a9-732333ceb2a8)
+- [Linked List](https://www.youtube.com/watch?v=FbHf0ii0WDg&list=PLK63NuByH5o9odyBT7nfYkHZyvGQ5oVp2)
- [Queues](https://medium.com/basecs/to-queue-or-not-to-queue-2653bcde5b04)
- [Stacks](https://medium.com/basecs/stacks-and-overflows-dbcf7854dc67)
- [Hash Tables](https://medium.com/basecs/taking-hash-tables-off-the-shelf-139cbf4752f0)
@@ -29,8 +32,8 @@ This repository contains awesome LeetCode resources to learn Data Structures and
- [Binary Search](https://leetcode.com/discuss/study-guide/786126/Python-Powerful-Ultimate-Binary-Search-Template.-Solved-many-problems)
- [Greedy Algorithm](https://www.freecodecamp.org/news/greedy-algorithms/)
- [Dynamic Programming](https://medium.com/basecs/less-repetition-more-dynamic-programming-43d29830a630)
-- [Graph Theory](https://medium.com/basecs/a-gentle-introduction-to-graph-theory-77969829ead8)
-- [Important Graph Algorithms](https://blog.algomaster.io/p/master-graph-algorithms-for-coding)
+- [Graph Theory](https://www.youtube.com/watch?v=xN5VGzK9_FQ&list=PLK63NuByH5o9odyBT7nfYkHZyvGQ5oVp2)
+- [Master Graph Algorithms](https://blog.algomaster.io/p/master-graph-algorithms-for-coding)
- [DFS Traversal](https://medium.com/basecs/deep-dive-through-a-graph-dfs-traversal-8177df5d0f13)
- [BFS Traversal](https://medium.com/basecs/going-broad-in-a-graph-bfs-traversal-959bd1a09255)
- [Union-Find](https://leetcode.com/discuss/general-discussion/1072418/Disjoint-Set-Union-(DSU)Union-Find-A-Complete-Guide)
@@ -40,12 +43,14 @@ This repository contains awesome LeetCode resources to learn Data Structures and
## 🚀 Patterns
- [15 Leetcode Patterns](https://blog.algomaster.io/p/15-leetcode-patterns)
- [20 DP Patterns](https://blog.algomaster.io/p/20-patterns-to-master-dynamic-programming)
-- [Prefix Sum Pattern](https://blog.algomaster.io/p/f96dd3de-c89c-428e-a88d-b1f751a42a57)
-- [Two Pointers Pattern](https://blog.algomaster.io/p/69025a2e-b0d5-4705-8507-bba16c2691f1)
-- [Linked List In-place Reversal Pattern](https://blog.algomaster.io/p/7dcce8e9-beee-4fef-8874-7aae025031b1)
-- [Sliding Window Pattern](https://blog.algomaster.io/p/f4412a17-7a3a-4d0b-8e39-9ea8f429bf7c)
-- [Top 'K' Elements Pattern](https://blog.algomaster.io/p/322aac40-c4d0-4e54-980d-b22d9eeebca6)
-- [Monotonic Stack Pattern](https://blog.algomaster.io/p/5dabff21-11f4-470d-8e38-76ff07c63fdf)
+- [Two Pointers Pattern](https://www.youtube.com/watch?v=QzZ7nmouLTI&list=PLK63NuByH5o9odyBT7nfYkHZyvGQ5oVp2)
+- [Sliding Window Pattern](https://www.youtube.com/watch?v=y2d0VHdvfdc&list=PLK63NuByH5o9odyBT7nfYkHZyvGQ5oVp2)
+- [Prefix Sum Pattern](https://www.youtube.com/watch?v=yuws7YK0Yng&list=PLK63NuByH5o9odyBT7nfYkHZyvGQ5oVp2)
+- [Fast and Slow Pointers Pattern](https://www.youtube.com/watch?v=b139yf7Ik-E&list=PLK63NuByH5o9odyBT7nfYkHZyvGQ5oVp2)
+- [Top 'K' Elements Pattern](https://www.youtube.com/watch?v=6_v6OoxvMOE&list=PLK63NuByH5o9odyBT7nfYkHZyvGQ5oVp2)
+- [Kadane's Algorithm](https://www.youtube.com/watch?v=NUWAXbSlsws&list=PLK63NuByH5o9odyBT7nfYkHZyvGQ5oVp2)
+- [Linked List In-place Reversal Pattern](https://www.youtube.com/watch?v=auoTGovuo9A&list=PLK63NuByH5o9odyBT7nfYkHZyvGQ5oVp2)
+- [Monotonic Stack Pattern](https://www.youtube.com/watch?v=DtJVwbbicjQ&list=PLK63NuByH5o9odyBT7nfYkHZyvGQ5oVp2)
- [Overlapping Intervals Pattern](https://blog.algomaster.io/p/812e72f7-eced-4256-a4c1-00606ae50679)
- [Backtracking Pattern](https://blog.algomaster.io/p/81d42ca2-600c-4252-aa33-a56462090048)
- [Modified Binary Search Pattern](https://blog.algomaster.io/p/d0d81b04-4c2a-4b45-a101-5137c3146686)
@@ -69,7 +74,15 @@ This repository contains awesome LeetCode resources to learn Data Structures and
- [Dynamic Programming Patterns](https://leetcode.com/discuss/study-guide/458695/Dynamic-Programming-Patterns)
- [Stock Series Patterns](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/solutions/108870/most-consistent-ways-of-dealing-with-the-series-of-stock-problems/)
+## ✅ Curated Problems
+- [AlgoMaster 300](https://algomaster.io/practice/dsa-patterns)
+- [Blind 75](https://leetcode.com/discuss/general-discussion/460599/blind-75-leetcode-questions)
+- [Leetcode Top 100 Liked](https://leetcode.com/studyplan/top-100-liked/)
+- [Leetcode Top Interview 150](https://leetcode.com/studyplan/top-interview-150/)
+
## 📺 YouTube Playlist
+- [AlgoMaster DSA Playlist](https://www.youtube.com/playlist?list=PLK63NuByH5o9odyBT7nfYkHZyvGQ5oVp2&pp=gAQB)
+- [AlgoMaster LeetCode Pattern Playlist](https://www.youtube.com/playlist?list=PLK63NuByH5o-tqaMUHRA4r8ObRW7PWz45)
- [Abdul Bari's Algorithms Playlist](https://www.youtube.com/playlist?list=PLDN4rrl48XKpZkf03iYFl-O29szjTrs_O)
- [William Fiset's Data Structure Playlist](https://www.youtube.com/playlist?list=PLDV1Zeh2NRsB6SWUrDFW2RmDotAfPbeHu)
- [William Fiset's Graphs Playlist](https://www.youtube.com/playlist?list=PLDV1Zeh2NRsDGO4--qE8yH72HFL1Km93P)
@@ -80,8 +93,11 @@ This repository contains awesome LeetCode resources to learn Data Structures and
- [Coursera - Algorithms, Part 2](https://www.coursera.org/learn/algorithms-part2)
## 📚 Books
-- [Data Structures And Algorithms Made Easy](https://www.amazon.com/Data-Structures-Algorithms-Made-Easy-ebook/dp/B0CBW278NC/)
-- [Cracking the Coding Interview](https://www.amazon.com/Cracking-Coding-Interview-Programming-Questions/dp/0984782850/)
+- [Data Structures And Algorithms Made Easy](https://www.amazon.in/dp/B08CMLS7LZ)
+- [Cracking the Coding Interview](https://www.amazon.in/dp/0984782850)
+
+## 📩 Newsletter
+- [AlgoMaster Newsletter](https://blog.algomaster.io/)
## 🔎 Visualization
- [VisuAlgo](https://visualgo.net/en)
@@ -94,76 +110,10 @@ This repository contains awesome LeetCode resources to learn Data Structures and
- [LeetHub v2](https://chromewebstore.google.com/detail/leethub-v2/mhanfgfagplhgemhjfeolkkdidbakocm?hl=en): Automatically integrate your Leetcode & GeeksforGeeks submissions to GitHub.
- [LeetCode VS Code Extension](https://marketplace.visualstudio.com/items?itemName=LeetCode.vscode-leetcode): Solve LeetCode problems in VS Code.
-## ✅ Curated Problems
-- [Blind 75](https://leetcode.com/discuss/general-discussion/460599/blind-75-leetcode-questions)
-- [Leetcode Top 100 Liked](https://leetcode.com/studyplan/top-100-liked/)
-- [Leetcode Top Interview 150](https://leetcode.com/studyplan/top-interview-150/)
-
-## 💻 Must-Do Problems (Topic Wise)
-### Linked List
-- [Reverse Linked List](https://leetcode.com/problems/reverse-linked-list/description/)
-- [Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/description/)
-- [Merge Two Sorted Lists](https://leetcode.com/problems/merge-two-sorted-lists/description/)
-- [Intersection of Two Linked Lists](https://leetcode.com/problems/intersection-of-two-linked-lists/description/)
-- [Remove Nth Node From End of List](https://leetcode.com/problems/remove-nth-node-from-end-of-list/description/)
-- [Add Two Numbers](https://leetcode.com/problems/add-two-numbers/description/)
-- [Copy List with Random Pointer](https://leetcode.com/problems/copy-list-with-random-pointer/description/)
-- [Flatten a Multilevel Doubly Linked List](https://leetcode.com/problems/flatten-a-multilevel-doubly-linked-list)
-- [Rotate List](https://leetcode.com/problems/rotate-list/description/)
-- [Sort List](https://leetcode.com/problems/sort-list/description/)
-- [Remove Duplicates from Sorted List II](https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/description/)
-- [LRU Cache](https://leetcode.com/problems/lru-cache/description/)
-- [Design Browser History](https://leetcode.com/problems/design-browser-history/description/)
-- [Merge k Sorted Lists](https://leetcode.com/problems/merge-k-sorted-lists/description/)
-- [Reverse Nodes in k-Group](https://leetcode.com/problems/reverse-nodes-in-k-group/description/)
-### Binary Trees
- - [Invert Binary Tree](https://leetcode.com/problems/invert-binary-tree/description/)
- - [Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/description/)
- - [Count Complete Tree Nodes](https://leetcode.com/problems/count-complete-tree-nodes/description/)
- - [All Possible Full Binary Trees](https://leetcode.com/problems/all-possible-full-binary-trees/description/)
- - [Delete Leaves With a Given Value](https://leetcode.com/problems/delete-leaves-with-a-given-value/description/)
- - [Binary Search Tree Iterator](https://leetcode.com/problems/binary-search-tree-iterator/description/)
- - [Longest Univalue Path](https://leetcode.com/problems/longest-univalue-path/description/)
- - [Delete Nodes And Return Forest](https://leetcode.com/problems/delete-nodes-and-return-forest/description/)
- - [Validate Binary Search Tree](https://leetcode.com/problems/validate-binary-search-tree/description/)
- - [Construct Binary Tree from Inorder and Postorder Traversal](https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/description/)
- - [All Nodes Distance K in Binary Tree](https://leetcode.com/problems/all-nodes-distance-k-in-binary-tree/description/)
- - [Maximum Difference Between Node and Ancestor](https://leetcode.com/problems/maximum-difference-between-node-and-ancestor/description/)
- - [Find Duplicate Subtrees](https://leetcode.com/problems/find-duplicate-subtrees/description/)
- - [Flatten Binary Tree to Linked List](https://leetcode.com/problems/flatten-binary-tree-to-linked-list/description/)
- - [House Robber III](https://leetcode.com/problems/house-robber-iii/description/)
- - [Step-By-Step Directions From a Binary Tree Node to Another](https://leetcode.com/problems/step-by-step-directions-from-a-binary-tree-node-to-another/description/)
- - [Delete Node in a BST](https://leetcode.com/problems/delete-node-in-a-bst/description/)
- - [Populating Next Right Pointers in Each Node II](https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/description/)
- - [Trim a Binary Search Tree](https://leetcode.com/problems/trim-a-binary-search-tree/description/)
- - [Distribute Coins in Binary Tree](https://leetcode.com/problems/distribute-coins-in-binary-tree/description/)
- - [Binary Search Tree to Greater Sum Tree](https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/description/)
- - [Serialize and Deserialize Binary Tree](https://leetcode.com/problems/serialize-and-deserialize-binary-tree/description/)
- - [Binary Tree Cameras](https://leetcode.com/problems/binary-tree-cameras/description/)
- - [Binary Tree Maximum Path Sum](https://leetcode.com/problems/binary-tree-maximum-path-sum/description/)
- - [Maximum Sum BST in Binary Tree](https://leetcode.com/problems/maximum-sum-bst-in-binary-tree/description/)
-### Backtracking
-- [Permutations](https://leetcode.com/problems/permutations/description/)
-- [Subsets](https://leetcode.com/problems/subsets/description/)
-- [Generate Parentheses](https://leetcode.com/problems/generate-parentheses/description/)
-- [Combination Sum](https://leetcode.com/problems/combination-sum/description/)
-- [Palindrome Partitioning](https://leetcode.com/problems/palindrome-partitioning/description/)
-- [Letter Combinations of a Phone Number](https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/)
-- [Unique Binary Search Trees II](https://leetcode.com/problems/unique-binary-search-trees-ii/description/)
-- [Partition to K Equal Sum Subsets](https://leetcode.com/problems/partition-to-k-equal-sum-subsets/description/)
-- [N-Queens II](https://leetcode.com/problems/n-queens-ii/description/)
-- [Sudoku Solver](https://leetcode.com/problems/sudoku-solver/description/)
-### Tries
- - [Implement Trie (Prefix Tree)](https://leetcode.com/problems/implement-trie-prefix-tree/description/)
- - [Longest Common Prefix](https://leetcode.com/problems/longest-common-prefix/description/)
- - [Search Suggestions System](https://leetcode.com/problems/search-suggestions-system/description/)
- - [Longest Word in Dictionary](https://leetcode.com/problems/longest-word-in-dictionary/description/)
- - [Top K Frequent Words](https://leetcode.com/problems/top-k-frequent-words/description/)
- - [Design Add and Search Words Data Structure](https://leetcode.com/problems/design-add-and-search-words-data-structure/description/)
- - [Implement Magic Dictionary](https://leetcode.com/problems/implement-magic-dictionary/description/)
- - [Replace Words](https://leetcode.com/problems/replace-words/description/)
- - [Word Search II](https://leetcode.com/problems/word-search-ii/description/)
- - [Stream of Characters](https://leetcode.com/problems/stream-of-characters/description/)
+Your contributions are most welcome!
+---
-Your contributions are most welcome!
+
+ If you find this resource helpful, please give it a star ⭐️ and share it with others!
+
diff --git a/patterns/c#/KadaneAlgorithm.cs b/patterns/c#/KadaneAlgorithm.cs
new file mode 100644
index 0000000..f27991b
--- /dev/null
+++ b/patterns/c#/KadaneAlgorithm.cs
@@ -0,0 +1,14 @@
+using System;
+
+public class KadaneAlgorithm {
+ public int MaxSubArray(int[] nums) {
+ int currentSum = nums[0];
+ int maxSum = nums[0];
+
+ for (int i = 1; i < nums.Length; i++) {
+ currentSum = Math.Max(nums[i], currentSum + nums[i]);
+ maxSum = Math.Max(maxSum, currentSum);
+ }
+ return maxSum;
+ }
+}
\ No newline at end of file
diff --git a/patterns/c#/LevelOrderTraversal.cs b/patterns/c#/LevelOrderTraversal.cs
new file mode 100644
index 0000000..05b2a53
--- /dev/null
+++ b/patterns/c#/LevelOrderTraversal.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+
+public class TreeNode {
+ public int val;
+ public TreeNode left;
+ public TreeNode right;
+
+ public TreeNode(int x) {
+ val = x;
+ }
+}
+
+public class LevelOrderTraversal {
+ public void LevelOrder(TreeNode root) {
+ if (root == null) return;
+
+ Queue queue = new Queue();
+ queue.Enqueue(root);
+
+ while (queue.Count > 0) {
+ TreeNode node = queue.Dequeue();
+ Console.Write(node.val + " "); // Process the node by printing its value
+
+ // Add the left and right children to the queue, if they exist
+ if (node.left != null) queue.Enqueue(node.left);
+ if (node.right != null) queue.Enqueue(node.right);
+ }
+ }
+}
\ No newline at end of file
diff --git a/patterns/c#/MonotonicStack.cs b/patterns/c#/MonotonicStack.cs
new file mode 100644
index 0000000..2d1d89e
--- /dev/null
+++ b/patterns/c#/MonotonicStack.cs
@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+
+public class MonotonicStack {
+ public int[] NextGreaterElement(int[] nums) {
+ int n = nums.Length;
+ int[] result = new int[n];
+ Array.Fill(result, -1); // Default to -1 if no greater element exists
+ Stack stack = new Stack(); // Stack stores indices
+
+ for (int i = 0; i < n; i++) {
+ while (stack.Count > 0 && nums[i] > nums[stack.Peek()]) {
+ int index = stack.Pop();
+ result[index] = nums[i];
+ }
+ stack.Push(i);
+ }
+ return result;
+ }
+
+ public int[] DailyTemperatures(int[] temperatures) {
+ int n = temperatures.Length;
+ int[] result = new int[n]; // Result array initialized with 0s
+ Stack stack = new Stack(); // Monotonic decreasing stack
+
+ for (int i = 0; i < n; i++) {
+ while (stack.Count > 0 && temperatures[i] > temperatures[stack.Peek()]) {
+ int prevIndex = stack.Pop();
+ result[prevIndex] = i - prevIndex;
+ }
+ stack.Push(i);
+ }
+ return result;
+ }
+}
\ No newline at end of file
diff --git a/patterns/c#/ReverseList.cs b/patterns/c#/ReverseList.cs
new file mode 100644
index 0000000..1dd3572
--- /dev/null
+++ b/patterns/c#/ReverseList.cs
@@ -0,0 +1,23 @@
+public class ListNode {
+ public int val;
+ public ListNode next;
+ public ListNode(int val = 0, ListNode next = null) {
+ this.val = val;
+ this.next = next;
+ }
+}
+
+public class Solution {
+ public ListNode ReverseList(ListNode head) {
+ ListNode prev = null;
+ ListNode curr = head;
+
+ while (curr != null) {
+ ListNode next = curr.next;
+ curr.next = prev;
+ prev = curr;
+ curr = next;
+ }
+ return prev;
+ }
+}
\ No newline at end of file
diff --git a/patterns/c#/SlidingWindow.cs b/patterns/c#/SlidingWindow.cs
new file mode 100644
index 0000000..78fe833
--- /dev/null
+++ b/patterns/c#/SlidingWindow.cs
@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+
+public class SlidingWindow {
+ public double FindMaxAverageBruteForce(int[] nums, int k) {
+ int n = nums.Length;
+ double maxAvg = double.MinValue;
+
+ for (int i = 0; i <= n - k; i++) {
+ int sum = 0;
+ for (int j = i; j < i + k; j++) {
+ sum += nums[j];
+ }
+ maxAvg = Math.Max(maxAvg, (double)sum / k);
+ }
+ return maxAvg;
+ }
+
+ public double FindMaxAverageSlidingWindow(int[] nums, int k) {
+ int n = nums.Length;
+ int sum = 0;
+
+ for (int i = 0; i < k; i++) {
+ sum += nums[i];
+ }
+
+ int maxSum = sum;
+
+ for (int i = k; i < n; i++) {
+ sum += nums[i];
+ sum -= nums[i - k];
+ maxSum = Math.Max(maxSum, sum);
+ }
+
+ return (double)maxSum / k;
+ }
+
+ public int LengthOfLongestSubstringSlidingWindow(string s) {
+ HashSet seen = new HashSet();
+ int maxLength = 0, left = 0;
+
+ for (int right = 0; right < s.Length; right++) {
+ while (seen.Contains(s[right])) {
+ seen.Remove(s[left]);
+ left++;
+ }
+ seen.Add(s[right]);
+ maxLength = Math.Max(maxLength, right - left + 1);
+ }
+ return maxLength;
+ }
+
+ public int LengthOfLongestSubstringSlidingWindowFrequencyArray(string s) {
+ int[] freq = new int[128];
+ int maxLength = 0, left = 0;
+
+ for (int right = 0; right < s.Length; right++) {
+ freq[s[right]]++;
+
+ while (freq[s[right]] > 1) {
+ freq[s[left]]--;
+ left++;
+ }
+
+ maxLength = Math.Max(maxLength, right - left + 1);
+ }
+ return maxLength;
+ }
+}
\ No newline at end of file
diff --git a/patterns/c#/TwoPointers.cs b/patterns/c#/TwoPointers.cs
new file mode 100644
index 0000000..086b691
--- /dev/null
+++ b/patterns/c#/TwoPointers.cs
@@ -0,0 +1,59 @@
+using System;
+
+public class TwoPointers {
+ // Move Zeroes using Two Pointers
+ public void MoveZeroesTwoPointers(int[] nums) {
+ int left = 0; // Pointer for placing non-zero elements
+
+ // Iterate with right pointer
+ for (int right = 0; right < nums.Length; right++) {
+ if (nums[right] != 0) {
+ // Swap elements if right pointer finds a non-zero
+ (nums[left], nums[right]) = (nums[right], nums[left]);
+ left++; // Move left pointer forward
+ }
+ }
+ }
+
+ // Brute Force approach for Container with Most Water
+ public int MaxAreaBruteForce(int[] height) {
+ int n = height.Length;
+ int maxArea = 0;
+
+ // Check all pairs (i, j)
+ for (int i = 0; i < n; i++) {
+ for (int j = i + 1; j < n; j++) {
+ // Compute the minimum height and width
+ int minHeight = Math.Min(height[i], height[j]);
+ int width = j - i;
+ int area = minHeight * width; // Compute water contained
+
+ maxArea = Math.Max(maxArea, area); // Update max water
+ }
+ }
+ return maxArea;
+ }
+
+ // Two Pointers approach for Container with Most Water
+ public int MaxAreaTwoPointers(int[] height) {
+ int left = 0, right = height.Length - 1;
+ int maxArea = 0;
+
+ // Move pointers toward each other
+ while (left < right) {
+ int width = right - left; // Distance between lines
+ int minHeight = Math.Min(height[left], height[right]); // Compute height
+ int area = minHeight * width; // Compute water contained
+
+ maxArea = Math.Max(maxArea, area); // Update max water
+
+ // Move the pointer pointing to the shorter height
+ if (height[left] < height[right]) {
+ left++; // Move left pointer forward
+ } else {
+ right--; // Move right pointer backward
+ }
+ }
+ return maxArea;
+ }
+}
\ No newline at end of file
diff --git a/patterns/c++/KadaneAlgorithm.cpp b/patterns/c++/KadaneAlgorithm.cpp
new file mode 100644
index 0000000..609f6ed
--- /dev/null
+++ b/patterns/c++/KadaneAlgorithm.cpp
@@ -0,0 +1,19 @@
+#include
+#include // For std::max
+
+class KadaneAlgorithm {
+public:
+ int maxSubArray(std::vector& nums) {
+ int currentSum = nums[0]; // Start with the first element
+ int maxSum = nums[0]; // Initialize maxSum with the first element
+
+ // Traverse the array from the second element
+ for (size_t i = 1; i < nums.size(); i++) {
+ // If currentSum is negative, reset to current element
+ currentSum = std::max(nums[i], currentSum + nums[i]);
+ // Update maxSum if currentSum is greater
+ maxSum = std::max(maxSum, currentSum);
+ }
+ return maxSum;
+ }
+};
\ No newline at end of file
diff --git a/patterns/c++/LevelOrderTraversal.cpp b/patterns/c++/LevelOrderTraversal.cpp
new file mode 100644
index 0000000..d32a116
--- /dev/null
+++ b/patterns/c++/LevelOrderTraversal.cpp
@@ -0,0 +1,32 @@
+#include
+#include
+using namespace std;
+
+// Definition for a binary tree node.
+struct TreeNode {
+ int val;
+ TreeNode* left;
+ TreeNode* right;
+
+ TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+};
+
+class LevelOrderTraversal {
+public:
+ void levelOrder(TreeNode* root) {
+ if (root == nullptr) return;
+
+ queue q;
+ q.push(root);
+
+ while (!q.empty()) {
+ TreeNode* node = q.front();
+ q.pop();
+ cout << node->val << " "; // Process the node by printing its value
+
+ // Add the left and right children to the queue, if they exist
+ if (node->left != nullptr) q.push(node->left);
+ if (node->right != nullptr) q.push(node->right);
+ }
+ }
+};
\ No newline at end of file
diff --git a/patterns/c++/MonotonicStack.cpp b/patterns/c++/MonotonicStack.cpp
new file mode 100644
index 0000000..e7ae2c8
--- /dev/null
+++ b/patterns/c++/MonotonicStack.cpp
@@ -0,0 +1,39 @@
+#include
+#include
+
+using namespace std;
+
+class MonotonicStack {
+public:
+ vector nextGreaterElement(vector& nums) {
+ int n = nums.size();
+ vector result(n, -1); // Default to -1 if no greater element exists
+ stack stack; // Stack stores indices
+
+ for (int i = 0; i < n; i++) {
+ while (!stack.empty() && nums[i] > nums[stack.top()]) {
+ int index = stack.top();
+ stack.pop();
+ result[index] = nums[i];
+ }
+ stack.push(i);
+ }
+ return result;
+ }
+
+ vector dailyTemperatures(vector& temperatures) {
+ int n = temperatures.size();
+ vector result(n, 0);
+ stack stack; // Monotonic decreasing stack
+
+ for (int i = 0; i < n; i++) {
+ while (!stack.empty() && temperatures[i] > temperatures[stack.top()]) {
+ int prevIndex = stack.top();
+ stack.pop();
+ result[prevIndex] = i - prevIndex;
+ }
+ stack.push(i);
+ }
+ return result;
+ }
+};
\ No newline at end of file
diff --git a/patterns/c++/ReverseList.cpp b/patterns/c++/ReverseList.cpp
new file mode 100644
index 0000000..1740054
--- /dev/null
+++ b/patterns/c++/ReverseList.cpp
@@ -0,0 +1,18 @@
+struct ListNode {
+ int val;
+ ListNode* next;
+ ListNode(int x) : val(x), next(nullptr) {}
+};
+
+ListNode* reverseList(ListNode* head) {
+ ListNode* prev = nullptr;
+ ListNode* curr = head;
+
+ while (curr != nullptr) {
+ ListNode* next = curr->next;
+ curr->next = prev;
+ prev = curr;
+ curr = next;
+ }
+ return prev;
+}
\ No newline at end of file
diff --git a/patterns/c++/SlidingWindow.cpp b/patterns/c++/SlidingWindow.cpp
new file mode 100644
index 0000000..6d12d0c
--- /dev/null
+++ b/patterns/c++/SlidingWindow.cpp
@@ -0,0 +1,74 @@
+#include
+#include
+#include
+#include
+
+using namespace std;
+
+class SlidingWindow {
+public:
+ double findMaxAverageBruteForce(vector& nums, int k) {
+ int n = nums.size();
+ double maxAvg = INT_MIN;
+
+ for (int i = 0; i <= n - k; i++) {
+ int sum = 0;
+ for (int j = i; j < i + k; j++) {
+ sum += nums[j];
+ }
+ maxAvg = max(maxAvg, (double)sum / k);
+ }
+ return maxAvg;
+ }
+
+ double findMaxAverageSlidingWindow(vector& nums, int k) {
+ int n = nums.size();
+ int sum = 0;
+
+ for (int i = 0; i < k; i++) {
+ sum += nums[i];
+ }
+
+ int maxSum = sum;
+
+ for (int i = k; i < n; i++) {
+ sum += nums[i];
+ sum -= nums[i - k];
+ maxSum = max(maxSum, sum);
+ }
+
+ return (double)maxSum / k;
+ }
+
+ int lengthOfLongestSubstringSlidingWindow(string s) {
+ unordered_set seen;
+ int maxLength = 0, left = 0;
+
+ for (int right = 0; right < s.size(); right++) {
+ while (seen.count(s[right])) {
+ seen.erase(s[left]);
+ left++;
+ }
+ seen.insert(s[right]);
+ maxLength = max(maxLength, right - left + 1);
+ }
+ return maxLength;
+ }
+
+ int lengthOfLongestSubstringSlidingWindowFrequencyArray(string s) {
+ vector freq(128, 0);
+ int maxLength = 0, left = 0;
+
+ for (int right = 0; right < s.size(); right++) {
+ freq[s[right]]++;
+
+ while (freq[s[right]] > 1) {
+ freq[s[left]]--;
+ left++;
+ }
+
+ maxLength = max(maxLength, right - left + 1);
+ }
+ return maxLength;
+ }
+};
\ No newline at end of file
diff --git a/patterns/c++/TwoPointers.cpp b/patterns/c++/TwoPointers.cpp
new file mode 100644
index 0000000..8faea2b
--- /dev/null
+++ b/patterns/c++/TwoPointers.cpp
@@ -0,0 +1,64 @@
+#include
+#include
+#include
+
+using namespace std;
+
+class TwoPointers {
+public:
+ // Move Zeroes using Two Pointers
+ void moveZeroesTwoPointers(vector& nums) {
+ int left = 0; // Pointer for placing non-zero elements
+
+ // Iterate with right pointer
+ for (int right = 0; right < nums.size(); right++) {
+ if (nums[right] != 0) {
+ // Swap elements if right pointer finds a non-zero
+ swap(nums[left], nums[right]);
+ left++; // Move left pointer forward
+ }
+ }
+ }
+
+ // Brute Force approach for Container with Most Water
+ int maxAreaBruteForce(vector& height) {
+ int n = height.size();
+ int maxArea = 0;
+
+ // Check all pairs (i, j)
+ for (int i = 0; i < n; i++) {
+ for (int j = i + 1; j < n; j++) {
+ // Compute the minimum height and width
+ int minHeight = min(height[i], height[j]);
+ int width = j - i;
+ int area = minHeight * width; // Compute water contained
+
+ maxArea = max(maxArea, area); // Update max water
+ }
+ }
+ return maxArea;
+ }
+
+ // Two Pointers approach for Container with Most Water
+ int maxAreaTwoPointers(vector& height) {
+ int left = 0, right = height.size() - 1;
+ int maxArea = 0;
+
+ // Move pointers toward each other
+ while (left < right) {
+ int width = right - left; // Distance between lines
+ int minHeight = min(height[left], height[right]); // Compute height
+ int area = minHeight * width; // Compute water contained
+
+ maxArea = max(maxArea, area); // Update max water
+
+ // Move the pointer pointing to the shorter height
+ if (height[left] < height[right]) {
+ left++; // Move left pointer forward
+ } else {
+ right--; // Move right pointer backward
+ }
+ }
+ return maxArea;
+ }
+};
\ No newline at end of file
diff --git a/patterns/go/kadane_algorithm.go b/patterns/go/kadane_algorithm.go
new file mode 100644
index 0000000..4832097
--- /dev/null
+++ b/patterns/go/kadane_algorithm.go
@@ -0,0 +1,15 @@
+package main
+
+import "math"
+
+func maxSubArray(nums []int) int {
+ currentSum := nums[0]
+ maxSum := nums[0]
+
+ for i := 1; i < len(nums); i++ {
+ currentSum = int(math.Max(float64(nums[i]), float64(currentSum+nums[i])))
+ maxSum = int(math.Max(float64(maxSum), float64(currentSum)))
+ }
+
+ return maxSum
+}
diff --git a/patterns/go/level_order_traversal.go b/patterns/go/level_order_traversal.go
new file mode 100644
index 0000000..04e388e
--- /dev/null
+++ b/patterns/go/level_order_traversal.go
@@ -0,0 +1,39 @@
+package main
+
+import "fmt"
+
+// Definition for a binary tree node.
+type TreeNode struct {
+ Val int
+ Left *TreeNode
+ Right *TreeNode
+}
+
+func levelOrder(root *TreeNode) {
+ if root == nil {
+ return
+ }
+
+ queue := []*TreeNode{root}
+
+ for len(queue) > 0 {
+ node := queue[0]
+ queue = queue[1:]
+ fmt.Print(node.Val, " ") // Process the node by printing its value
+
+ // Add the left and right children to the queue, if they exist
+ if node.Left != nil {
+ queue = append(queue, node.Left)
+ }
+ if node.Right != nil {
+ queue = append(queue, node.Right)
+ }
+}
+
+func main() {
+ // Example usage
+ root := &TreeNode{Val: 1}
+ root.Left = &TreeNode{Val: 2}
+ root.Right = &TreeNode{Val: 3}
+ levelOrder(root) // Output: 1 2 3
+}
\ No newline at end of file
diff --git a/patterns/go/monotonic_stack.go b/patterns/go/monotonic_stack.go
new file mode 100644
index 0000000..1f66f4b
--- /dev/null
+++ b/patterns/go/monotonic_stack.go
@@ -0,0 +1,46 @@
+package main
+
+import "fmt"
+
+func nextGreaterElement(nums []int) []int {
+ n := len(nums)
+ result := make([]int, n)
+ for i := range result {
+ result[i] = -1 // Default to -1 if no greater element exists
+ }
+ stack := []int{} // Stack stores indices
+
+ for i := 0; i < n; i++ {
+ for len(stack) > 0 && nums[i] > nums[stack[len(stack)-1]] {
+ index := stack[len(stack)-1]
+ stack = stack[:len(stack)-1]
+ result[index] = nums[i]
+ }
+ stack = append(stack, i)
+ }
+ return result
+}
+
+func dailyTemperatures(temperatures []int) []int {
+ n := len(temperatures)
+ result := make([]int, n) // Result array initialized with 0s
+ stack := []int{} // Monotonic decreasing stack
+
+ for i := 0; i < n; i++ {
+ for len(stack) > 0 && temperatures[i] > temperatures[stack[len(stack)-1]] {
+ prevIndex := stack[len(stack)-1]
+ stack = stack[:len(stack)-1]
+ result[prevIndex] = i - prevIndex
+ }
+ stack = append(stack, i)
+ }
+ return result
+}
+
+func main() {
+ nums := []int{2, 1, 5, 6, 2, 3}
+ fmt.Println(nextGreaterElement(nums))
+
+ temperatures := []int{73, 74, 75, 71, 69, 72, 76, 73}
+ fmt.Println(dailyTemperatures(temperatures))
+}
diff --git a/patterns/go/reverse_list.go b/patterns/go/reverse_list.go
new file mode 100644
index 0000000..8cbcaed
--- /dev/null
+++ b/patterns/go/reverse_list.go
@@ -0,0 +1,19 @@
+package main
+
+type ListNode struct {
+ Val int
+ Next *ListNode
+}
+
+func reverseList(head *ListNode) *ListNode {
+ var prev *ListNode = nil
+ curr := head
+
+ for curr != nil {
+ next := curr.Next
+ curr.Next = prev
+ prev = curr
+ curr = next
+ }
+ return prev
+}
diff --git a/patterns/go/sliding_window.go b/patterns/go/sliding_window.go
new file mode 100644
index 0000000..056b87d
--- /dev/null
+++ b/patterns/go/sliding_window.go
@@ -0,0 +1,81 @@
+package main
+
+import (
+ "math"
+)
+
+// Brute Force Approach - O(n * k)
+func findMaxAverageBruteForce(nums []int, k int) float64 {
+ n := len(nums)
+ maxAvg := math.Inf(-1)
+
+ for i := 0; i <= n-k; i++ {
+ sum := 0
+ for j := i; j < i+k; j++ {
+ sum += nums[j]
+ }
+ maxAvg = math.Max(maxAvg, float64(sum)/float64(k))
+ }
+ return maxAvg
+}
+
+// Sliding Window Approach - O(n)
+func findMaxAverageSlidingWindow(nums []int, k int) float64 {
+ sum := 0
+ for i := 0; i < k; i++ {
+ sum += nums[i]
+ }
+
+ maxSum := sum
+
+ for i := k; i < len(nums); i++ {
+ sum += nums[i] - nums[i-k]
+ if sum > maxSum {
+ maxSum = sum
+ }
+ }
+
+ return float64(maxSum) / float64(k)
+}
+
+// Sliding Window for Longest Substring Without Repeating Characters
+func lengthOfLongestSubstringSlidingWindow(s string) int {
+ seen := make(map[byte]bool)
+ maxLength, left := 0, 0
+
+ for right := 0; right < len(s); right++ {
+ for seen[s[right]] {
+ delete(seen, s[left])
+ left++
+ }
+ seen[s[right]] = true
+ maxLength = max(maxLength, right-left+1)
+ }
+ return maxLength
+}
+
+// Sliding Window using Frequency Array
+func lengthOfLongestSubstringSlidingWindowFrequencyArray(s string) int {
+ freq := make([]int, 128)
+ maxLength, left := 0, 0
+
+ for right := 0; right < len(s); right++ {
+ freq[s[right]]++
+
+ for freq[s[right]] > 1 {
+ freq[s[left]]--
+ left++
+ }
+
+ maxLength = max(maxLength, right-left+1)
+ }
+ return maxLength
+}
+
+// Helper function to get max of two numbers
+func max(a, b int) int {
+ if a > b {
+ return a
+ }
+ return b
+}
diff --git a/patterns/go/two_pointers.go b/patterns/go/two_pointers.go
new file mode 100644
index 0000000..1433c48
--- /dev/null
+++ b/patterns/go/two_pointers.go
@@ -0,0 +1,69 @@
+package main
+
+// Move Zeroes using Two Pointers
+func moveZeroesTwoPointers(nums []int) {
+ left := 0 // Pointer for placing non-zero elements
+
+ // Iterate with right pointer
+ for right := 0; right < len(nums); right++ {
+ if nums[right] != 0 {
+ // Swap elements if right pointer finds a non-zero
+ nums[left], nums[right] = nums[right], nums[left]
+ left++ // Move left pointer forward
+ }
+ }
+}
+
+// Brute Force approach for Container with Most Water
+func maxAreaBruteForce(height []int) int {
+ n := len(height)
+ maxArea := 0
+
+ // Check all pairs (i, j)
+ for i := 0; i < n; i++ {
+ for j := i + 1; j < n; j++ {
+ // Compute the minimum height and width
+ minHeight := min(height[i], height[j])
+ width := j - i
+ area := minHeight * width // Compute water contained
+
+ if area > maxArea {
+ maxArea = area // Update max water
+ }
+ }
+ }
+ return maxArea
+}
+
+// Two Pointers approach for Container with Most Water
+func maxAreaTwoPointers(height []int) int {
+ left, right := 0, len(height)-1
+ maxArea := 0
+
+ // Move pointers toward each other
+ for left < right {
+ width := right - left // Distance between lines
+ minHeight := min(height[left], height[right]) // Compute height
+ area := minHeight * width // Compute water contained
+
+ if area > maxArea {
+ maxArea = area // Update max water
+ }
+
+ // Move the pointer pointing to the shorter height
+ if height[left] < height[right] {
+ left++ // Move left pointer forward
+ } else {
+ right-- // Move right pointer backward
+ }
+ }
+ return maxArea
+}
+
+// Helper function to return the minimum of two integers
+func min(a, b int) int {
+ if a < b {
+ return a
+ }
+ return b
+}
diff --git a/patterns/java/KadaneAlgorithm.java b/patterns/java/KadaneAlgorithm.java
new file mode 100644
index 0000000..9e3f46b
--- /dev/null
+++ b/patterns/java/KadaneAlgorithm.java
@@ -0,0 +1,17 @@
+package patterns.java;
+
+public class KadaneAlgorithm {
+ public int maxSubArray(int[] nums) {
+ int currentSum = nums[0]; // Start with the first element
+ int maxSum = nums[0]; // Initialize maxSum with the first element
+
+ // Traverse the array from the second element
+ for (int i = 1; i < nums.length; i++) {
+ // If currentSum is negative, reset to current element
+ currentSum = Math.max(nums[i], currentSum + nums[i]);
+ // Update maxSum if currentSum is greater
+ maxSum = Math.max(maxSum, currentSum);
+ }
+ return maxSum;
+ }
+}
\ No newline at end of file
diff --git a/patterns/java/LevelOrderTraversal.java b/patterns/java/LevelOrderTraversal.java
new file mode 100644
index 0000000..ac56f0f
--- /dev/null
+++ b/patterns/java/LevelOrderTraversal.java
@@ -0,0 +1,33 @@
+package patterns.java;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+// Definition for a binary tree node.
+class TreeNode {
+ int val;
+ TreeNode left;
+ TreeNode right;
+
+ TreeNode(int x) {
+ val = x;
+ }
+}
+
+public class LevelOrderTraversal {
+ public void levelOrder(TreeNode root) {
+ if (root == null) return;
+
+ Queue queue = new LinkedList<>();
+ queue.add(root);
+
+ while (!queue.isEmpty()) {
+ TreeNode node = queue.poll();
+ System.out.print(node.val + " "); // Process the node by printing its value
+
+ // Add the left and right children to the queue, if they exist
+ if (node.left != null) queue.add(node.left);
+ if (node.right != null) queue.add(node.right);
+ }
+ }
+}
diff --git a/patterns/java/MonotonicStack.java b/patterns/java/MonotonicStack.java
new file mode 100644
index 0000000..920b61f
--- /dev/null
+++ b/patterns/java/MonotonicStack.java
@@ -0,0 +1,43 @@
+package patterns.java;
+
+import java.util.Arrays;
+import java.util.Stack;
+
+public class MonotonicStack {
+
+ public int[] nextGreaterElement(int[] nums) {
+ int n = nums.length;
+ int[] result = new int[n]; // Output array
+ Arrays.fill(result, -1); // Default to -1 if no greater element exists
+ Stack stack = new Stack<>(); // Stack stores indices
+
+ // Iterate through the array
+ for (int i = 0; i < n; i++) {
+ // While stack is not empty and current element is greater than stack top
+ while (!stack.isEmpty() && nums[i] > nums[stack.peek()]) {
+ int index = stack.pop(); // Pop the top element
+ result[index] = nums[i]; // The current element is the Next Greater Element
+ }
+ stack.push(i); // Push the current index onto the stack
+ }
+ return result;
+ }
+
+ public int[] dailyTemperatures(int[] temperatures) {
+ int n = temperatures.length;
+ int[] result = new int[n]; // Result array initialized with 0s
+ Stack stack = new Stack<>(); // Monotonic decreasing stack (stores indices)
+
+ // Iterate through the temperature array
+ for (int i = 0; i < n; i++) {
+ // While stack is not empty AND the current temperature is warmer than the temperature at stack top
+ while (!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {
+ int prevIndex = stack.pop(); // Pop the previous day's index
+ result[prevIndex] = i - prevIndex; // Calculate the wait time
+ }
+ stack.push(i); // Push current index onto the stack
+ }
+
+ return result; // Return the computed results
+ }
+}
\ No newline at end of file
diff --git a/patterns/java/ReverseLinkedList.java b/patterns/java/ReverseLinkedList.java
new file mode 100644
index 0000000..3bd0843
--- /dev/null
+++ b/patterns/java/ReverseLinkedList.java
@@ -0,0 +1,20 @@
+package patterns.java;
+
+class ListNode {
+ int val;
+ ListNode next;
+}
+
+public class ReverseLinkedList {
+ public ListNode reverseList(ListNode head) {
+ ListNode prev = null; // Previous node, initially null
+ ListNode curr = head; // Current node starts from the head
+ while (curr != null) {
+ ListNode next = curr.next; // Store next node
+ curr.next = prev; // Reverse the current node's pointer
+ prev = curr; // Move prev to current
+ curr = next; // Move curr to next
+ }
+ return prev; // New head of the reversed list
+ }
+}
diff --git a/patterns/java/SlidingWindow.java b/patterns/java/SlidingWindow.java
new file mode 100644
index 0000000..7fe3d79
--- /dev/null
+++ b/patterns/java/SlidingWindow.java
@@ -0,0 +1,90 @@
+package patterns.java;
+
+import java.util.HashSet;
+
+public class SlidingWindow {
+ public double findMaxAverageBruteForce(int[] nums, int k) {
+ int n = nums.length;
+ double maxAvg = Integer.MIN_VALUE;
+
+ // Iterate through all possible subarrays of length k
+ for (int i = 0; i <= n - k; i++) {
+ int sum = 0;
+
+ // Calculate sum of subarray starting at index i
+ for (int j = i; j < i + k; j++) {
+ sum += nums[j];
+ }
+
+ // Compute average and update maxAvg
+ maxAvg = Math.max(maxAvg, (double) sum / k);
+ }
+ return maxAvg;
+ }
+
+ public double findMaxAverageSlidingWindow(int[] nums, int k) {
+ int n = nums.length;
+
+ // Compute the sum of the first 'k' elements
+ int sum = 0;
+ for (int i = 0; i < k; i++) {
+ sum += nums[i];
+ }
+
+ // Initialize maxSum as the sum of the first window
+ int maxSum = sum;
+
+ // Slide the window across the array
+ for (int i = k; i < n; i++) {
+ sum += nums[i]; // Add new element entering window
+ sum -= nums[i - k]; // Remove element leaving window
+ maxSum = Math.max(maxSum, sum); // Update maxSum
+ }
+
+ // Return maximum average
+ return (double) maxSum / k;
+ }
+
+ public int lengthOfLongestSubstringSlidingWindow(String s) {
+ int n = s.length();
+ HashSet seen = new HashSet<>(); // Store characters in the current window
+ int maxLength = 0;
+ int left = 0;
+
+ // Expand window by moving 'right'
+ for (int right = 0; right < n; right++) {
+ // If a duplicate is found, shrink the window from the left
+ while (seen.contains(s.charAt(right))) {
+ seen.remove(s.charAt(left));
+ left++;
+ }
+ // Add current character to window and update max length
+ seen.add(s.charAt(right));
+ maxLength = Math.max(maxLength, right - left + 1);
+ }
+ return maxLength;
+ }
+
+ public int lengthOfLongestSubstringSlidingWindowFrequencyArray(String s) {
+ int n = s.length();
+ int[] freq = new int[128]; // ASCII character frequency array
+ int maxLength = 0;
+ int left = 0;
+
+ // Expand window by moving 'right'
+ for (int right = 0; right < n; right++) {
+ char currentChar = s.charAt(right);
+ freq[currentChar]++; // Increase frequency of the current character
+
+ // If there is a duplicate, shrink the window from the left
+ while (freq[currentChar] > 1) {
+ freq[s.charAt(left)]--; // Remove character at left pointer
+ left++; // Shrink window
+ }
+
+ // Update maximum window size
+ maxLength = Math.max(maxLength, right - left + 1);
+ }
+ return maxLength;
+ }
+}
\ No newline at end of file
diff --git a/patterns/java/TopKElements.java b/patterns/java/TopKElements.java
index c84c391..15946b1 100644
--- a/patterns/java/TopKElements.java
+++ b/patterns/java/TopKElements.java
@@ -126,7 +126,9 @@ private int getDistance(int[] point) {
public int[][] kClosestPointsToOriginMaxHeapApproach(int[][] points, int k) {
// Max heap with custom comparator to compare by distance
- PriorityQueue maxHeap = new PriorityQueue<>((a, b) -> getDistance(b) - getDistance(a));
+ PriorityQueue maxHeap = new PriorityQueue<>(
+ (a, b) -> Integer.compare(getDistance(b), getDistance(a))
+ );
// Iterate through all points
for (int[] point : points) {
@@ -146,4 +148,4 @@ public int[][] kClosestPointsToOriginMaxHeapApproach(int[][] points, int k) {
return result;
}
-}
\ No newline at end of file
+}
diff --git a/patterns/java/TwoPointers.java b/patterns/java/TwoPointers.java
new file mode 100644
index 0000000..35cb395
--- /dev/null
+++ b/patterns/java/TwoPointers.java
@@ -0,0 +1,59 @@
+package patterns.java;
+
+public class TwoPointers {
+
+ public void moveZeroesTwoPointers(int[] nums) {
+ int left = 0; // Pointer for placing non-zero elements
+
+ // Iterate with right pointer
+ for (int right = 0; right < nums.length; right++) {
+ if (nums[right] != 0) {
+ // Swap elements if right pointer finds a non-zero
+ int temp = nums[left];
+ nums[left] = nums[right];
+ nums[right] = temp;
+ left++; // Move left pointer forward
+ }
+ }
+ }
+
+ public int maxAreaBruteForce(int[] height) {
+ int n = height.length;
+ int maxArea = 0;
+
+ // Check all pairs (i, j)
+ for (int i = 0; i < n; i++) {
+ for (int j = i + 1; j < n; j++) {
+ // Height of the container
+ int minHeight = Math.min(height[i], height[j]);
+ int width = j - i; // Distance between lines
+ int area = minHeight * width; // Compute water contained
+
+ maxArea = Math.max(maxArea, area); // Update max water
+ }
+ }
+ return maxArea;
+ }
+
+ public int maxAreaTwoPointers(int[] height) {
+ int left = 0, right = height.length - 1;
+ int maxArea = 0;
+
+ // Move pointers toward each other
+ while (left <= right) {
+ int width = right - left; // Distance between lines
+ int minHeight = Math.min(height[left], height[right]);
+ int area = minHeight * width; // Compute water contained
+
+ maxArea = Math.max(maxArea, area); // Update max water
+
+ // Move the pointer pointing to the shorter height
+ if (height[left] < height[right]) {
+ left++; // Move left pointer forward
+ } else {
+ right--; // Move right pointer backward
+ }
+ }
+ return maxArea;
+ }
+}
\ No newline at end of file
diff --git a/patterns/javascript/kadaneAlgorithm.js b/patterns/javascript/kadaneAlgorithm.js
new file mode 100644
index 0000000..859b036
--- /dev/null
+++ b/patterns/javascript/kadaneAlgorithm.js
@@ -0,0 +1,12 @@
+class KadaneAlgorithm {
+ maxSubArray(nums) {
+ let currentSum = nums[0];
+ let maxSum = nums[0];
+
+ for (let i = 1; i < nums.length; i++) {
+ currentSum = Math.max(nums[i], currentSum + nums[i]);
+ maxSum = Math.max(maxSum, currentSum);
+ }
+ return maxSum;
+ }
+}
\ No newline at end of file
diff --git a/patterns/javascript/levelOrderTraversal.js b/patterns/javascript/levelOrderTraversal.js
new file mode 100644
index 0000000..c65bab9
--- /dev/null
+++ b/patterns/javascript/levelOrderTraversal.js
@@ -0,0 +1,24 @@
+// Definition for a binary tree node.
+class TreeNode {
+ constructor(val) {
+ this.val = val;
+ this.left = this.right = null;
+ }
+}
+
+class LevelOrderTraversal {
+ levelOrder(root) {
+ if (root === null) return;
+
+ const queue = [root];
+
+ while (queue.length > 0) {
+ const node = queue.shift();
+ console.log(node.val); // Process the node by printing its value
+
+ // Add the left and right children to the queue, if they exist
+ if (node.left !== null) queue.push(node.left);
+ if (node.right !== null) queue.push(node.right);
+ }
+ }
+}
\ No newline at end of file
diff --git a/patterns/javascript/monotonicStack.js b/patterns/javascript/monotonicStack.js
new file mode 100644
index 0000000..94918c4
--- /dev/null
+++ b/patterns/javascript/monotonicStack.js
@@ -0,0 +1,31 @@
+class MonotonicStack {
+ nextGreaterElement(nums) {
+ let n = nums.length;
+ let result = new Array(n).fill(-1); // Default to -1 if no greater element exists
+ let stack = []; // Stack stores indices
+
+ for (let i = 0; i < n; i++) {
+ while (stack.length > 0 && nums[i] > nums[stack[stack.length - 1]]) {
+ let index = stack.pop();
+ result[index] = nums[i];
+ }
+ stack.push(i);
+ }
+ return result;
+ }
+
+ dailyTemperatures(temperatures) {
+ let n = temperatures.length;
+ let result = new Array(n).fill(0); // Result array initialized with 0s
+ let stack = []; // Monotonic decreasing stack
+
+ for (let i = 0; i < n; i++) {
+ while (stack.length > 0 && temperatures[i] > temperatures[stack[stack.length - 1]]) {
+ let prevIndex = stack.pop();
+ result[prevIndex] = i - prevIndex;
+ }
+ stack.push(i);
+ }
+ return result;
+ }
+}
\ No newline at end of file
diff --git a/patterns/javascript/reverseList.js b/patterns/javascript/reverseList.js
new file mode 100644
index 0000000..317f50e
--- /dev/null
+++ b/patterns/javascript/reverseList.js
@@ -0,0 +1,19 @@
+class ListNode {
+ constructor(val = 0, next = null) {
+ this.val = val;
+ this.next = next;
+ }
+}
+
+function reverseList(head) {
+ let prev = null;
+ let curr = head;
+
+ while (curr !== null) {
+ let next = curr.next;
+ curr.next = prev;
+ prev = curr;
+ curr = next;
+ }
+ return prev;
+}
\ No newline at end of file
diff --git a/patterns/javascript/slidingWindow.js b/patterns/javascript/slidingWindow.js
new file mode 100644
index 0000000..2e80ef0
--- /dev/null
+++ b/patterns/javascript/slidingWindow.js
@@ -0,0 +1,62 @@
+class SlidingWindow {
+ // Brute Force Approach - O(n * k)
+ findMaxAverageBruteForce(nums, k) {
+ let maxAvg = -Infinity;
+
+ for (let i = 0; i <= nums.length - k; i++) {
+ let sum = 0;
+ for (let j = i; j < i + k; j++) {
+ sum += nums[j];
+ }
+ maxAvg = Math.max(maxAvg, sum / k);
+ }
+ return maxAvg;
+ }
+
+ // Sliding Window Approach - O(n)
+ findMaxAverageSlidingWindow(nums, k) {
+ let sum = nums.slice(0, k).reduce((a, b) => a + b, 0);
+ let maxSum = sum;
+
+ for (let i = k; i < nums.length; i++) {
+ sum += nums[i] - nums[i - k];
+ maxSum = Math.max(maxSum, sum);
+ }
+
+ return maxSum / k;
+ }
+
+ // Sliding Window for Longest Substring Without Repeating Characters
+ lengthOfLongestSubstringSlidingWindow(s) {
+ let seen = new Set();
+ let maxLength = 0, left = 0;
+
+ for (let right = 0; right < s.length; right++) {
+ while (seen.has(s[right])) {
+ seen.delete(s[left]);
+ left++;
+ }
+ seen.add(s[right]);
+ maxLength = Math.max(maxLength, right - left + 1);
+ }
+ return maxLength;
+ }
+
+ // Sliding Window using Frequency Array
+ lengthOfLongestSubstringSlidingWindowFrequencyArray(s) {
+ let freq = new Array(128).fill(0);
+ let maxLength = 0, left = 0;
+
+ for (let right = 0; right < s.length; right++) {
+ freq[s.charCodeAt(right)]++;
+
+ while (freq[s.charCodeAt(right)] > 1) {
+ freq[s.charCodeAt(left)]--;
+ left++;
+ }
+
+ maxLength = Math.max(maxLength, right - left + 1);
+ }
+ return maxLength;
+ }
+}
\ No newline at end of file
diff --git a/patterns/javascript/top_k_elements.js b/patterns/javascript/topKElements.js
similarity index 100%
rename from patterns/javascript/top_k_elements.js
rename to patterns/javascript/topKElements.js
diff --git a/patterns/javascript/twoPointers.js b/patterns/javascript/twoPointers.js
new file mode 100644
index 0000000..5c46a59
--- /dev/null
+++ b/patterns/javascript/twoPointers.js
@@ -0,0 +1,68 @@
+class TwoPointers {
+ /**
+ * Move Zeroes using Two Pointers
+ * @param {number[]} nums - Input array
+ */
+ moveZeroesTwoPointers(nums) {
+ let left = 0; // Pointer for placing non-zero elements
+
+ // Iterate with right pointer
+ for (let right = 0; right < nums.length; right++) {
+ if (nums[right] !== 0) {
+ // Swap elements if right pointer finds a non-zero
+ [nums[left], nums[right]] = [nums[right], nums[left]];
+ left++; // Move left pointer forward
+ }
+ }
+ }
+
+ /**
+ * Brute Force approach for Container with Most Water
+ * @param {number[]} height - Array of heights
+ * @return {number} - Maximum water that can be contained
+ */
+ maxAreaBruteForce(height) {
+ let maxArea = 0;
+ let n = height.length;
+
+ // Check all pairs (i, j)
+ for (let i = 0; i < n; i++) {
+ for (let j = i + 1; j < n; j++) {
+ // Compute the minimum height and width
+ let minHeight = Math.min(height[i], height[j]);
+ let width = j - i;
+ let area = minHeight * width; // Compute water contained
+
+ maxArea = Math.max(maxArea, area); // Update max water
+ }
+ }
+ return maxArea;
+ }
+
+ /**
+ * Two Pointers approach for Container with Most Water
+ * @param {number[]} height - Array of heights
+ * @return {number} - Maximum water that can be contained
+ */
+ maxAreaTwoPointers(height) {
+ let left = 0, right = height.length - 1;
+ let maxArea = 0;
+
+ // Move pointers toward each other
+ while (left < right) {
+ let width = right - left; // Distance between lines
+ let minHeight = Math.min(height[left], height[right]); // Compute height
+ let area = minHeight * width; // Compute water contained
+
+ maxArea = Math.max(maxArea, area); // Update max water
+
+ // Move the pointer pointing to the shorter height
+ if (height[left] < height[right]) {
+ left++; // Move left pointer forward
+ } else {
+ right--; // Move right pointer backward
+ }
+ }
+ return maxArea;
+ }
+}
\ No newline at end of file
diff --git a/patterns/python/kadane_algorithm.py b/patterns/python/kadane_algorithm.py
new file mode 100644
index 0000000..66bdd33
--- /dev/null
+++ b/patterns/python/kadane_algorithm.py
@@ -0,0 +1,10 @@
+class KadaneAlgorithm:
+ def max_sub_array(self, nums):
+ current_sum = nums[0]
+ max_sum = nums[0]
+
+ for i in range(1, len(nums)):
+ current_sum = max(nums[i], current_sum + nums[i])
+ max_sum = max(max_sum, current_sum)
+
+ return max_sum
\ No newline at end of file
diff --git a/patterns/python/level_order_traversal.py b/patterns/python/level_order_traversal.py
new file mode 100644
index 0000000..c52fc99
--- /dev/null
+++ b/patterns/python/level_order_traversal.py
@@ -0,0 +1,25 @@
+from collections import deque
+
+# Definition for a binary tree node.
+class TreeNode:
+ def __init__(self, x):
+ self.val = x
+ self.left = None
+ self.right = None
+
+class LevelOrderTraversal:
+ def level_order(self, root):
+ if root is None:
+ return
+
+ queue = deque([root])
+
+ while queue:
+ node = queue.popleft()
+ print(node.val, end=" ") # Process the node by printing its value
+
+ # Add the left and right children to the queue, if they exist
+ if node.left:
+ queue.append(node.left)
+ if node.right:
+ queue.append(node.right)
\ No newline at end of file
diff --git a/patterns/python/monotonic_stack.py b/patterns/python/monotonic_stack.py
new file mode 100644
index 0000000..62e51ce
--- /dev/null
+++ b/patterns/python/monotonic_stack.py
@@ -0,0 +1,26 @@
+class MonotonicStack:
+ def next_greater_element(self, nums):
+ n = len(nums)
+ result = [-1] * n # Default to -1 if no greater element exists
+ stack = [] # Stack stores indices
+
+ for i in range(n):
+ while stack and nums[i] > nums[stack[-1]]:
+ index = stack.pop()
+ result[index] = nums[i]
+ stack.append(i)
+
+ return result
+
+ def daily_temperatures(self, temperatures):
+ n = len(temperatures)
+ result = [0] * n # Result array initialized with 0s
+ stack = [] # Monotonic decreasing stack
+
+ for i in range(n):
+ while stack and temperatures[i] > temperatures[stack[-1]]:
+ prev_index = stack.pop()
+ result[prev_index] = i - prev_index
+ stack.append(i)
+
+ return result
\ No newline at end of file
diff --git a/patterns/python/reverse_list.py b/patterns/python/reverse_list.py
new file mode 100644
index 0000000..ec842b3
--- /dev/null
+++ b/patterns/python/reverse_list.py
@@ -0,0 +1,16 @@
+class ListNode:
+ def __init__(self, val=0, next=None):
+ self.val = val
+ self.next = next
+
+def reverse_list(head):
+ prev = None
+ curr = head
+
+ while curr:
+ next_node = curr.next
+ curr.next = prev
+ prev = curr
+ curr = next_node
+
+ return prev
\ No newline at end of file
diff --git a/patterns/python/sliding_window.py b/patterns/python/sliding_window.py
new file mode 100644
index 0000000..b42e33d
--- /dev/null
+++ b/patterns/python/sliding_window.py
@@ -0,0 +1,46 @@
+class SlidingWindow:
+ def find_max_average_brute_force(self, nums, k):
+ max_avg = float('-inf')
+
+ for i in range(len(nums) - k + 1):
+ max_avg = max(max_avg, sum(nums[i:i + k]) / k)
+
+ return max_avg
+
+ def find_max_average_sliding_window(self, nums, k):
+ sum_window = sum(nums[:k])
+ max_sum = sum_window
+
+ for i in range(k, len(nums)):
+ sum_window += nums[i] - nums[i - k]
+ max_sum = max(max_sum, sum_window)
+
+ return max_sum / k
+
+ def length_of_longest_substring_sliding_window(self, s):
+ seen = set()
+ max_length = left = 0
+
+ for right in range(len(s)):
+ while s[right] in seen:
+ seen.remove(s[left])
+ left += 1
+ seen.add(s[right])
+ max_length = max(max_length, right - left + 1)
+
+ return max_length
+
+ def length_of_longest_substring_sliding_window_frequency_array(self, s):
+ freq = [0] * 128
+ max_length = left = 0
+
+ for right in range(len(s)):
+ freq[ord(s[right])] += 1
+
+ while freq[ord(s[right])] > 1:
+ freq[ord(s[left])] -= 1
+ left += 1
+
+ max_length = max(max_length, right - left + 1)
+
+ return max_length
\ No newline at end of file
diff --git a/patterns/python/two_pointers.py b/patterns/python/two_pointers.py
new file mode 100644
index 0000000..3e874f0
--- /dev/null
+++ b/patterns/python/two_pointers.py
@@ -0,0 +1,48 @@
+class TwoPointers:
+ # Move Zeroes using Two Pointers
+ def move_zeroes_two_pointers(self, nums):
+ left = 0 # Pointer for placing non-zero elements
+
+ # Iterate with right pointer
+ for right in range(len(nums)):
+ if nums[right] != 0:
+ # Swap elements if right pointer finds a non-zero
+ nums[left], nums[right] = nums[right], nums[left]
+ left += 1 # Move left pointer forward
+
+ # Brute Force approach for Container with Most Water
+ def max_area_brute_force(self, height):
+ n = len(height)
+ max_area = 0
+
+ # Check all pairs (i, j)
+ for i in range(n):
+ for j in range(i + 1, n):
+ # Compute the minimum height and width
+ min_height = min(height[i], height[j])
+ width = j - i
+ area = min_height * width # Compute water contained
+
+ max_area = max(max_area, area) # Update max water
+ return max_area
+
+ # Two Pointers approach for Container with Most Water
+ def max_area_two_pointers(self, height):
+ left, right = 0, len(height) - 1
+ max_area = 0
+
+ # Move pointers toward each other
+ while left < right:
+ width = right - left # Distance between lines
+ min_height = min(height[left], height[right]) # Compute height
+ area = min_height * width # Compute water contained
+
+ max_area = max(max_area, area) # Update max water
+
+ # Move the pointer pointing to the shorter height
+ if height[left] < height[right]:
+ left += 1 # Move left pointer forward
+ else:
+ right -= 1 # Move right pointer backward
+
+ return max_area
\ No newline at end of file
diff --git a/patterns/typescript/kadaneAlgorithm.ts b/patterns/typescript/kadaneAlgorithm.ts
new file mode 100644
index 0000000..5b91e80
--- /dev/null
+++ b/patterns/typescript/kadaneAlgorithm.ts
@@ -0,0 +1,12 @@
+class KadaneAlgorithm {
+ maxSubArray(nums: number[]): number {
+ let currentSum: number = nums[0];
+ let maxSum: number = nums[0];
+
+ for (let i = 1; i < nums.length; i++) {
+ currentSum = Math.max(nums[i], currentSum + nums[i]);
+ maxSum = Math.max(maxSum, currentSum);
+ }
+ return maxSum;
+ }
+}
\ No newline at end of file
diff --git a/patterns/typescript/levelOrderTraversal.ts b/patterns/typescript/levelOrderTraversal.ts
new file mode 100644
index 0000000..dfbbcb3
--- /dev/null
+++ b/patterns/typescript/levelOrderTraversal.ts
@@ -0,0 +1,28 @@
+// Definition for a binary tree node.
+class BinaryTreeNode {
+ val: number;
+ left: TreeNode | null;
+ right: TreeNode | null;
+
+ constructor(val: number) {
+ this.val = val;
+ this.left = this.right = null;
+ }
+}
+
+class BinaryTreeLevelOrderTraversal {
+ levelOrder(root: BinaryTreeNode | null): void {
+ if (root === null) return;
+
+ const queue: BinaryTreeNode[] = [root];
+
+ while (queue.length > 0) {
+ const node = queue.shift()!;
+ console.log(node.val); // Process the node by printing its value
+
+ // Add the left and right children to the queue, if they exist
+ if (node.left !== null) queue.push(node.left);
+ if (node.right !== null) queue.push(node.right);
+ }
+ }
+}
\ No newline at end of file
diff --git a/patterns/typescript/monotonicStack.ts b/patterns/typescript/monotonicStack.ts
new file mode 100644
index 0000000..a878002
--- /dev/null
+++ b/patterns/typescript/monotonicStack.ts
@@ -0,0 +1,31 @@
+class MonotonicStack {
+ nextGreaterElement(nums: number[]): number[] {
+ let n = nums.length;
+ let result: number[] = new Array(n).fill(-1); // Default to -1 if no greater element exists
+ let stack: number[] = []; // Stack stores indices
+
+ for (let i = 0; i < n; i++) {
+ while (stack.length > 0 && nums[i] > nums[stack[stack.length - 1]]) {
+ let index = stack.pop()!;
+ result[index] = nums[i];
+ }
+ stack.push(i);
+ }
+ return result;
+ }
+
+ dailyTemperatures(temperatures: number[]): number[] {
+ let n = temperatures.length;
+ let result: number[] = new Array(n).fill(0); // Result array initialized with 0s
+ let stack: number[] = []; // Monotonic decreasing stack
+
+ for (let i = 0; i < n; i++) {
+ while (stack.length > 0 && temperatures[i] > temperatures[stack[stack.length - 1]]) {
+ let prevIndex = stack.pop()!;
+ result[prevIndex] = i - prevIndex;
+ }
+ stack.push(i);
+ }
+ return result;
+ }
+}
\ No newline at end of file
diff --git a/patterns/typescript/reverseList.ts b/patterns/typescript/reverseList.ts
new file mode 100644
index 0000000..d757f7e
--- /dev/null
+++ b/patterns/typescript/reverseList.ts
@@ -0,0 +1,22 @@
+class ListNode {
+ val: number;
+ next: ListNode | null;
+
+ constructor(val: number = 0, next: ListNode | null = null) {
+ this.val = val;
+ this.next = next;
+ }
+}
+
+function reverseList(head: ListNode | null): ListNode | null {
+ let prev: ListNode | null = null;
+ let curr: ListNode | null = head;
+
+ while (curr !== null) {
+ let next: ListNode | null = curr.next;
+ curr.next = prev;
+ prev = curr;
+ curr = next;
+ }
+ return prev;
+}
\ No newline at end of file
diff --git a/patterns/typescript/slidingWindow.ts b/patterns/typescript/slidingWindow.ts
new file mode 100644
index 0000000..86a2c8d
--- /dev/null
+++ b/patterns/typescript/slidingWindow.ts
@@ -0,0 +1,62 @@
+class SlidingWindow {
+ // Brute Force Approach - O(n * k)
+ findMaxAverageBruteForce(nums: number[], k: number): number {
+ let maxAvg = -Infinity;
+
+ for (let i = 0; i <= nums.length - k; i++) {
+ let sum = 0;
+ for (let j = i; j < i + k; j++) {
+ sum += nums[j];
+ }
+ maxAvg = Math.max(maxAvg, sum / k);
+ }
+ return maxAvg;
+ }
+
+ // Sliding Window Approach - O(n)
+ findMaxAverageSlidingWindow(nums: number[], k: number): number {
+ let sum = nums.slice(0, k).reduce((a, b) => a + b, 0);
+ let maxSum = sum;
+
+ for (let i = k; i < nums.length; i++) {
+ sum += nums[i] - nums[i - k];
+ maxSum = Math.max(maxSum, sum);
+ }
+
+ return maxSum / k;
+ }
+
+ // Sliding Window for Longest Substring Without Repeating Characters
+ lengthOfLongestSubstringSlidingWindow(s: string): number {
+ let seen = new Set();
+ let maxLength = 0, left = 0;
+
+ for (let right = 0; right < s.length; right++) {
+ while (seen.has(s[right])) {
+ seen.delete(s[left]);
+ left++;
+ }
+ seen.add(s[right]);
+ maxLength = Math.max(maxLength, right - left + 1);
+ }
+ return maxLength;
+ }
+
+ // Sliding Window using Frequency Array
+ lengthOfLongestSubstringSlidingWindowFrequencyArray(s: string): number {
+ let freq = new Array(128).fill(0);
+ let maxLength = 0, left = 0;
+
+ for (let right = 0; right < s.length; right++) {
+ freq[s.charCodeAt(right)]++;
+
+ while (freq[s.charCodeAt(right)] > 1) {
+ freq[s.charCodeAt(left)]--;
+ left++;
+ }
+
+ maxLength = Math.max(maxLength, right - left + 1);
+ }
+ return maxLength;
+ }
+}
\ No newline at end of file
diff --git a/patterns/typescript/top_k_elements.ts b/patterns/typescript/topKElements.ts
similarity index 100%
rename from patterns/typescript/top_k_elements.ts
rename to patterns/typescript/topKElements.ts
diff --git a/patterns/typescript/twoPointers.ts b/patterns/typescript/twoPointers.ts
new file mode 100644
index 0000000..8587625
--- /dev/null
+++ b/patterns/typescript/twoPointers.ts
@@ -0,0 +1,57 @@
+class TwoPointers {
+ // Move Zeroes using Two Pointers
+ moveZeroesTwoPointers(nums: number[]): void {
+ let left = 0; // Pointer for placing non-zero elements
+
+ // Iterate with right pointer
+ for (let right = 0; right < nums.length; right++) {
+ if (nums[right] !== 0) {
+ // Swap elements if right pointer finds a non-zero
+ [nums[left], nums[right]] = [nums[right], nums[left]];
+ left++; // Move left pointer forward
+ }
+ }
+ }
+
+ // Brute Force approach for Container with Most Water
+ maxAreaBruteForce(height: number[]): number {
+ let maxArea = 0;
+ let n = height.length;
+
+ // Check all pairs (i, j)
+ for (let i = 0; i < n; i++) {
+ for (let j = i + 1; j < n; j++) {
+ // Compute the minimum height and width
+ let minHeight = Math.min(height[i], height[j]);
+ let width = j - i;
+ let area = minHeight * width; // Compute water contained
+
+ maxArea = Math.max(maxArea, area); // Update max water
+ }
+ }
+ return maxArea;
+ }
+
+ // Two Pointers approach for Container with Most Water
+ maxAreaTwoPointers(height: number[]): number {
+ let left = 0, right = height.length - 1;
+ let maxArea = 0;
+
+ // Move pointers toward each other
+ while (left < right) {
+ let width = right - left; // Distance between lines
+ let minHeight = Math.min(height[left], height[right]); // Compute height
+ let area = minHeight * width; // Compute water contained
+
+ maxArea = Math.max(maxArea, area); // Update max water
+
+ // Move the pointer pointing to the shorter height
+ if (height[left] < height[right]) {
+ left++; // Move left pointer forward
+ } else {
+ right--; // Move right pointer backward
+ }
+ }
+ return maxArea;
+ }
+}
\ No newline at end of file