Unit 7: Heaps and Heap Sort

Maintain a heap of size k while scanning scores so the final heap contains the k largest values.

Use a priority queue to merge several sorted lists by repeatedly taking the smallest current value.

Use a max-heap for the lower half and a min-heap for the upper half to report the median after each insertion.

Arrange repeated tasks so identical tasks are separated by a cooldown, using counts and waiting times.

Return the k points closest to a center point and compare max-heap and sorting approaches.

Order patients by severity, arrival time, and name, then explain comparator tie behavior.

Repeatedly combine the two smallest lengths and prove why the heap supports the greedy choice efficiently.

Process values one at a time and report the kth largest value after each update.

Transform an array into a heap using percolate-down from the last internal node.

Insert values into a binary heap and show the array after each percolate-up step.

Remove the root, move the last value to the root, and show each swap needed to restore heap order.

Build a max-heap, repeatedly move the max to the end, and restore heap order in the remaining prefix.

Choose one value from each sorted list so the range is as small as possible.

Given meeting intervals, compute the minimum number of rooms needed by tracking earliest ending meetings.

Rearrange characters so no adjacent characters match, or explain why it is impossible.

Create a comparator for assignments ordered by due date, priority, and student name.

Explain which structure is better for frequent insertions with repeated highest-priority removals.

Maintain frontier nodes ordered by best known distance and skip stale entries safely.

Sort data where each item is at most k positions from its correct location.

Simulate sending notifications by always processing the earliest scheduled event first.

Given parent and child index formulas, find the off-by-one error in a heap implementation.

Check whether an array satisfies min-heap order and explain why completeness is implicit in array storage.

Build offer, poll, peek, size, and isEmpty while hiding the internal array representation.

Given two sorted arrays, find the largest k pair sums without generating every pair.

Assign each new task to the currently least-loaded student team and analyze when this greedy plan is reasonable.

Given n inserts and m removals, compute the total asymptotic cost and compare with repeated sorting.

Support changing player scores while avoiding incorrect stale heap entries.

Process simulation events ordered by time and add future events as the simulation runs.

Choose between queue, sorted ArrayList, TreeMap, and heap for several priority-based scenarios.

Create a heap assignment requiring manual traces, implementation, comparator design, and runtime comparison.