LeetCode javascript top 10 questions with solutions

 LeetCode covers a broad range of topics from Arrays, Strings, Linked Lists, Trees, Graphs, Dynamic Programming, Backtracking, and more. I'll also give you sample solutions for some popular problem types to demonstrate how to implement them in JavaScript.

Here’s a structured breakdown of the Top 100 LeetCode Problems in terms of their categories, and I’ll show you how to solve a few of them in JavaScript:

Categories & Topics

1. Array

   • Two Sum
   • Best Time to Buy and Sell Stock
   • Contains Duplicate
   • Merge Intervals
   • Rotate Image

2. String

   • Longest Substring Without Repeating Characters
   • Reverse String
   • Valid Anagram
   • String to Integer (atoi)
   • Palindrome Number

3. Linked List

   • Reverse Linked List
   • Merge Two Sorted Lists
   • Remove Nth Node From End of List
   • Add Two Numbers
   • Intersection of Two Linked Lists

4. Tree

   • Binary Tree Inorder Traversal
   • Maximum Depth of Binary Tree
   • Symmetric Tree
   • Convert Sorted Array to Binary Search Tree
   • Binary Tree Level Order Traversal

5. Dynamic Programming

   • Climbing Stairs
   • Longest Increasing Subsequence
   • Coin Change
   • Word Break
   • Decode Ways

6. Backtracking

   • Generate Parentheses
   • Permutations
   • Subsets
   • N-Queens

7. Sorting & Searching

   • Merge Intervals
   • Search Insert Position
   • Kth Largest Element in an Array
   • Find First and Last Position of Element in Sorted Array
   • Top K Frequent Elements

8. Graph

   • Number of Islands
   • Course Schedule
   • Clone Graph
   • Surrounded Regions

9. Math

   • Excel Sheet Column Number
   • Happy Number
   • Count Primes
   • Find the Duplicate Number

10. Miscellaneous

    • Valid Parentheses
    • Intersection of Two Arrays
    • 3Sum
    • LRU Cache

Sample JavaScript Solutions

1. Two Sum (Array)

Problem: Given an array of integers, return the indices of the two numbers such that they add up to a specific target.

function twoSum(nums, target) {
    const map = new Map();
    for (let i = 0; i < nums.length; i++) {
        const complement = target - nums[i];
        if (map.has(complement)) {
            return [map.get(complement), i];
        }
        map.set(nums[i], i);
    }
    return [];
}

2. Longest Substring Without Repeating Characters (String)

Problem: Given a string, find the length of the longest substring without repeating characters.

function lengthOfLongestSubstring(s) {
    let map = new Map();
    let start = 0, maxLength = 0;
    for (let end = 0; end < s.length; end++) {
        if (map.has(s[end])) {
            start = Math.max(start, map.get(s[end]) + 1);
        }
        map.set(s[end], end);
        maxLength = Math.max(maxLength, end - start + 1);
    }
    return maxLength;
}

3. Reverse Linked List (Linked List)

Problem: Reverse a singly linked list.

function reverseList(head) {
    let prev = null;
    let current = head;
    while (current) {
        let nextTemp = current.next;
        current.next = prev;
        prev = current;
        current = nextTemp;
    }
    return prev;
}

4. Maximum Depth of Binary Tree (Tree)

Problem: Given a binary tree, find its maximum depth.

function maxDepth(root) {
    if (root === null) {
        return 0;
    }
    let leftDepth = maxDepth(root.left);
    let rightDepth = maxDepth(root.right);
    return Math.max(leftDepth, rightDepth) + 1;
}

5. Coin Change (Dynamic Programming)

Problem: Given an array of coins and a total amount, find the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.

function coinChange(coins, amount) {
    let dp = Array(amount + 1).fill(Infinity);
    dp[0] = 0;
    for (let i = 1; i <= amount; i++) {
        for (let coin of coins) {
            if (i - coin >= 0) {
                dp[i] = Math.min(dp[i], dp[i - coin] + 1);
            }
        }
    }
    return dp[amount] === Infinity ? -1 : dp[amount];
}

6. Permutations (Backtracking)

Problem: Given a collection of distinct integers, return all possible permutations.

function permute(nums) {
    let res = [];
    function backtrack(start = 0) {
        if (start === nums.length) {
            res.push([...nums]);
        }
        for (let i = start; i < nums.length; i++) {
            [nums[start], nums[i]] = [nums[i], nums[start]];  // Swap
            backtrack(start + 1);
            [nums[start], nums[i]] = [nums[i], nums[start]];  // Backtrack
        }
    }
    backtrack();
    return res;
}

7. Merge Intervals (Sorting & Searching)

Problem: Given a collection of intervals, merge all overlapping intervals.

function merge(intervals) {
    if (intervals.length === 0) return [];
    intervals.sort((a, b) => a[0] - b[0]);
    let result = [intervals[0]];
    for (let i = 1; i < intervals.length; i++) {
        let last = result[result.length - 1];
        let current = intervals[i];
        if (current[0] <= last[1]) {
            last[1] = Math.max(last[1], current[1]);
        } else {
            result.push(current);
        }
    }
    return result;
}

8. Number of Islands (Graph)

Problem: Given a 2D grid of '1's (land) and '0's (water), count the number of islands.

function numIslands(grid) {
    if (grid.length === 0) return 0;
    let count = 0;
    
    function dfs(i, j) {
        if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] === '0') {
            return;
        }
        grid[i][j] = '0';  // Mark the cell as visited
        dfs(i - 1, j);  // Up
        dfs(i + 1, j);  // Down
        dfs(i, j - 1);  // Left
        dfs(i, j + 1);  // Right
    }

    for (let i = 0; i < grid.length; i++) {
        for (let j = 0; j < grid[0].length; j++) {
            if (grid[i][j] === '1') {
                count++;
                dfs(i, j);  // Mark all connected '1's
            }
        }
    }
    return count;
}

---

How to Find the "Top 10" Problems on LeetCode

• LeetCode Explore Section: LeetCode has a "Explore" section with curated sets of problems. You can check out the Top Interview Questions or the LeetCode 75 problem set to find popular problems.

• LeetCode Problem Difficulty: Problems are categorized by difficulty—Easy, Medium, and Hard. The most frequently asked questions in interviews are generally Medium difficulty.

• LeetCode Discussion Forum: Many users share their solutions and discuss the most important and frequently asked questions in the LeetCode Discuss forum.

---

I hope this overview helps you get started on tackling some of the most important and frequently asked LeetCode problems in JavaScript! Would you like more in-depth solutions for any specific category or problem?