Algorithm Interview Questions and Answers for 2025

Dijkstra's algorithm is used to find the shortest path between a given node in a graph to any other node in the graph. It is a five-step algorithm to calculate the distance between 2 nodes in a graph and might also be used to depict road networks.

No, we cannot use the binary search algorithm for linked lists. The reason for this is that in the linked List, random access is not allowed. We cannot reach the middle term or element of the linked list in constant or O(1) time. Thus, making the use of binary search algorithms on a linked list impossible.

One of the most frequently posed sorting interview questions, be ready for it.  

A recursive algorithm approaches a difficult problem by breaking it down into smaller subproblems until the problem is small enough to be solved quickly. A recursive algorithm involves a function that calls itself, which is why the recursive name algorithm. 

For an algorithm to be a recursive algorithm, there are three laws, 

1. There must be a base case 
2. It is necessary for recursive to have a function that calls itself. 
3. The state of a recursive algorithm must be changed in order for it to return to the base case. 

If these three rules are fulfilled by an algorithm, then it can be called a recursive algorithm.

Insertion sort is a sorting technique that separates the input list into sorted and unsorted sub-lists. After separating the input list into two, as mentioned, it inserts one element at a time on the proper spot in the sorted sub-list from the unsorted one. After each iteration, one new element is added to the sorted sub-list, and one is removed from the unsorted one. In the end, the required sorted List is the sorted sub-list.

Selection sort is a sorting technique that separates the data into sorted and unsorted sub-lists. Then, the minimum element, or the smallest element from the unsorted List, is selected and placed in the sorted sub-list. The loop works until all the elements from the unsorted sub-list are shifted to the sorted sub-list giving us the final sorted List.

The space complexity of both the insertion sort and selection sort is O(1). This is because both sorting methods do not require any additional or minimal data storage. Only a single list element must be sorted.

The definition I am getting in my mind is, "The tree traversal is the process of visiting all the nodes of a tree". A tree can be traversed in three ways as 

1. Inorder Traversal 
2. Preorder Traversal 
3. Postorder Traversal 

Inorder Traversal algorithm, steps can be given as: 

1. Traverse the left subtree, i.e., call Inorder (Left → subtree) 
2. Visit the root of the Tree. 
3. Traverse the right subtree now that is call Inorder (right → subtree)

Preorder Traversal algorithm steps can be given as follows: 

1. Visit the root first. 
2. Traverse the left subtree, which means call Preorder (left → subtree) 
3. Traverse the right subtree, which means call Preorder (right → subtree)

Postorder Traversal algorithm steps can be given as follows: 

1. Traverse the left subtree, which means call Postorder (left → subtree) 
2. Traverse the right subtree, which means call Postorder (right → subtree) 
3. In the end, visit the root 

A staple in DSA interview questions, be prepared to answer this one.  

Sure, Some of the algorithms using tree traversal which I can recall at this moment are: 

• Pre-order traversal. 
• In order traversal 
• ZigZag traversal 
• Breadth-first search 
• Post order traversal 

This question is a regular feature in Algorithm interview questions, be ready to tackle it.  

The algorithm to insert a node in a binary search tree can be explained in 3 steps. 

• Assign the current node to the root node of the Tree. 
• If the root node's value is greater than the value we are looking at, then: 
  • If the root node has a left child, go to the left. 
  • If there is no left child, add this node here. 
• If the root node's value is less than the value we are looking at, then: 
  • If the root node has a right child, go to the right. 
  • If there is no right child, add this node here. 

This is the Binary search tree, as per my knowledge.

Okay, so the Heap sort is a comparison-based sorting algorithm similar to the selection sort. This algorithm separates its input into two regions: one as sorted and another one as unsorted as the first step. Then, it successively removes the items from the unsorted part by taking the largest element from it and putting it into the sorted region one by one. 

The main advantage of the heap sort algorithm is that it does not waste time scanning the unsorted part back to back multiple times as done in the selection sort. Instead, heap sort keeps the unsorted region in a heap data structure to identify the largest element in each step more rapidly. The steps of the heap sort algorithm can be explained as follows: 

• At first, it starts by converting the List to a max heap. 
• Then, the algorithm swaps the first and last values in the List, which reduces the range of values to be considered in the heap operation by one, and then, it filters the new first value into its heap place. 
• This process is repeated until the range of values is considered one. 

And this is all about the heap sort algorithm. 

A skip list is a method for data structuring where it allows the algorithm to search, insert or delete the elements in a symbol table or dictionary.

In a skip list, elements are represented by nodes. The search function returns the content of the value related to the key. We can insert a new value in a key using the "insert" function and delete one using "delete". This is all I understand about the skip list.

