LeetCode Interview Questions Medium (51–100) with Logic
The LeetCode interview questions medium set (51–100) represents the real difficulty
level asked in most technical interviews.
These problems test your understanding of data structures, recursion, trees, binary search,
and problem-solving patterns.
Why Medium LeetCode Questions Matter
- Most real interviews are medium difficulty
- Tests reasoning, not memorization
- Builds confidence for advanced problems
- Frequently asked by product-based companies
BINARY SEARCH (51–60)
51. Binary Search
function search(nums,target){
let l=0,r=nums.length-1;
while(l<=r){
let mid=Math.floor((l+r)/2);
if(nums[mid]===target) return mid;
nums[mid]<target?l=mid+1:r=mid-1;
}
return -1;
}
52. Search in Rotated Sorted Array
function search(nums,target){
let l=0,r=nums.length-1;
while(l<=r){
let mid=Math.floor((l+r)/2);
if(nums[mid]===target) return mid;
if(nums[l]<=nums[mid]){
target>=nums[l]&&target<nums[mid]?r=mid-1:l=mid+1;
}else{
target>nums[mid]&&target<=nums[r]?l=mid+1:r=mid-1;
}
}
return -1;
}
53. Find Minimum in Rotated Sorted Array
function findMin(nums){
let l=0,r=nums.length-1;
while(l<r){
let mid=Math.floor((l+r)/2);
nums[mid]>nums[r]?l=mid+1:r=mid;
}
return nums[l];
}
LINKED LIST (61–70)
61. Linked List Cycle
function hasCycle(head){
let slow=head,fast=head;
while(fast&&fast.next){
slow=slow.next;
fast=fast.next.next;
if(slow===fast) return true;
}
return false;
}
62. Remove Nth Node From End
function removeNthFromEnd(head,n){
let dummy={next:head},fast=dummy,slow=dummy;
for(let i=0;i<=n;i++) fast=fast.next;
while(fast){
fast=fast.next;
slow=slow.next;
}
slow.next=slow.next.next;
return dummy.next;
}
63. Add Two Numbers
function addTwoNumbers(l1,l2){
let dummy=new ListNode(0),cur=dummy,carry=0;
while(l1||l2||carry){
let sum=(l1?.val||0)+(l2?.val||0)+carry;
carry=Math.floor(sum/10);
cur.next=new ListNode(sum%10);
cur=cur.next;
l1=l1?.next;l2=l2?.next;
}
return dummy.next;
}
TREES (71–85)
71. Maximum Depth of Binary Tree
function maxDepth(root){
if(!root) return 0;
return 1+Math.max(maxDepth(root.left),maxDepth(root.right));
}
72. Same Tree
function isSameTree(p,q){
if(!p&&!q) return true;
if(!p||!q||p.val!==q.val) return false;
return isSameTree(p.left,q.left)&&isSameTree(p.right,q.right);
}
73. Invert Binary Tree
function invertTree(root){
if(!root) return null;
[root.left,root.right]=[invertTree(root.right),invertTree(root.left)];
return root;
}
74. Binary Tree Level Order Traversal
function levelOrder(root){
if(!root) return [];
let res=[],queue=[root];
while(queue.length){
let size=queue.length,level=[];
for(let i=0;i<size;i++){
let node=queue.shift();
level.push(node.val);
node.left&&queue.push(node.left);
node.right&&queue.push(node.right);
}
res.push(level);
}
return res;
}
RECURSION & BACKTRACKING (86–95)
86. Subsets
function subsets(nums){
let res=[];
function backtrack(i,path){
res.push([...path]);
for(let j=i;j<nums.length;j++){
path.push(nums[j]);
backtrack(j+1,path);
path.pop();
}
}
backtrack(0,[]);
return res;
}
87. Permutations
function permute(nums){
let res=[];
function backtrack(path,used){
if(path.length===nums.length){
res.push([...path]);return;
}
for(let i=0;i<nums.length;i++){
if(used[i]) continue;
used[i]=true;
path.push(nums[i]);
backtrack(path,used);
path.pop();used[i]=false;
}
}
backtrack([],Array(nums.length).fill(false));
return res;
}
DYNAMIC PROGRAMMING (96–100)
96. House Robber
function rob(nums){
let prev=0,curr=0;
for(let n of nums){
let temp=Math.max(curr,prev+n);
prev=curr;
curr=temp;
}
return curr;
}
97. Coin Change
function coinChange(coins,amount){
let dp=Array(amount+1).fill(Infinity);
dp[0]=0;
for(let i=1;i<=amount;i++)
for(let c of coins)
if(i-c>=0) dp[i]=Math.min(dp[i],dp[i-c]+1);
return dp[amount]===Infinity?-1:dp[amount];
}
98. Longest Increasing Subsequence
function lengthOfLIS(nums){
let dp=Array(nums.length).fill(1);
for(let i=0;i<nums.length;i++)
for(let j=0;j<i;j++)
if(nums[i]>nums[j])
dp[i]=Math.max(dp[i],dp[j]+1);
return Math.max(...dp);
}
99. Unique Paths
function uniquePaths(m,n){
let dp=Array(n).fill(1);
for(let i=1;i<m;i++)
for(let j=1;j<n;j++)
dp[j]+=dp[j-1];
return dp[n-1];
}
100. Jump Game
function canJump(nums){
let reach=0;
for(let i=0;i<nums.length;i++){
if(i>reach) return false;
reach=Math.max(reach,i+nums[i]);
}
return true;
}
Next Step: Advanced Level (101–150)
You are now interview-ready at medium level.
The final step is mastering advanced LeetCode interview questions (101–150)
covering graphs, advanced DP, greedy, and system-level thinking.
Continue with:
LeetCode Top 150 Interview Questions (101–150) – Advanced Level