Added solutions for c++, java and js

Author: gahogg

3Sum - Leetcode 15/3Sum - Leetcode 15.cpp

@@ -0,0 +1,35 @@
+#include <vector>
+#include <unordered_map>
+#include <set>
+#include <algorithm>
+
+using namespace std;
+
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        unordered_map<int, int> indexMap;
+        set<vector<int>> result;
+        int n = nums.size();
+
+        // Build the index map
+        for (int i = 0; i < n; ++i) {
+            indexMap[nums[i]] = i;
+        }
+
+        // Iterate over each pair
+        for (int i = 0; i < n; ++i) {
+            for (int j = i + 1; j < n; ++j) {
+                int desired = -nums[i] - nums[j];
+                if (indexMap.find(desired) != indexMap.end() &&
+                    indexMap[desired] != i && indexMap[desired] != j) {
+                    vector<int> triplet = {nums[i], nums[j], desired};
+                    sort(triplet.begin(), triplet.end());
+                    result.insert(triplet);
+                }
+            }
+        }
+
+        return vector<vector<int>>(result.begin(), result.end());
+    }
+};

3Sum - Leetcode 15/3Sum - Leetcode 15.java

@@ -0,0 +1,28 @@
+import java.util.*;
+
+public class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        Set<List<Integer>> result = new HashSet<>();
+        Map<Integer, Integer> indexMap = new HashMap<>();
+        int n = nums.length;
+
+        // Build the index map
+        for (int i = 0; i < n; i++) {
+            indexMap.put(nums[i], i);
+        }
+
+        // Iterate over each pair
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                int desired = -nums[i] - nums[j];
+                if (indexMap.containsKey(desired) && indexMap.get(desired) != i && indexMap.get(desired) != j) {
+                    List<Integer> triplet = Arrays.asList(nums[i], nums[j], desired);
+                    Collections.sort(triplet);
+                    result.add(triplet);
+                }
+            }
+        }
+
+        return new ArrayList<>(result);
+    }
+}

3Sum - Leetcode 15/3Sum - Leetcode 15.js

@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function(nums) {
+    const indexMap = new Map();
+    const result = new Set();
+    const n = nums.length;
+
+    // Build the index map
+    for (let i = 0; i < n; i++) {
+        indexMap.set(nums[i], i);
+    }
+
+    // Iterate over each pair
+    for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+            const desired = -nums[i] - nums[j];
+            if (indexMap.has(desired) && indexMap.get(desired) !== i && indexMap.get(desired) !== j) {
+                const triplet = [nums[i], nums[j], desired].sort((a, b) => a - b);
+                result.add(triplet.toString());
+            }
+        }
+    }
+
+    return Array.from(result, str => str.split(',').map(Number));
+};

3Sum - Leetcode 15.py renamed to 3Sum - Leetcode 15/3Sum - Leetcode 15.py

@@ -0,0 +1,33 @@
+#include <vector>
+#include <queue>
+
+class Solution {
+public:
+    vector<double> averageOfLevels(TreeNode* root) {
+        vector<double> avgs;
+        if (!root) return avgs;
+
+        queue<TreeNode*> q;
+        q.push(root);
+
+        while (!q.empty()) {
+            double sum = 0;
+            int size = q.size();
+            for (int i = 0; i < size; ++i) {
+                TreeNode* node = q.front();
+                q.pop();
+                sum += node->val;
+
+                if (node->left) {
+                    q.push(node->left);
+                }
+                if (node->right) {
+                    q.push(node->right);
+                }
+            }
+            avgs.push_back(sum / size);
+        }
+
+        return avgs;
+    }
+};

Average of Levels in Binary Tree - Leetcode 637/Average of Levels in Binary Tree - Leetcode 637.cpp

@@ -0,0 +1,43 @@
+import java.util.*;
+
+public class Solution {
+    public List<Double> averageOfLevels(TreeNode root) {
+        List<Double> avgs = new ArrayList<>();
+        if (root == null) return avgs;
+
+        Queue<TreeNode> q = new LinkedList<>();
+        q.add(root);
+
+        while (!q.isEmpty()) {
+            double sum = 0;
+            int size = q.size();
+            for (int i = 0; i < size; i++) {
+                TreeNode node = q.poll();
+                sum += node.val;
+
+                if (node.left != null) {
+                    q.add(node.left);
+                }
+                if (node.right != null) {
+                    q.add(node.right);
+                }
+            }
+            avgs.add(sum / size);
+        }
+
+        return avgs;
+    }
+}
+
+class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+    TreeNode() {}
+    TreeNode(int val) { this.val = val; }
+    TreeNode(int val, TreeNode left, TreeNode right) {
+        this.val = val;
+        this.left = left;
+        this.right = right;
+    }
+}

Average of Levels in Binary Tree - Leetcode 637/Average of Levels in Binary Tree - Leetcode 637.java

@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = val;
+ *     this.left = left === undefined ? null : left;
+ *     this.right = right === undefined ? null : right;
+ * }
+ */
+
+var averageOfLevels = function(root) {
+    let avgs = [];
+    if (root === null) return avgs;
+
+    let q = [root];
+
+    while (q.length > 0) {
+        let sum = 0;
+        let size = q.length;
+        for (let i = 0; i < size; i++) {
+            let node = q.shift();
+            sum += node.val;
+
+            if (node.left !== null) {
+                q.push(node.left);
+            }
+            if (node.right !== null) {
+                q.push(node.right);
+            }
+        }
+        avgs.push(sum / size);
+    }
+
+    return avgs;
+};

