Top C++ Coding Interview Questions With Real Solutions
2025-08-16
C++ remains one of the most popular languages for technical interviews because it gives you control over performance, memory, and data structures. If you want to ace interviews, you should master the core problem patterns that come up again and again. Below are some of the top C++ interview questions with real solutions you can run and explain.
1) Two Sum
Pattern: Hash Map lookup.
#include <vector>
#include <unordered_map>
using namespace std;
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int,int> seen;
for (int i = 0; i < nums.size(); i++) {
int need = target - nums[i];
if (seen.count(need)) return {seen[need], i};
seen[nums[i]] = i;
}
return {};
}
Why it matters: Tests hash map use, O(n) lookup.
2) Reverse a Linked List
Pattern: Iterative pointer manipulation.
struct ListNode {
int val;
ListNode* next;
ListNode(int v) : val(v), next(nullptr) {}
};
ListNode* reverseList(ListNode* head) {
ListNode* prev = nullptr;
while (head) {
ListNode* nxt = head->next;
head->next = prev;
prev = head;
head = nxt;
}
return prev;
}
Why it matters: Pointer control is a classic C++ interview test.
3) Merge Intervals
Pattern: Greedy with sorting.
#include <vector>
#include <algorithm>
using namespace std;
vector<vector<int>> merge(vector<vector<int>>& intervals) {
if (intervals.empty()) return {};
sort(intervals.begin(), intervals.end());
vector<vector<int>> res;
res.push_back(intervals[0]);
for (int i = 1; i < intervals.size(); i++) {
if (intervals[i][0] <= res.back()[1]) {
res.back()[1] = max(res.back()[1], intervals[i][1]);
} else {
res.push_back(intervals[i]);
}
}
return res;
}
Why it matters: Common interval scheduling/merge pattern.
4) Longest Substring Without Repeating Characters
Pattern: Sliding Window.
#include <string>
#include <unordered_map>
using namespace std;
int lengthOfLongestSubstring(string s) {
unordered_map<char,int> pos;
int left = 0, best = 0;
for (int right = 0; right < s.size(); right++) {
char c = s[right];
if (pos.count(c) && pos[c] >= left) left = pos[c] + 1;
pos[c] = right;
best = max(best, right - left + 1);
}
return best;
}
5) Search in Rotated Sorted Array
Pattern: Binary Search with conditions.
#include <vector>
using namespace std;
int search(vector<int>& nums, int target) {
int lo = 0, hi = nums.size() - 1;
while (lo <= hi) {
int mid = lo + (hi - lo) / 2;
if (nums[mid] == target) return mid;
if (nums[lo] <= nums[mid]) {
if (nums[lo] <= target && target < nums[mid]) hi = mid - 1;
else lo = mid + 1;
} else {
if (nums[mid] < target && target <= nums[hi]) lo = mid + 1;
else hi = mid - 1;
}
}
return -1;
}
6) Kth Largest Element
Pattern: Min Heap of size k.
#include <vector>
#include <queue>
using namespace std;
int findKthLargest(vector<int>& nums, int k) {
priority_queue<int, vector<int>, greater<int>> pq;
for (int n : nums) {
pq.push(n);
if (pq.size() > k) pq.pop();
}
return pq.top();
}
7) Number of Islands
Pattern: DFS flood fill.
#include <vector>
using namespace std;
void dfs(vector<vector<char>>& g, int i, int j) {
if (i < 0 || j < 0 || i >= g.size() || j >= g[0].size() || g[i][j] == '0') return;
g[i][j] = '0';
dfs(g, i+1, j); dfs(g, i-1, j); dfs(g, i, j+1); dfs(g, i, j-1);
}
int numIslands(vector<vector<char>>& grid) {
int m = grid.size(), n = grid[0].size(), count = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] == '1') {
dfs(grid, i, j);
count++;
}
}
}
return count;
}
8) LRU Cache
Pattern: HashMap + Doubly Linked List.
#include <unordered_map>
using namespace std;
struct Node {
int key, val;
Node* prev;
Node* next;
Node(int k, int v) : key(k), val(v), prev(nullptr), next(nullptr) {}
};
class LRUCache {
int cap;
unordered_map<int, Node*> map;
Node* head; Node* tail;
void remove(Node* node) {
node->prev->next = node->next;
node->next->prev = node->prev;
}
void insert(Node* node) {
node->next = head->next;
node->prev = head;
head->next->prev = node;
head->next = node;
}
public:
LRUCache(int capacity) {
cap = capacity;
head = new Node(0,0);
tail = new Node(0,0);
head->next = tail; tail->prev = head;
}
int get(int key) {
if (!map.count(key)) return -1;
Node* node = map[key];
remove(node); insert(node);
return node->val;
}
void put(int key, int value) {
if (map.count(key)) {
Node* node = map[key];
node->val = value;
remove(node); insert(node);
} else {
if (map.size() == cap) {
Node* lru = tail->prev;
remove(lru);
map.erase(lru->key);
delete lru;
}
Node* node = new Node(key, value);
map[key] = node;
insert(node);
}
}
};
9) Dynamic Programming – House Robber
#include <vector>
using namespace std;
int rob(vector<int>& nums) {
int prev2 = 0, prev1 = 0;
for (int n : nums) {
int take = prev2 + n;
int skip = prev1;
int cur = max(take, skip);
prev2 = prev1;
prev1 = cur;
}
return prev1;
}
10) Backtracking – Generate Parentheses
#include <vector>
#include <string>
using namespace std;
void backtrack(int n, int open, int close, string cur, vector<string>& res) {
if (cur.size() == 2 * n) { res.push_back(cur); return; }
if (open < n) backtrack(n, open + 1, close, cur + "(", res);
if (close < open) backtrack(n, open, close + 1, cur + ")", res);
}
vector<string> generateParenthesis(int n) {
vector<string> res;
backtrack(n, 0, 0, "", res);
return res;
}
Interview Checklist
- Arrays & Hashing: Two Sum, Product of Array Except Self
- Linked List: Reverse List, Detect Cycle, Merge Two Lists
- Greedy: Merge Intervals, Jump Game
- Binary Search: Rotated Sorted Array, First Bad Version
- Dynamic Programming: Climbing Stairs, Coin Change, LIS
- Graphs: Number of Islands, Clone Graph, Course Schedule
- Heap & Priority Queue: Kth Largest, Top K Frequent
- System Design Level: LRU Cache
Final Note
If you can master these problems and explain why the solution works, you’ll cover 80% of what C++ interviews test. Focus on patterns: two pointers, sliding window, binary search, greedy, DFS/BFS, heap, DP, and backtracking.
When you’re stuck and want to see a step-by-step C++ solution with explanation while practicing, tools like StealthCoder can help you stay on track and learn faster.