Skip to content
Data Structures and Algorithms
All coursesPlacement Report
‹ Back to previous sectionCourse homeAll page URLs

Data Structures and Algorithms Interview Questions in Bangalore

36 practice questions with answers for Data Structures and Algorithms interviews in Bangalore.

Data Structures and Algorithms jobs in Bangalore

Bangalore (Bengaluru) is India's largest technology hub, with global product companies, engineering centres, unicorn start-ups and big IT-services campuses. Product-company interviews here are usually deeper, with more scenario, design and hands-on rounds.

Below are 36 questions that match the mix of service, product and domain employers hiring software engineer (fresher / sde-1)s in Bangalore.

Solved for BangaloreStart practicing
3 QUESTIONS FREESign up to unlock the full question bank and track your progress.Unlock every question and answer, then continue practising company-wise and package-wise.
3 questions free Unlock the rest in seconds
01

Find the kth largest element in an array using a heap.

Heaps, Priority Queues and GreedyEasy
Save to ▾
Show answer
import heapq def kth_largest(nums, k): heap = [] for x in nums: heapq.heappush(heap, x) if len(heap) > k: heapq.heappop(heap) # drop the smallest return heap[0] # smallest of the k largest # kth_largest([3, 2, 1, 5, 6, 4], 2) -> 5 # O(n log k) time, O(k) space; quickselect gives O(n) average
02

What is the difference between full, complete and perfect binary trees?

Trees and Binary Search TreesEasy
Save to ▾
Show answer
In a full binary tree every node has zero or two children. In a complete binary tree every level except possibly the last is completely filled, and the last level is filled from the left, which is exactly the shape of a binary heap and allows array storage. A perfect binary tree has all internal nodes with two children and all leaves at the same level, containing 2 to the power h plus 1, minus 1 nodes.
03

Merge K sorted linked lists using a min-heap.

Heaps, Priority Queues and GreedyMedium
Save to ▾
Show answer
import heapq def merge_k_lists(lists): heap = [] for i, node in enumerate(lists): if node: heapq.heappush(heap, (node.val, i, node)) # i breaks ties dummy = tail = ListNode() while heap: val, i, node = heapq.heappop(heap) tail.next = node tail = node if node.next: heapq.heappush(heap, (node.next.val, i, node.next)) return dummy.next # O(N log K) for N total nodes
04

What are lower bound and upper bound, and what common bugs appear in binary search?

Sorting, Searching and BacktrackingMedium
Save to ▾
Show answer
Lower bound returns the first index whose value is not less than the target, and upper bound the first index whose value is greater, so their difference counts occurrences. Common bugs are off-by-one errors in the loop condition, infinite loops when mid does not move, and integer overflow from (low plus high) divided by 2 in Java or C++; use low plus (high minus low) divided by 2. Python's bisect module provides both functions.
05

You must build autocomplete for a search box over one million product names. Which data structure would you use?

Trees and Binary Search TreesMedium
Save to ▾
Show answer
I would use a trie where each node stores, besides children, the top few most popular completions under that prefix. Then typing a prefix walks L nodes and returns precomputed suggestions instantly, without exploring the whole subtree. Memory can be reduced with a compressed radix trie. For typo tolerance or ranking by many signals, a search engine with prefix indexes is more practical at large scale.
06

In activity selection, why do we sort by end time rather than start time or duration?

Heaps, Priority Queues and GreedyMedium
Save to ▾
Show answer
Choosing the activity that finishes earliest leaves the most remaining time for others, and an exchange argument shows that any optimal schedule can swap its first activity for the earliest-finishing one without losing count. Sorting by start time fails when an early activity runs very long, and sorting by duration fails when a short activity overlaps two compatible ones. The algorithm is O(n log n) for sorting plus one pass.
07

A problem has n up to 100000. Which time complexities are acceptable for a 1-second limit?

Complexity Analysis and RecursionMedium
Save to ▾
Show answer
A common rule is that judges run about 10 to the power 8 simple operations per second. With n equal to 10 to the power 5, O(n log n) is about 1.7 million operations and O(n) is trivial, both fine. O(n squared) is 10 to the power 10 operations, far too slow. So I would look for sorting, hashing, two pointers, binary search or prefix sums rather than nested loops over all pairs.
08

How does merge sort work and what are its properties?