To know if a linked list has a loop, I would use a two-pointer approach. It is because if we maintain two pointers and increase one pointer after processing 2 nodes and another after processing every node, we will encounter a situation where both the pointers will be pointing to the same node. The only reason for this is that the linked List has a loop.

Okay. I think the best solution is to use a min heap for building a min heap of the first k elements. For each element after the kth element, we would compare it with the root of the min heap. If the element is greater, it will be the root. Otherwise, it will be ignored. At the end of the List, we will have the largest element at the root of the min heap as the kth largest element.

Okay, so we have two integers, x and n. I will be writing the program in python. 

def power(x, n) 
pow = 1 
for i in range(n) 
pow = pow * x 
return pow 
#driver code 
if __name__ == ‘__main__’: 
 
x = 7 
n = 2 
#Function call 
print(power(x, n)) 

We can find the missing number in such an array by monitoring the elements of the array. The code for this will be

def missing_no(arr, N) 
#list of zeroes 
temp = [0] * (N+1) 
for i in range(0, N): 
Temp[arr[i] - 1] = 1 
for i in range(0, N+1): 
if(temp[i] == 0): 
and = i+1 
print(ans) 
#driver code 
if __name__ = ‘__main__’: 
arr = [7, 8, 10, 11] 
N = len(arr) 
#function call 
misssing_no(arr, N)

I think a single algorithm cannot be considered best as each algorithm is designed in a way to solve a problem in a certain situation. However, I have found QuickSort to be the fastest, having the best performance for most problem statements or inputs for this case. 

There are certain advantages of Quicksort over other sorting algorithms. 

1. Cache-efficient - QuickSort linearly scans and partitions the input making it possible to take most from every cache load. 
2. Can quick some swaps - QuickSort is sensitive to input that is in the right order. It can skip some swaps. 
3. Quicksort is efficient in worst-case input sets, as it works in random order. 
4. Easy adaption to already and/or mostly sorted inputs. 
5. In QuickSort, speeds take priority over stability. 

There are many applications of graph data structure. Some of which I am able to recall are: 

1. Transport grids where stations are represented as vertices and routes at the edges of the graph. 
2. Utility graphs of power, where vertices are connection points, and edges are the wires/pipes connecting them. 
3. Social network graphs to determine the flow of information and hotspots as edges and vertices. 
4. Neural networks where vertices represent neurons and edge the synapses between them. 

Okay, as per my knowledge, we have 

1. Binary Tree - It is a tree where each parent has at least two offspring. The children are referred to as the left and right youngsters. 
2. The AVL tree - is a self-balancing binary search tree. 
3. Red and Black Tree - It is also another type of auto-balancing Tree. It helps to keep the forest in balance. 
4. The last one is the N-ary Tree, which is a tree with a node and a maximum N number of children. An N-ary tree is one with the children of each node either as 0 or N. 

Sure. 

• Null is a value. But VOID is a data type identifier. 
• Null indicates an empty value for a variable, while void indicates pointers that do not have an initial size. 
• Null means that it never existed, while void means it existed but is not in effect. 

Expect to come across this popular question in Data structure interview questions.  

Dynamic memory stores simple structured data types at runtime. It has the ability to combine the allocated structured blocks separately to form composite structures that expand and contract as needed. This helps to manage the data of data blocks of arbitrary size in arbitrary order. This is how dynamic memory allocation helps in managing data.

Some operations which we can perform on the queue are: 

1. enqueue() - adds an element to the end of the queue 
2. dequeue() - removes an element from the front of the queue 
3. init() - used to initialize the queue 
4. isEmpty - tests whether the queue is empty or not. 

These are the few functions we perform on queues that I can recall right now.

A must-know for anyone heading into an Algorithm interview, this question is frequently asked in Algorithm interview questions.  

Okay. For this, we first require two linked lists. 

For example, if the first List is 2→4→6 and the second is 1→5→7→9→11, the first List should become 2→1→4→5→6→7 and the second List should become empty. 

This is what we are aiming to achieve with the program. All the nodes of the second List should only be inserted when there are positions available. 

Okay, so to do this, we would run a loop while there are available positions in the first loop. Then, we would insert nodes of the second List by changing the pointers. The code for this can be given as 

Code: 

class Node(object): 
    def __init__(self, data:int): 
        self.data = data 
        self.next = None 
