Algorithms Final Review | Practice Test / Quiz / MCQs

Home > Data Structures And Algorithms > Quizzes > Algorithms Final Review

Algorithms Final Review

Fast practice, instant feedback. Timer auto-submits when time’s up.

Avg score: 11% • Most missed: “Time Complexity of (singly) Linked List”

Study First Challenge a Friend Stats

Algorithms Final Review

Time left 00:00

25 Questions

1. Depth First Search

(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)Very often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)How much memory an algorithm requires1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-place

2. Disadvantages of Greedy Algorithms

1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-place(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)How much memory an algorithm requiresVery often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)

3. Quick Sort

How much memory an algorithm requires(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-placeVery often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)

4. Space Complexity

(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)How much memory an algorithm requires1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-placeVery often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)

5. Heap Sort

(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-placeVery often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)1. Heapify ( establish the properties of heap) 2. Swap first and last element - 3. Reduce heap size and Repeat until entire array is sorted SHOW ARRAY AT EACH STEP 0 Big O - Omega - Theta : n log n - In-place

6. Breadth First Search

Very often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)(Uses Que) - Search each level fully and then continue. Continue inorder of what is pushed to the que! - Big O (V + E)(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-place

7. How is an Algorithm considered correct?

(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)Very often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-placeIf for all valid input - the algorithm terminates after a finite number of step and provides the correct ouput

8. Dynamic Programming

Very often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-placeAn Optimization : problems that consist of the same sub problems. ** Basically store your previous results to be able to avoid solving the same problem(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)

9. Pros and Cons of Adjacency Matrix

Very often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)Pro : faster look up Con : not space efficient for large graphs(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-place

10. Load factor of Hash Table

Very often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-place(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)alpha = ( n / m)

11. Big Î© (Omega)

1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-place(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)Best CaseVery often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)

12. Insertion Sort

Very often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)Big O (n * n)1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-place(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)

13. Rehashing or Double Hashing

(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)Very often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)On collision - run the value through another hashing function. Can result in secondary clustering1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-place

14. Merge Sort

1. Split array in half until single unit 2. Compare and Merge into larger - sorted array 3. Rinse and Repeat - Big O - Omega - Theta : n log n - Not In place - Requires more space than Heap and Quick(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)Very often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-place

15. Time Complexity of (singly) Linked List

(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)Very often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-placeAdd - Remove - Retrieve Head : Big O (1)| Add - Remove Retrieve Tail : Big O (1) [if address is stored] ... Otherwise Big O (n) | Add - retrieve - remove - replace (elements) : Big O(n)

16. Time Complexity of array-based list

(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)Insert - Remove - Find : Big O (n) | Retrieve - replace - swap : Big O (1)1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-placeVery often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)

17. Pros and Cons of Adjacency List

(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)Pro : Space efficient Con : Search time is very slow1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-placeVery often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)

18. Time Complexity of Prism's Algorithm

Very often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)Adj Matrix : Big O (v ^2) - Adj List with Binary Heap : O (v log v + e log v)1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-place

19. Big O

1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-placeVery often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)Worst Case

20. Prism's Algorithm

1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-place(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)- Greedy algorithm to get an MST ( Visit every node and noooo cycles). Pick smallest edge to get to an unvisted node.Very often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)

21. Rate of Growth

Very often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)constant ( c ) - logarithmic ( log n) - linear ( n ) - linear logarithmic ( n log n) - quadratic ( n^2 ) - cubic ( n ^ 3 ) - exponential ( 2 ^ n) - factorial ( n! )(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-place

22. Chaining

Very often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-placeOn collision (every index is head of linked list) - add new value to the end. - (a)list grows longer so does look up time - Big O(1 + alpha)

23. Greedy Algorithms

Always chooses the current best choice. Local maxima in hopes to achieve global maxima - 0-1 Knapsack Problem - Thief with limited bag space1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-placeVery often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)

24. Probing

1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-placeVery often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)On collision offset the value by an offset. Can result in clustering

25. Binary Search ( Sorted Array / Tree)

(Uses Stack) - Search as deep as possible first - then backtrack. Big O (V + E)1. Pick last element as pivot. 2. From the other end of the array - create a partition (just track index). At each index if larger than pivot keep on the right side of the partition. If smaller than pivot keep to the left of partition 3. Once run is finished - swap pivot with first elemnent of the right partition. RINSE AND REPEAT ( Each partition essentially become a sub array that you run quick sort on - Do this until all values are sorted) . SHOW ARRAY AT EACH STEP - Big O (n^2) - Big Theta - Omega (n logn) - In-placeVery often fails to return desired outcome - Every 'Correct' Greedy algorithm has to be proven ( Unless proven - you cannot be certain that the best answer was chosen)Assume array is sorted - If value is bigger move right - if value is smaller move left. Repeat until you find value or size = 0 - Big O ( log n)

⚡ Recently practiced quizzes in this topic

Live quiz activity

Design and Analysis of Algorithms (DAA) Practice Test Questions Basic Pseudocode 1 Data Structures & Algorithms Practice Test: Maximum Flow Problem Algorithms and Pseudocode Data Structures & Algorithms Practice Test: Sorting Data Structures & Algorithms Practice Test: Shortest Path Data Structures & Algorithms Practice Test: Minimum Cut Data Structures & Algorithms Practice Test: Matching Data Structures & Algorithms Practice Test: Backtracking Data Structures & Algorithms Practice Test: Dynamic Programming

25 Questions

❤ If you liked Fatskills, consider supporting us by checking out The Life Manuals You Never Got.

About | Explore | User Guide | Topics | Subjects | Doubt Solver | Career Aptitude Test | Answers | Free Tools | OSHA Basics Quiz | What Should We Know?
Privacy | Terms |

Without work one finishes nothing. - Ralph Waldo Emerson
© 2026 Fatskills.com

All trademarks, logos and brand names are the property of their respective owners. All company, product and service names used in this website are for identification purposes only. Use of these names, trademarks and brands does not imply endorsement.

25 Questions

❤ If you liked Fatskills, consider supporting us by checking out The Life Manuals You Never Got.

About | Explore | User Guide | Topics | Subjects | Doubt Solver | Career Aptitude Test | Answers | Free Tools | OSHA Basics Quiz | What Should We Know? Privacy | Terms |

Without work one finishes nothing. - Ralph Waldo Emerson© 2026 Fatskills.com

All trademarks, logos and brand names are the property of their respective owners. All company, product and service names used in this website are for identification purposes only. Use of these names, trademarks and brands does not imply endorsement.

About | Explore | User Guide | Topics | Subjects | Doubt Solver | Career Aptitude Test | Answers | Free Tools | OSHA Basics Quiz | What Should We Know?
Privacy | Terms |

Without work one finishes nothing. - Ralph Waldo Emerson
© 2026 Fatskills.com