Sorting, Searching and BacktrackingMedium
Save to ▾
Show answer
Merge sort splits the array into halves, recursively sorts each half and merges the two sorted halves in linear time. The recurrence T(n) = 2T(n/2) + n gives O(n log n) in every case. It is stable and works well for linked lists and external sorting of large files, but needs O(n) extra space for arrays. It also adapts to counting inversions during the merge step.
09

How does heap sort work and how does it compare with quicksort and merge sort?

Heaps, Priority Queues and GreedyMedium
Save to ▾
Show answer
Heap sort builds a max-heap in O(n), then repeatedly swaps the root with the last element, shrinks the heap and sifts down, giving O(n log n) in all cases with O(1) extra space. It is not stable and has poor cache locality, so in practice it is slower than quicksort. Merge sort is stable but needs O(n) space. Introsort switches from quicksort to heap sort to guarantee O(n log n).
10

What is the difference between a linked list and an array?

Linked Lists, Stacks and QueuesEasy
Save to ▾
Show answer
An array stores elements contiguously, giving O(1) index access and good cache performance, but inserting or deleting in the middle costs O(n) because elements shift. A linked list stores nodes with pointers to the next node, so insertion and deletion at a known node are O(1), but finding the i-th element takes O(n) and each node has pointer overhead. Arrays suit read-heavy work, lists suit frequent splicing.
11

A cashier system uses the greedy rule of always giving the largest coin first. When can this fail?

Heaps, Priority Queues and GreedyEasy
Save to ▾
Show answer
Greedy coin change is optimal for canonical systems such as Indian rupee denominations, but fails for arbitrary coin sets. With coins 1, 3 and 4 and amount 6, greedy gives 4 plus 1 plus 1, three coins, while 3 plus 3 uses only two. For arbitrary denominations, use dynamic programming where dp of x is the minimum coins for amount x, computed in O(amount times number of coins).
12

Find the minimum number of railway platforms needed given arrival and departure times.

Heaps, Priority Queues and GreedyMedium
Save to ▾
Show answer
// Java static int minPlatforms(int[] arr, int[] dep) { Arrays.sort(arr); Arrays.sort(dep); int i = 0, j = 0, cur = 0, best = 0; while (i < arr.length) { if (arr[i] <= dep[j]) { // a train arrives before the next departs cur++; i++; best = Math.max(best, cur); } else { cur--; j++; } } return best; } // O(n log n) for sorting, O(1) extra space.
13

Explain the sliding window technique with fixed and variable windows.

Arrays, Strings and HashingMedium
Save to ▾
Show answer
A sliding window keeps a contiguous range and updates its result incrementally instead of recomputing. A fixed window of size k, such as the maximum sum of k consecutive elements, adds the new element and removes the old one each step in O(n). A variable window grows the right end and shrinks the left end while a condition is violated, as in the longest substring without repeating characters. Both turn O(n squared) into O(n).
14

Find the shortest path length from the top-left to the bottom-right of a grid where 1 is a wall.

Graphs and Graph AlgorithmsMedium
Save to ▾
Show answer
from collections import deque def shortest_path(grid): R, C = len(grid), len(grid[0]) if grid[0][0] or grid[R-1][C-1]: return -1 q = deque([(0, 0, 1)]) seen = {(0, 0)} while q: r, c, d = q.popleft() if (r, c) == (R - 1, C - 1): return d for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)): nr, nc = r + dr, c + dc if 0 <= nr < R and 0 <= nc < C and not grid[nr][nc] and (nr, nc) not in seen: seen.add((nr, nc)) q.append((nr, nc, d + 1)) return -1 # BFS: O(R * C)
15

Why are you looking for a change from your current job?

Sorting, Searching and BacktrackingMedium
Save to ▾
Show answer
Situation: in my current role I have learned a lot maintaining internal tools for two years. Task: I want to grow into harder engineering problems. Action: I have been strengthening my data structures, system design and backend skills through projects and by taking ownership of performance work in my team. Result: I am now ready for a role with larger scale and more technical depth, which is why this position appeals to me.
16

Tell me about yourself for a software engineer role.

Sorting, Searching and BacktrackingEasy
Save to ▾
Show answer
Situation: I am a computer science graduate who enjoys problem solving. Task: become a strong software engineer. Action: I have solved over 400 data structures and algorithms problems, built a campus event app and a file search tool using tries and hashing, and completed an internship where I fixed performance issues in a backend service. Result: I can write clean, efficient code, explain trade-offs clearly, and I am eager to contribute to your engineering team.
17

