1. What is a stack?

A stack is a linear data structure that follows the Last In First Out (LIFO) principle, meaning
the last element added is the first one to be removed. It allows operations only at one end,
known as the top of the stack.

2. What is a queue?

A queue is a linear data structure that follows the First In First Out (FIFO) principle, where the
first element added is the first one to be removed. Elements are added at the rear and
removed from the front.

3. What is a linked list?

A linked list is a linear data structure consisting of a sequence of elements, where each
element (node) contains a data part and a reference (link) to the next node in the sequence,
allowing for dynamic memory allocation.

4. What is the difference between stack and queue?

The main difference is in their operation principles: a stack uses LIFO (Last In First Out), while
a queue uses FIFO (First In First Out). This means that in a stack, the last element added is the
first to be removed, whereas in a queue, the first element added is the first to be removed.

5. What is a heap?

A heap is a specialized tree-based data structure that satisfies the heap property; in a max-
heap, for any given node, its value is greater than or equal to the values of its children, while
in a min-heap, it is less than or equal to its children.

6. What is hashing?

Hashing is a technique used to uniquely identify a specific object from a group of similar
objects by using a hash function that converts input data into a fixed -size string of characters,
which typically represents an index in an array.

7. What is an array?

An array is a collection of elements identified by index or key, where all elements are stored in
contiguous memory locations. It allows for easy access and manipulation of data using
indices.

8. What is a tree data structure?

A tree data structure is a hierarchical structure that consists of nodes connected by edges,
where each node has zero or more child nodes and exactly one parent node, except for the
root node which has no parent.

9. What is a binary search tree?

A binary search tree (BST) is a type of tree data structure where each node has at most two
children, and for any given node, all values in its left subtree are less than its value, while all
values in its right subtree are greater.

10. What is a red-black tree?

A red-black tree is a balanced binary search tree with an additional property: each node has
an extra bit for denoting color (red or black), which ensures that no two red nodes can be
adjacent and helps maintain balance during insertions and deletions.

11. What is a splay tree?

A splay tree is a self-adjusting binary search tree that moves frequently accessed elements
closer to the root through rotations after accesses, thereby optimizing access times for
frequently used nodes.

12. What is a priority queue?

A priority queue is an abstract data type similar to a regular queue but with an additional
feature: each element has a priority associated with it, and elements are dequeued based on
their priority rather than their order in the queue.

13. What is a graph?

A graph is a collection of nodes (vertices) connected by edges, which can represent various
relationships between pairs of objects. Graphs can be directed or undirected and may contain
cycles.

14. What is DFS vs BFS?

DFS (Depth-First Search) and BFS (Breadth-First Search) are two algorithms for traversing or
searching through graph structures: DFS explores as far down one branch as possible before
backtracking, while BFS explores all neighbors at the present depth prio r to moving on to
nodes at the next depth level.
15. What is the difference between DFS and BFS?

The main difference lies in their approach: DFS uses a stack (either implicitly through
recursion or explicitly), leading to deep exploration before backtracking, while BFS uses a
queue to explore all neighbors at each level before moving deeper into the g raph.

16. What is First In Last Out?

First In Last Out (FILO) refers to an operational principle where the first element added to a
collection will be the last one removed; this principle characterizes stack data structures.

17. What is Last In First Out?

Last In First Out (LIFO) describes an operational principle where the last element added to a
collection will be the first one removed; this principle characterizes stack data structures.

18. What is the brute force technique?

The brute force technique involves solving problems by systematically enumerating all
possible candidates and checking whether each candidate satisfies the problem's conditions;
it guarantees finding an optimal solution but may not be efficient for large i nput sizes.

19. What is double hashing?

Double hashing is an open addressing collision resolution technique used in hash tables where
two hash functions are utilized: one determines the initial index and the second provides an
offset for probing when collisions occur.

20. Write an algorithm for Heap sort.

Heap sort involves building a max-heap from the input array and then repeatedly extracting
the maximum element from the heap and rebuilding it until all elements are sorted:

```

function heapSort(array):

buildMaxHeap(array)

for i from length(array) - 1 down to 1:

swap(array[0], array[i])

heapify(array, 0, i)

21. Write an algorithm for Bubble sort.

Bubble sort repeatedly steps through the list, compares adjacent elements, and swaps them if
they are in the wrong order. The process is repeated until no swaps are needed, indicating
that the list is sorted.

```

