Data Base Management System

The Shunting-yard algorithm, which converts infix to postfix, uses a stack to hold operators until they can be placed in the output string.

A deque (double-ended queue) is a linear data structure that allows insertion and deletion at both ends.

Recursive procedures rely on the call stack to store return addresses, local variables, and parameters for each active function call.

Prefix notation places operators before operands. A+(B-C)D becomes A+(-BC)D, then A+(-BCD), and finally +A-BCD.

A stack is a LIFO structure where elements are added and removed from the same end, known as the top.

Stacks follow the Last In First Out (LIFO) principle, where the most recently added item is the first one removed.

A program trace is a record of the execution of a computer program, showing the state of registers and memory at specific points.

Sequence: push(1) [1], push(2) [1,2], pop [1] (val 2), push(1) [1,1], push(2) [1,1,2], pop [1,1] (val 2), pop [1] (val 1), pop [] (val 1), push(2) [2], pop [] (val 2). Popped values: 2, 2, 1, 1, 2.

A stack is defined by its LIFO (Last In First Out) access pattern.

Queues are used to manage resources in a fair, first-come-first-served manner, such as printer jobs or CPU scheduling.

To simulate a stack (LIFO) using a priority queue (which returns the smallest key), we need to assign keys such that the most recently added item has the smallest key. Therefore, keys must be strictly decreasing.

A queue is defined by its FIFO (First In First Out) access pattern.

While stacks are used for expression evaluation and recursion, resource allocation (like CPU scheduling) is typically handled by queues to ensure fairness.

Selection sort has a nested loop structure, resulting in a time complexity of O(n^2) for all cases.

Accessing data on a tape is sequential, meaning you must pass through previous items to reach a specific one, similar to a queue.

Bubble sort uses nested loops to compare adjacent elements, leading to an average time complexity of O(n^2).

Insertion sort has an average time complexity of O(n^2) because, on average, each element must be compared and shifted against half of the already sorted elements.

Merge sort uses a divide and conquer approach, splitting the array into halves recursively and merging them, resulting in a consistent O(n log n) complexity.

Quick sort's average performance is O(n log n) because the partitioning process effectively divides the array into roughly equal halves on average.

Selection sort always performs a nested loop to find the minimum element, resulting in O(n^2) complexity regardless of the initial order of elements.

Bubble sort compares adjacent elements in nested loops, leading to O(n^2) in the worst case when the array is sorted in reverse order.

Merge sort guarantees O(n log n) time complexity in all cases, including the worst case, because the splitting and merging steps are always balanced.

In the worst case, such as a reverse-sorted array, every element must be compared and shifted across all previously sorted elements, leading to O(n^2).

Quick sort's worst-case complexity is O(n^2), which occurs when the pivot selection consistently results in highly unbalanced partitions.