Stacks and Queues in Data Structures

An ordered list where insertions and deletions occur at the same end, called the top.

The principle that the last element added to a stack is the first one removed.

Using an array to store stack elements, with variables 'TOP' and 'MAX_STACK_SIZE'

Error that occurs when trying to add an element to a full stack.

Checking if a stack is empty (TOP = -1).

Checking if a stack is full (TOP = MAX_STACK_SIZE -1).

Adding an element to the top of the stack.

Removing an element from the top of the stack.

Adds an element to the top of a stack. If the stack is full, it prints an error and exits.

Removes and returns the element from the top of a stack, treating the stack like a LIFO structure

A condition when a stack's capacity is reached, preventing further elements from being added.

A condition when a stack has no elements.

A stack implementation where the array size adapts as needed, making the capacity adjustable.

Allocates memory for a stack using dynamic allocation, initialising its capacity to 1.

Checks if a stack is empty (no elements present).

Checks if a stack is full (no more space for adding elements).

A function that calls itself within its own definition.

A recursive function that has a base case (no self-reference) and each recursive call gets closer to the base case.

A specific input value for which a recursive function does not call itself.

The product of all positive integers from 1 up to a given positive integer (n).

A recursive function that calculates the factorial of a given positive integer using the formula: n! = n * (n-1)! where 0!=1.

The greatest common divisor of two integers. It's the largest integer that divides both without a remainder.

A recursive function to find the Greatest Common Divisor (GCD) of two numbers using a self-referencing approach.

A method of solving a problem by performing a series of steps sequentially, one by one.

A linear data structure where elements are added at the rear and removed from the front (FIFO - First-In, First-Out).

The principle that the first element added to a queue is the first one removed.

Queues can be implemented using arrays or linked lists.

The functions (addq, deleteq, isEmptyQ, isFullQ) used to interact with a queue (to add, remove, check emptiness and fullness).

A function that prints an error message and exits the program if a queue is full.

Adds an element (item) to the rear of the queue.

Removes and returns the element from the front of the queue.

Operating systems often use queues to process jobs. Jobs are processed in the order of arrival, unless priority is applied.

When items are added and removed from a sequential queue, the queue shifts. This potentially leaves empty space at the front but still results in queueFull if the rear reaches maximum possible size.

Checks if the queue is empty.

Checks if the queue is full.

Moving the entire queue in a sequential queue has a worst case time complexity of O(MAX_QUEUE_SIZE).

A queue implementation avoids queue shifting by wrapping around the array. This keeps efficient memory use.

In a circular queue, the front variable points one position before the front element's location.

In a circular queue, the rear variable is handled normally; it points to the last element.

A data structure that wraps around the array end in a sequential fashion.

A linear data structure that allows elements to be added and removed from both ends (front and rear).

A deque that allows insertions only at one end and deletions at both ends.

A deque that allows deletions only at one end and insertions at both ends.

A data structure which prioritizes elements based on their value, processing higher priority elements first.

A priority queue representation that uses a linearly connected structure where each item stores not just data but also its priority.

A condition where a queue has reached its maximum capacity and cannot accept further elements.

A data structure that stores data in a sequential manner, with the last and the first element considered to be adjacent.

A technique used to adjust the capacity of an array as needed, during runtime.