def bubbleSort(array):

n = len(array)

for i in range(n):

swapped = False

for j in range(0, n-i-1):

if array[j] > array[j+1]:

array[j], array[j+1] = array[j+1], array[j]

swapped = True

if not swapped:

break

```

22. Write an algorithm for Quick sort.

Quick sort selects a 'pivot' element from the array and partitions the other elements into two
sub-arrays according to whether they are less than or greater than the pivot. The sub -arrays
are then sorted recursively.

```

def quickSort(array):

if len(array) <= 1:

return array

pivot = array[len(array) // 2]

left = [x for x in array if x < pivot]

middle = [x for x in array if x == pivot]

right = [x for x in array if x > pivot]

return quickSort(left) + middle + quickSort(right)

```

23. What is time complexity?

Time complexity is a computational complexity that describes the amount of time it takes to
run an algorithm as a function of the length of the input. It is often expressed using Big O
notation.

24. What is space complexity?

Space complexity refers to the amount of memory space required by an algorithm as a

function of the input size. It includes both the space needed for the input and any auxiliary
space used during computation.

25. What is backtracking?

Backtracking is an algorithmic technique for solving problems incrementally by trying partial

solutions and abandoning them if they are not valid, effectively exploring all possible
configurations.

26. What are algorithms?

Algorithms are step-by-step procedures or formulas for solving problems or performing tasks,
typically expressed in a finite number of well-defined instructions.

27. What is insertion sort?

Insertion sort is a simple sorting algorithm that builds a sorted array one element at a time
by repeatedly taking an element from the unsorted portion and inserting it into its correct
position in the sorted portion.

28. What is the complexity in a queue?

The time complexity for basic operations (enqueue and dequeue) in a queue is O(1), meaning
these operations can be performed in constant time.

29. What is the time complexity for an array?

The time complexity for accessing an element in an array by index is O(1), while searching for
an element without an index typically has a time complexity of O(n).

30. What is the difference between a linked list and a queue?

A linked list is a data structure consisting of nodes where each node points to the next,
allowing dynamic memory allocation, while a queue is a specific type of data structure that
follows FIFO order for adding and removing elements.
31. What is the difference between an array and a list?

An array has a fixed size and stores elements of the same type in contiguous memory
locations, while a list (in languages like Python) can grow dynamically and can contain
elements of different types.

32. What is the difference between a tree and a graph?

A tree is a hierarchical data structure with nodes connected by edges without cycles, whereas
a graph can have cycles and does not have to be hierarchical; it consists of vertices connected
by edges.

33. What is an index?

An index is a data structure that improves the speed of data retrieval operations on a
database table at the cost of additional space and maintenance overhead.

34. What is indexing in an array?

Indexing in an array refers to accessing elements using their position numbers, allowing direct
access to any element based on its index value.

35. What are some examples of time complexity functions (e.g., O(1), O(log n), O(n), O(n^2))?

Examples include:

- O(1): Constant time (e.g., accessing an element in an array)

- O(log n): Logarithmic time (e.g., binary search)

- O(n): Linear time (e.g., traversing an array)

- O(n^2): Quadratic time (e.g., bubble sort)

36. What is a data structure? Give examples.

A data structure is a way to organize and store data so that it can be accessed and modified
efficiently. Examples include arrays, linked lists, stacks, queues, trees, and graphs.

37. What are some common data structures? Explain five of them.

Common data structures include:

- Array: A collection of elements identified by index or key stored in contiguous memory

locations.
- Linked List: A linear collection of nodes where each node points to the next node, allowing
dynamic size changes.

- Stack: A collection that follows LIFO order, allowing push and pop operations at one end
only.

- Queue: A collection that follows FIFO order, allowing enqueue at one end and dequeue at
another end.

- Tree: A hierarchical structure with nodes connected by edges, where each node can have
multiple children.

38. Explain the difference between a stack and a queue.

A stack operates on LIFO principle (last added item is removed first), while a queue operates
on FIFO principle (first added item is removed first).

39. What is a graph?

A graph is a collection of vertices (nodes) connected by edges, representing relationships or

pathways between pairs of objects.

40. What is a binary search tree? What are its properties?

A binary search tree (BST) is a binary tree where each node has at most two children, with all
values in the left subtree being less than its parent node's value and all values in the right
subtree being greater; it allows efficient searching, insertion, and deletion operations.

41. What is a computational model?

A computational model is a representation of a system using mathematical and algorithmic

methods to simulate and study complex phenomena. It allows experimentation by adjusting
parameters and observing outcomes, commonly used in fields like physics, biolog y, and
engineering.

42. What is an algorithm?

An algorithm is a step-by-step procedure or formula for solving a problem or performing a

task, typically expressed in a finite number of well-defined instructions.

43. Explain Asymptotic notations (Big O, Omega, Theta).

Asymptotic notations describe the behavior of functions as inputs grow large. Big O notation
(O) provides an upper bound on time complexity, Omega notation (Ω) gives a lower bound,
and Theta notation (Θ) indicates tight bounds (both upper and lower).
44. What is a primitive operation? Give some examples.

A primitive operation is a basic computation that takes a constant amount of time to execute,
such as arithmetic operations (addition, subtraction), comparisons (greater than, less than),
and accessing array elements.

45. What are the differences between an algorithm and a program?

An algorithm is a theoretical concept that outlines a solution to a problem, while a program is

the implementation of that algorithm in code that can be executed by a computer.

46. What is recursion? Why is it important?

Recursion is a programming technique where a function calls itself to solve smaller instances
of the same problem. It is important for simplifying complex problems and enabling elegant
solutions for tasks like tree traversal and factorial calculation.

47. What is a base case in recursion, and why is it necessary?

A base case is the condition under which a recursive function stops calling itself. It is
necessary to prevent infinite recursion and ensure that the function eventually returns a
result.

48. What is a stack overflow error and why does it occur?

A stack overflow error occurs when there is too much memory used on the call stack, typically
due to excessive recursion without reaching a base case or deep function calls exceeding the
stack size limit.

49. What is the divide-and-conquer strategy?

The divide-and-conquer strategy involves breaking down a problem into smaller subproblems,
solving each subproblem independently, and combining their solutions to solve the original
problem.

50. What is the greedy method?

The greedy method is an algorithmic approach that makes the locally optimal choice at each
stage with the hope of finding a global optimum. It does not always yield the best solution
but can be efficient for certain problems.

51. What is dynamic programming?

Dynamic programming is an optimization technique used to solve problems by breaking them
down into simpler subproblems and storing their solutions to avoid redundant computations.

52. What is branch and bound?

Branch and bound is an algorithm design paradigm used for solving optimization problems by
systematically exploring branches of possible solutions while keeping track of bounds on the
best solution found so far.

53. What is pattern matching?

Pattern matching refers to checking if a specific sequence of characters or patterns exists

within another sequence or data structure, commonly used in text processing algorithms.

54. What is Huffman encoding?

Huffman encoding is a compression algorithm that assigns variable-length codes to input

characters based on their frequencies, minimizing the total number of bits used for encoding.

55. What is lower bound theory?

Lower bound theory establishes minimum limits on the time complexity required to solve
specific problems, helping to understand the efficiency of algorithms relative to their inherent
difficulty.

56. How do you measure the input size of an algorithm?

The input size of an algorithm can be measured based on various factors such as the number
of elements in an array or list, the length of strings, or the dimensions of matrices involved in
computations.

57. What are the best, worst, and average cases for an algorithm?

Best case refers to the scenario where an algorithm performs optimally with minimal input
size; worst case describes the scenario with maximum input size leading to maximum
resource usage; average case represents expected performance over all possible inpu ts.

58. Explain the frequency count method for analyzing algorithms.

The frequency count method involves counting how many times each basic operation (like
comparisons or assignments) occurs during execution to estimate time complexity based on
input size.
59. How do you determine the time complexity of an algorithm?

Time complexity can be determined by analyzing loops, recursive calls, and operations within
an algorithm to express its growth rate relative to input size using Big O notation.

60. How does binary search work?

Binary search works by repeatedly dividing a sorted array in half and comparing the target
value with the middle element; if they match, the search ends; if not, it continues in either
half based on whether the target value is greater or less than the midd le element.

61. What is the time complexity of binary search?

The time complexity of binary search is O(log n), where n is the number of elements in the
array. This efficiency comes from halving the search space with each comparison.

62. What is the difference between a min-heap and a max-heap?

A min-heap is a binary tree where the parent node is less than or equal to its children,
ensuring the smallest element is at the root. A max-heap, conversely, has a parent node that
is greater than or equal to its children, with the largest element at the root.

63. Explain the merge sort algorithm.

Merge sort is a divide-and-conquer algorithm that divides an array into two halves,
recursively sorts each half, and then merges the sorted halves back together. It has a time
complexity of O(n log n).

64. Explain the quick sort algorithm.

Quick sort selects a 'pivot' element and partitions the array into elements less than and
greater than the pivot. The sub-arrays are then sorted recursively. Its average time
complexity is O(n log n).

65. What is a spanning tree?

A spanning tree of a graph is a subgraph that includes all vertices and is connected without
any cycles, ensuring there are no redundant edges.

66. Explain Prim's algorithm for finding a minimum spanning tree.

Prim's algorithm starts with a single vertex and grows the spanning tree by adding the
smallest edge connecting a vertex in the tree to a vertex outside it until all vertices are
included.
67. Explain Kruskal's algorithm for finding a minimum spanning tree.

Kruskal's algorithm sorts all edges in increasing order of weight and adds them one by one to
the spanning tree, ensuring no cycles are formed, until all vertices are connected.

68. What is the single source shortest path problem?

The single source shortest path problem involves finding the shortest paths from a given
source vertex to all other vertices in a weighted graph.

69. Explain Dijkstra's algorithm for finding the shortest path.

Dijkstra's algorithm finds the shortest path from a source vertex to all other vertices by
maintaining a priority queue of vertices based on their current shortest distance and updating
paths as shorter ones are found.

70. Explain the tabulation and memorization methods of dynamic programming.

Tabulation (bottom-up) involves solving subproblems and storing their results in a table to
avoid redundant calculations, while memorization (top-down) involves storing results of
expensive function calls and reusing them when needed.

71. What is the matrix chain multiplication problem?

The matrix chain multiplication problem seeks to determine the most efficient way to multiply
a given sequence of matrices by minimizing the number of scalar multiplications needed.

72. Explain the all-pair shortest path problem.

The all-pair shortest path problem involves finding shortest paths between every pair of
vertices in a graph, commonly solved using algorithms like Floyd-Warshall or repeated
applications of Dijkstra's algorithm.

73. What is the optimal binary search tree problem?

The optimal binary search tree problem aims to construct a binary search tree that minimizes
search cost based on given access frequencies for each key, resulting in efficient retrieval
times.

74. What is the Bellman-Ford algorithm?

The Bellman-Ford algorithm computes shortest paths from a single source vertex to all
vertices in a graph, allowing for negative weight edges but detecting negative weight cycles.

75. What are tractable and intractable problems?

Tractable problems can be solved efficiently (in polynomial time), while intractable problems
cannot be solved efficiently, typically requiring exponential time or more.

76. Explain the job sequencing with deadlines problem.

The job sequencing with deadlines problem involves scheduling jobs within given deadlines to
maximize profit, where each job takes one unit of time and can only be completed if
scheduled before its deadline.

77. Explain the 0/1 knapsack problem.

The 0/1 knapsack problem involves selecting items with given weights and values to
maximize total value without exceeding a specified weight limit; each item can either be
included or excluded.

78. Explain the travelling salesman problem.

The travelling salesman problem seeks to find the shortest possible route that visits each city
exactly once and returns to the origin city, posing significant computational challenges.

79. Explain the Brute Force pattern matching algorithm.

The brute force pattern matching algorithm checks every possible position in a text for
matches against a pattern by comparing characters sequentially until either a match is found
or all positions have been checked.

80. Explain the Knuth-Morris-Pratt (KMP) algorithm.

The KMP algorithm improves pattern matching efficiency by preprocessing the pattern to
create an auxiliary array (the "longest prefix suffix" array) that allows skipping unnecessary
comparisons during matching.

81. Explain the Boyer-Moore algorithm.

The Boyer-Moore algorithm uses information from mismatches during pattern matching to
skip sections of text, making it more efficient than naive approaches by leveraging bad
character and good suffix heuristics.
82. What are oracle and adversary arguments?

Oracle arguments involve using an "oracle" that can provide answers to specific queries
instantly, often used in theoretical computer science; adversary arguments involve reasoning
about worst-case scenarios based on an opponent's actions during an algorithm's execution.

83. What are literals and clauses in Boolean expressions?

Literals are basic variables or their negations in Boolean expressions, while clauses are
disjunctions (OR operations) of literals; together they form expressions used in logic
programming and satisfiability problems.