1/13							15
				2
																							18
		3
										16				4
			6												5
			7
															17
						8
		14
					9
							10
									11
		12

Across

1. A merge sort technique that sorts data by combining subproblems without using extra memory for temporary storage.

2. A typical scenario describing the expected time an algorithm requires to solve a problem across all inputs.

3. A strategy that breaks a problem into subproblems, solves them independently, then combines solutions to solve the original problem.

4. A simple, informal way to outline an algorithm’s steps without using programming language syntax.

5. An algorithm that rearranges elements within the original array using minimal extra memory during problem solving.

6. The scenario where an algorithm requires the maximum time to complete when solving a problem.

7. Mathematical notation describing an algorithm's maximum time complexity growth as input size increases indefinitely.

8. A function that efficiently combines two sorted lists into one sorted list during a divide-and-conquer algorithm.

9. An algorithm that orders elements by repeatedly comparing pairs to determine their relative positions within a list.

10. A function or algorithm that calls itself with a smaller version of the problem until a base case is reached.

11. The amount of memory an algorithm requires to solve a problem as a function of the size of the input.

12. A sorting method that requires additional memory to rearrange elements, unlike algorithms that sort within the original data space.

Down

13. An algorithm that sorts data by rearranging elements within the original structure without using extra memory.

14. A technique that solves a problem by repeatedly applying the same process to smaller instances until reaching a simple case.

15. Algorithm that divides an array into sub-lists, sorts the sub-lists, and then merges them back together in sorted order.

16. The scenario in which an algorithm takes the least amount of time to solve a given problem.

17. A sorting algorithm that preserves the relative order of equal elements in the sorted output.

18. The amount of time an algorithm takes to solve a problem as a function of the size of the input.

🖶