Average of Levels in Binary Tree - Leetcode 637/Average of Levels in Binary Tree - Leetcode 637.js

@@ -0,0 +1,24 @@
+
+class Solution {
+public:
+    bool isBalanced(TreeNode* root) {
+        return height(root) != -1;
+    }
+
+private:
+    int height(TreeNode* node) {
+        if (!node) return 0;
+
+        int leftHeight = height(node->left);
+        if (leftHeight == -1) return -1;
+
+        int rightHeight = height(node->right);
+        if (rightHeight == -1) return -1;
+
+        if (abs(leftHeight - rightHeight) > 1) {
+            return -1;
+        }
+
+        return 1 + max(leftHeight, rightHeight);
+    }
+};

Average of Levels in Binary Tree - Leetcode 637.py renamed to Average of Levels in Binary Tree - Leetcode 637/Average of Levels in Binary Tree - Leetcode 637.py

@@ -0,0 +1,34 @@
+public class Solution {
+    public boolean isBalanced(TreeNode root) {
+        return height(root) != -1;
+    }
+
+    private int height(TreeNode node) {
+        if (node == null) return 0;
+
+        int leftHeight = height(node.left);
+        if (leftHeight == -1) return -1;
+
+        int rightHeight = height(node.right);
+        if (rightHeight == -1) return -1;
+
+        if (Math.abs(leftHeight - rightHeight) > 1) {
+            return -1;
+        }
+        
+        return 1 + Math.max(leftHeight, rightHeight);
+    }
+}
+
+class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+    TreeNode() {}
+    TreeNode(int val) { this.val = val; }
+    TreeNode(int val, TreeNode left, TreeNode right) {
+        this.val = val;
+        this.left = left;
+        this.right = right;
+    }
+}

Balanced Binary Tree - Leetcode 110/Balanced Binary Tree - Leetcode 110.cpp

@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = val;
+ *     this.left = left === undefined ? null : left;
+ *     this.right = right === undefined ? null : right;
+ * }
+ */
+
+var isBalanced = function(root) {
+    return height(root) !== -1;
+};
+
+function height(node) {
+    if (node === null) return 0;
+
+    const leftHeight = height(node.left);
+    if (leftHeight === -1) return -1;
+
+    const rightHeight = height(node.right);
+    if (rightHeight === -1) return -1;
+
+    if (Math.abs(leftHeight - rightHeight) > 1) {
+        return -1;
+    }
+
+    return 1 + Math.max(leftHeight, rightHeight);
+}

Balanced Binary Tree - Leetcode 110/Balanced Binary Tree - Leetcode 110.java

@@ -0,0 +1,35 @@
+#include <vector>
+#include <stack>
+#include <string>
+#include <sstream>
+
+using namespace std;
+
+class Solution {
+public:
+    int calPoints(vector<string>& operations) {
+        stack<int> stk;
+
+        for (const string& op : operations) {
+            if (op == "+") {
+                int top = stk.top(); stk.pop();
+                int newTop = top + stk.top();
+                stk.push(top);
+                stk.push(newTop);
+            } else if (op == "D") {
+                stk.push(2 * stk.top());
+            } else if (op == "C") {
+                stk.pop();
+            } else {
+                stk.push(stoi(op));
+            }
+        }
+
+        int sum = 0;
+        while (!stk.empty()) {
+            sum += stk.top(); stk.pop();
+        }
+
+        return sum;
+    }
+};

Balanced Binary Tree - Leetcode 110/Balanced Binary Tree - Leetcode 110.js

@@ -0,0 +1,29 @@
+import java.util.*;
+
+public class Solution {
+    public int calPoints(String[] operations) {
+        Stack<Integer> stack = new Stack<>();
+
+        for (String op : operations) {
+            if (op.equals("+")) {
+                int top = stack.pop();
+                int newTop = top + stack.peek();
+                stack.push(top);
+                stack.push(newTop);
+            } else if (op.equals("D")) {
+                stack.push(stack.peek() * 2);
+            } else if (op.equals("C")) {
+                stack.pop();
+            } else {
+                stack.push(Integer.parseInt(op));
+            }
+        }
+
+        int sum = 0;
+        while (!stack.isEmpty()) {
+            sum += stack.pop();
+        }
+        
+        return sum;
+    }
+}

Balanced Binary Tree - Leetcode 110.py renamed to Balanced Binary Tree - Leetcode 110/Balanced Binary Tree - Leetcode 110.py

@@ -0,0 +1,24 @@
+/**
+ * @param {string[]} operations
+ * @return {number}
+ */
+var calPoints = function(operations) {
+    const stack = [];
+
+    for (const op of operations) {
+        if (op === "+") {
+            const top = stack.pop();
+            const newTop = top + stack[stack.length - 1];
+            stack.push(top);
+            stack.push(newTop);
+        } else if (op === "D") {
+            stack.push(stack[stack.length - 1] * 2);
+        } else if (op === "C") {
+            stack.pop();
+        } else {
+            stack.push(parseInt(op));
+        }
+    }
+
+    return stack.reduce((acc, val) => acc + val, 0);
+};