What is a greedy algorithm and when does it give the optimal answer?

Heaps, Priority Queues and GreedyMedium
Save to ▾
Show answer
A greedy algorithm builds a solution step by step, always taking the choice that looks best right now and never revisiting it. It is optimal only when the problem has the greedy choice property, meaning a locally best choice is part of some optimal solution, and optimal substructure. Examples where greedy works are activity selection, Huffman coding, Dijkstra and Kruskal. For many problems, such as 0/1 knapsack, it fails.
18

Packages with given weights must be shipped in order within D days. How do you find the minimum ship capacity?

Sorting, Searching and BacktrackingMedium
Save to ▾
Show answer
The capacity lies between the heaviest package and the total weight, and if a capacity works, any larger one also works, so binary search the answer. For a candidate capacity, greedily load packages day by day, starting a new day when the next package does not fit, and count days. If the days are within D, try smaller; otherwise try larger. Time is O(n log of total weight).
19

A trading application needs a stack that also returns the current minimum in O(1). How would you design it?

Linked Lists, Stacks and QueuesMedium
Save to ▾
Show answer
Keep a second stack of minimums. On push, push the value onto the main stack and push the smaller of the value and the current minimum onto the min stack. On pop, pop both. getMin returns the top of the min stack in O(1). To save space, push onto the min stack only when the new value is less than or equal to the current minimum, and pop it only when the popped value equals it.
20

Your brute-force solution for the longest substring without repeating characters is O(n cubed). How would you improve it?

Arrays, Strings and HashingMedium
Save to ▾
Show answer
I would use a variable sliding window. Keep a map from character to its last index and a left pointer. Move the right pointer through the string; when the current character was seen at an index at or after left, move left to that index plus one. Update the best length at each step. Each character is processed a constant number of times, giving O(n) time and O(alphabet size) space.
21

Solve house robber: maximise money robbed from houses in a row without robbing two adjacent houses.

Dynamic ProgrammingEasy
Save to ▾
Show answer
def rob(nums): take, skip = 0, 0 # best if the previous house is taken or skipped for x in nums: take, skip = skip + x, max(take, skip) return max(take, skip) # rob([2, 7, 9, 3, 1]) -> 12 (2 + 9 + 1) # dp[i] = max(dp[i-1], dp[i-2] + nums[i]); O(n) time, O(1) space
22

Users enter formulas with brackets in a spreadsheet tool. How do you validate that the brackets are balanced?

Linked Lists, Stacks and QueuesEasy
Save to ▾
Show answer
Scan the formula once with a stack. Push every opening bracket; on a closing bracket, check that the stack is not empty and its top is the matching opening type, then pop. Ignore other characters. At the end the stack must be empty. This is O(n) time and handles nested mixes such as parentheses inside square brackets. To show useful errors, record the position of the first mismatch or unclosed bracket.
23

Your recursive solution passes with memoisation, but the interviewer asks for a bottom-up version. How do you convert it?

Dynamic ProgrammingMedium
Save to ▾
Show answer
I identify the recursion parameters, which become the table dimensions, and the base cases, which become the initial cells. Then I look at which states each call depends on, for example index plus 1, and fill the table in the opposite order, so dependencies are computed first. The recursive transition becomes the loop body. Finally I check whether only the last row is used, so I can reduce space, and walk through a small example.
24

Check whether a string is a palindrome, ignoring case and non-alphanumeric characters.

Arrays, Strings and HashingEasy
Save to ▾
Show answer
// Java static boolean isPalindrome(String s) { int i = 0, j = s.length() - 1; while (i < j) { char a = s.charAt(i), b = s.charAt(j); if (!Character.isLetterOrDigit(a)) { i++; continue; } if (!Character.isLetterOrDigit(b)) { j--; continue; } if (Character.toLowerCase(a) != Character.toLowerCase(b)) return false; i++; j--; } return true; } // Two pointers, O(n) time, O(1) space.
25

How do you prioritise when several tasks have deadlines at the same time?

Heaps, Priority Queues and GreedyMedium
Save to ▾
Show answer
Situation: in one sprint I had a bug fix, a feature and interview preparation for a new hire panel all due together. Task: deliver without dropping quality. Action: I listed the tasks with impact and deadline, discussed the order with my lead, finished the customer-facing bug first, split the feature into smaller deliverables and blocked calendar time for each. Result: everything was delivered within the week and nothing urgent slipped.
26