class LinkedList(object): 
    def __init__(self): 
        self.head = None   
    def push(self, new_data:int): 
        new_node = Node(new_data) 
        new_node.next = self.head 
      # Moving the head to point the new node        # new node 
        self.head = new_node  
    # Function to print linked List from head 
    def printList(self): 
        temp = self.head 
        while temp != None: 
            print(temp.data) 
            temp = temp.next 
     # Main function that inserts nodes of linked List an into b at 
    # alternate positions. Since head of first List never changes 
    # but head of second List might change, we need single 
    # pointer for first List and double pointer for second List. 
    def merge(self, a, b): 
        a_curr = a.head 
        b_curr = b.head   
        # swap their positions until one is empty 
        while a_curr != None and b_curr != None: 
            # Save next pointers 
            a_next = a_curr.next 
            b_next = b_curr.next 
            # make b_curr as next of a_curr change next pointer 
 # of b_curr 
            b_curr.next = a_next  
            # change next pointer of a_curr 
            a_curr.next = b_curr  
            # update current pointers for next iteration 
            a_curr = a_next 
            b_curr = b_next 
            b.head = b_curr 
# Driver code 
list1 = LinkedList() 
list2 = LinkedList() 
# Creating the Linked lists 
# 1. 
list1.push(6) 
list1.push(4) 
list1.push(2) 
# 2. 
for i in range(1, 5, 7, 9, 11): 
    list2.push(i) 
print("First Linked List:") 
list1.printList() 
print("Second Linked List:") 
list2.printList()  
# Merging the linked lists 
list1.merge(a = list1, b = list2) 
print("Modified first linked list:") 
list1.printList() 
print("Modified second linked list:") 
list2.printList() 

Output : 

First Linked List: 2 4 6; Second Linked List: 1 5 7 9 11; Modified First Linked List:2 1 4 5 6 7; Modified Second Linked List: 9 11

The code to implement the bubble sort algorithm will have 3 steps 

1. Declare the array 
2. Nest a couple of loops to compare the number in the array. 
3. Store the array in ascending order by replacing the elements if found in any other order. 

Code: 

def bubbleSort(arr): 
    n = len(arr) 
    # optimize code, so if the array is already sorted, it 
    # doesn't need to go through the entire process 
    swapped = False 
    # Traverse through all array elements 
    for i in range(n-1): 
        # range(n) also work but outer loop will 
        # repeat one time more than needed. 
        # Last i elements are already in place 
        for j in range(0, n-i-1): 
            # traverse the array from 0 to n-i-1 
            # Swap if the element found is greater 
            # than the next element 
            if arr[j] > arr[j + 1]: 
                swapped = True 
                arr[j], arr[j + 1] = arr[j + 1], arr[j] 
         
        if not swapped: 
            # if we haven't needed to make a single swap, we 
            # can just exit the main loop. 
            return 
 
# Driver code to test above 
arr = [74, 24, 35, 12, 32, 11, 90] 
bubbleSort(arr) 
print("Sorted array is:") 
for i in range(len(arr)): 
    print("% d" % arr[i], end=" ") 

Output: 

Sorted array is: 
 11  12  24  32  35  74  90 

Okay. In insertion sort, we assume that the first element in the array is to be sorted. The second element is stored separately in the key. This sorts the first two elements. We can then take the third element and make a comparison with the ones on its left. This process will go on until a point where we sort the array. 

Code: 

def insertionSort(arr):  
    if (n := len(arr)) <= 1: 
      return 
    for i in range(1, n):   
        key = arr[i] 
        # Move elements of arr[0..i-1], that are 
        # greater than key, to one position ahead 
        # of their current position 
        j = i-1 
        while j >=0 and key < arr[j] : 
                arr[j+1] = arr[j] 
                j -= 1 
        arr[j+1] = key
#sorting the array [12, 11, 13, 5, 6] using insertionSort 
arr = [12, 11, 13, 5, 6] 
insertionSort(arr) 
print(arr) 

Okay. Inheritance is the procedure in which one class inherits the attributes and methods of another class. The class that inherits the properties of another class is called the child class, and the class whose properties are being inherited is called the parent class. Another interesting thing about inheritance is that the child class can have its own properties and methods along with the ones inherited from the parent class. 

Code: 

class Person(object):  
  # Constructor 
  def __init__(self, name, id): 
    self.name = name 
    self.id = id 
  # To check if this person is an employee 
  def Display(self): 
    print(self.name, self.id) 
class Child(Parent): 
      
    # Constructor 
    def __init__(self): 
        self.value = "Inside Child" 
          
    # Child's show method 
    def show(self): 
        print(self.value) 
 
# Driver code 
emp = Person("Satyam", 102) # An Object of Person 
emp.Display() 

It's no surprise that this one pops up often in DSA interview questions.  

Okay, So overloading is when a class has 2 or more methods with the same name. Then they are called overloaded methods. 

Code: 

def product(a, b): 
    p = a * b 
    print(p) 
# Second product method takes three argument and print their 
# product 
def product(a, b, c): 
    p = a * b*c 
    print(p) 
# Uncommenting the below line shows an error product(4, 5) 
# This line will call the second product method 
product(4, 5, 5) 
Overriding is when a superclass method is also implemented in the child class. 

Code: 

class Parent():
    # Constructor 
    def __init__(self): 
        self.value = "Inside Parent"       
    # Parent's show method 
    def show(self): 
        print(self.value)    
# Defining child class 
class Child(Parent):     
    # Constructor 
    def __init__(self): 
        self.value = "Inside Child" 
    # Child's show method 
    def show(self): 
        print(self.value)  
# Driver's code 
obj1 = Parent() 
obj2 = Child() 
obj1.show() 
obj2.show() 

The method I would follow to write the program is that first find the reverse of the input string and then compare the two; if they are the same, then it is a palindrome; otherwise, not. 

Code: 

def isPalindrome(s): 
    return s == s[::-1]
# Driver code 
s = "malayalam" 
ans = isPalindrome(s) 
if ans: 
    print("Yes") 
else: 
    print("No")

For removing all occurrences of a given character from the input string, I would use the built-in string method "replace" to replace the character with another, including symbols and spaces. 

Code: 

# initializing string 
test_str = "CheeseoverCheese" 
# initializing removal character 
rem_char = "e" 
# printing original string 
print(" The original string is: " 
      + str(test_str)) 
# Using translate() 
# Deleting all occurrences of character 
res = test_str.translate(None, rem_char) 
# printing result 
print(" quote The string after character deletion: " 
      + str(res)) 

Output: 

The original string is : CheeseoverCheese 
The string after character deletion : ChsovrChs 

Okay, so to find the middle element of a linked list, I would first traverse the linked List using 2 pointers. Then, move one pointer by one and another by two. When the fast pointer reaches the end, the slow one will reach the middle. 

Code: 

class Node: 
    # Function to initialize the node object 
    def __init__(self, data): 
        self.data = data 
        self.next = None 
class LinkedList: 
    def __init__(self): 
        self.head = None 
    def push(self, new_data): 
        new_node = Node(new_data) 
        new_node.next = self.head 
        self.head = new_node 
    # Function to get the middle of 
    # the linked List 
    def printMiddle(self): 
        slow_ptr = self.head 
        fast_ptr = self.head 
        if self.head is not None: 
            while(fast_ptr is not None and fast_ptr.next is not None): 
                fast_ptr = fast_ptr.next.next 
                slow_ptr = slow_ptr.next 
            print("The middle element is: ", slow_ptr.data) 
# Driver code 
list1 = LinkedList() 
list1.push(5) 
list1.push(4) 
list1.push(2) 
list1.push(3) 
list1.push(1) 
list1.printMiddle() 

Output: 

The middle element is:  2 

A common question in DS interview questions, don't miss this one.  

This problem statement of deleting a node in the linked List can be solved using 

The iterative method is as follows: 

To delete a node from the linked List, we need to follow three steps; 

1. Find the previous node from the node that is to be deleted. 
2. Change the text of the previous node. 
3. Free memory for the node that is to be deleted. 

The code for solving this problem can be: 

Code: 

Class Node: 
    def __init__(self, data): 
        self.data = data 
        self.next = None 
class LinkedList: 
    def __init__(self): 
        self.head = None 
    # Insert new node at the beginning 
    def push(self, new_data): 
        new_node = Node(new_data) 
        new_node.next = self.head 
        self.head = new_node 
    # Given a reference to the head of a list and a key, 
    # delete the first occurrence of key in linked List 
   
    def deleteNode(self, key): 
         
        # head node 
        temp = self.head 
        # If head node is the last node 
        if (temp is not None): 
            if (temp.data == key): 
                self.head = temp.next 
                temp = None 
                return 
        # If there are more nodes after the head node   
        # Search for the key to be deleted, keep track of the 
        # previous node as we need to change 'prev.next' 
        while(temp is not None): 
            if temp.data == key: 
                break 
            prev = temp 
            temp = temp.next 
        # if key was not present in linked List 
        if(temp == None): 
            return 
        # Unlink the node from linked List 
        prev.next = temp.next 
        temp = None 
  
    # print the Linked List 
    def printList(self): 
        temp = self.head 
        while(temp): 
            print (" %d" %(temp.data)), 
            temp = temp.next 
# Driver program 
list = LinkedList() 
list.push(9) 
list.push(1) 
list.push(4) 
list.push(6) 
print ("Created Linked List: ") 
list.printList() 
list.deleteNode(1) 
print (" 
Linked List after Deletion of 1:") 
list.printList() 

Output: 

Created Linked List: 6 4 1 9; 
 Linked List after deleting the node with value as 1: 6 4 9