What is edit distance and where is it used?

Dynamic ProgrammingMedium
Save to ▾
Show answer
Edit distance, or Levenshtein distance, is the minimum number of insertions, deletions and substitutions to turn one string into another. dp[i][j] is the distance between the first i characters of A and the first j of B; if characters match, take dp[i-1][j-1], otherwise 1 plus the minimum of the three neighbouring cells. It runs in O(m times n) and is used in spell checkers, fuzzy search, DNA alignment and plagiarism detection.
27

Implement Kadane's algorithm for the maximum subarray sum.

Arrays, Strings and HashingEasy
Save to ▾
Show answer
def max_subarray(nums): best = current = nums[0] for x in nums[1:]: current = max(x, current + x) # extend or start fresh best = max(best, current) return best # max_subarray([-2, 1, -3, 4, -1, 2, 1, -5, 4]) -> 6 (subarray 4, -1, 2, 1)
28

You must merge two sorted arrays where the first array has enough empty space at the end for the second. How would you do it in place?

Arrays, Strings and HashingMedium
Save to ▾
Show answer
Merging from the front would overwrite unread elements, so merge from the back. Use three pointers: the last real element of the first array, the last element of the second, and the last slot of the first array. Repeatedly place the larger of the two candidates at the write position and move pointers left. When the second array is exhausted, the rest is already in place. This takes O(m plus n) time and O(1) space.
29

What is time complexity and what does Big-O notation mean?

Complexity Analysis and RecursionEasy
Save to ▾
Show answer
Time complexity describes how the number of steps an algorithm performs grows as the input size n grows, ignoring machine speed. Big-O gives an upper bound on that growth for large n and drops constants and lower terms, so 3n squared plus 5n becomes O(n squared). It lets you compare approaches before coding; for example binary search at O(log n) beats linear search at O(n) on large sorted data.
30

Solve climbing stairs: how many ways are there to climb n steps taking 1 or 2 steps at a time?

Dynamic ProgrammingEasy
Save to ▾
Show answer
def climb_stairs(n): if n <= 2: return n prev2, prev1 = 1, 2 # ways(1), ways(2) for _ in range(3, n + 1): prev2, prev1 = prev1, prev1 + prev2 return prev1 # ways(n) = ways(n-1) + ways(n-2): a Fibonacci pattern # climb_stairs(5) -> 8; O(n) time, O(1) space
31

What is a heap and how is it stored in an array?

Heaps, Priority Queues and GreedyEasy
Save to ▾
Show answer
A binary heap is a complete binary tree where every parent is smaller than its children in a min-heap or larger in a max-heap, so the root is the minimum or maximum. Because the tree is complete, it is stored in an array without pointers: for index i, children are at 2i plus 1 and 2i plus 2 and the parent at (i minus 1) divided by 2. This layout is compact and cache friendly.
32

How do you find the lowest common ancestor in a BST versus in a general binary tree?

Trees and Binary Search TreesMedium
Save to ▾
Show answer
In a BST, start at the root: if both values are smaller go left, if both are larger go right, otherwise the current node is the LCA, taking O(h). In a general binary tree, recurse: if the node is null or matches either target, return it; otherwise search both subtrees. If both sides return non-null, the current node is the LCA; else return the non-null side. That takes O(n).
33

Explain best, average and worst case complexity using quicksort.

Complexity Analysis and RecursionMedium
Save to ▾
Show answer
Best case is the minimum work over inputs of size n, worst case the maximum and average case the expected work over typical inputs. Quicksort averages O(n log n) because random pivots split arrays reasonably evenly. Its worst case is O(n squared) when the pivot is always the smallest or largest element, such as sorted input with a first-element pivot. Random pivots or median-of-three make the worst case very unlikely.
34

Implement topological sort using Kahn's algorithm.

Graphs and Graph AlgorithmsMedium
Save to ▾
Show answer
from collections import deque def topo_sort(n, edges): adj = [[] for _ in range(n)] indeg = [0] * n for u, v in edges: # u must come before v adj[u].append(v) indeg[v] += 1 q = deque(i for i in range(n) if indeg[i] == 0) order = [] while q: u = q.popleft() order.append(u) for v in adj[u]: indeg[v] -= 1 if indeg[v] == 0: q.append(v) return order if len(order) == n else [] # empty means a cycle exists
35

Generate all permutations of a list of distinct numbers using backtracking.

Sorting, Searching and BacktrackingMedium
Save to ▾
Show answer
def permutations(nums): result, path = [], [] used = [False] * len(nums) def backtrack(): if len(path) == len(nums): result.append(path[:]) return for i, x in enumerate(nums): if used[i]: continue used[i] = True path.append(x) backtrack() path.pop() # undo the choice used[i] = False backtrack() return result # n! permutations: O(n * n!) time
36

What is backtracking?

Sorting, Searching and BacktrackingEasy
Save to ▾
Show answer
Backtracking builds a solution step by step and abandons a partial solution as soon as it cannot lead to a valid answer, then undoes the last choice and tries the next. It is a DFS over the space of choices. It solves permutations, combinations, subsets, N-Queens, Sudoku and word search. The worst case is often exponential, so good pruning, such as checking constraints early, is what makes it practical.

Companies with offices in Bangalore (20)

Product

Amazon

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Bengaluru, Hyderabad, Chennai +2

View questions
Product

Google

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Bengaluru, Hyderabad, Gurugram +2

View questions
Product

Microsoft

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Hyderabad, Bengaluru, Noida +2

View questions
Product

Meta

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Gurugram, Bengaluru, Hyderabad +1

View questions
Product

Adobe

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Noida, Bengaluru, Gurugram

View questions
Hardware & semiconductors

Apple

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Hyderabad, Bengaluru, Mumbai +1

View questions
E-commerce & consumer tech

Flipkart

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Bengaluru, Hyderabad

View questions
E-commerce & consumer tech

Walmart

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Bengaluru, Chennai, Gurugram

View questions
Product

Uber

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Bengaluru, Hyderabad, Gurugram

View questions
Product

Atlassian

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Bengaluru

View questions
Product

Salesforce

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Hyderabad, Bengaluru, Mumbai +1

View questions
Product

Oracle

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Bengaluru, Hyderabad, Noida +2

View questions
Product

LinkedIn

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Bengaluru, Gurugram, Mumbai

View questions
Fintech

Intuit

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Bengaluru

View questions
Banking & finance

Goldman Sachs

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Bengaluru, Hyderabad, Mumbai

View questions
Fintech

DE Shaw

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Hyderabad, Bengaluru, Gurugram

View questions
E-commerce & consumer tech

Swiggy

Data Structures and Algorithms interview questions

  • 30 questions
  • 4 rounds

Bengaluru, Hyderabad

View questions
Fintech

PhonePe

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Bengaluru, Pune

View questions
Fintech

Razorpay

Data Structures and Algorithms interview questions

  • 30 questions
  • 5 rounds

Bengaluru, Mumbai

View questions
IT services

TCS

Data Structures and Algorithms interview questions

  • 30 questions
  • 4 rounds

Mumbai, Chennai, Pune +2

View questions

Frequently asked questions

Which companies hire Data Structures and Algorithms professionals in Bangalore?

Companies with large offices in Bangalore include Amazon, Google, Microsoft, Meta, Adobe, Apple, Flipkart, Walmart, Uber, Atlassian. Use their company pages below to practise employer-specific sets.

Are Data Structures and Algorithms interviews in Bangalore different from other cities?

The questions depend more on the company than the city. Bangalore's mix of employers decides the style: Product-company interviews here are usually deeper, with more scenario, design and hands-on rounds

How do I find Data Structures and Algorithms jobs in Bangalore?

Shortlist companies with Bangalore offices, keep your CV focused on Data Structures and Algorithms projects, apply on company career pages and job portals with the Bangalore filter, and practise the questions on this page before each interview.

Other cities

DelhiNoidaGurgaonHyderabadPuneChennaiMumbaiKolkataAhmedabadJaipurLucknowChandigarhIndoreKochiCoimbatoreBhubaneswarNagpurVisakhapatnamThiruvananthapuram

More ways to practise

Company-wise Data Structures and Algorithms questionsExperience-wise Data Structures and Algorithms questionsRole-wise Data Structures and Algorithms questionsCity-wise Data Structures and Algorithms questionsMost asked Data Structures and Algorithms questionsScenario-based questionsPractical / hands-on questionsHR & behavioural questionsData Structures and Algorithms mock interviewOnline assessment questionsTechnical round questionsManagerial round questionsData Structures and Algorithms topic sheets