Data Structures Quiz

A data structure that stores a collection of elements of the same data type in contiguous memory locations.

An array where the size is fixed and cannot be changed after creation.

A data structure that follows the Last-In-First-Out (LIFO) principle, where the last element added is the first one removed.

An operation that removes and returns the top element from a stack.

A function that returns the value of the element at the top of the stack.

A function that checks if a stack is empty.

An operation that adds an element to the top of a stack.

The index of the topmost element in a stack.

A data structure where each node has at most two children, referred to as the left and right children.

The number of edges from a node to the root node.

The number of edges from the deepest node to the root node.

A binary tree where each internal node has either zero or two children. No nodes have only one child.

The number of internal nodes in a full binary tree is given by (n-1)/2, where n is the total number of nodes.

The number of leaf nodes in a full binary tree is given by (n+1)/2, where n is the total number of nodes.

A binary tree where all levels are filled with nodes from left to right, except possibly the last level.

A complete binary tree where all the levels are completely filled and the last level is also filled from left to right.

A data structure with a series of nodes, each containing data and a link to the next node. The last node points to None, indicating the end.

Reversing a linked list means changing the order of nodes so the last one becomes the first, the second-to-last becomes the second, and so on.

A data structure used for reversing a linked list by storing the values in reverse order. The algorithm iterates through the linked list, pushing each node's value onto the stack. Then, it pops the elements from the stack and updates the linked list nodes.

The product of all positive integers from 1 to a given non-negative integer, denoted by '!' (e.g., 5! = 54321 = 120).

A method of calculating factorial using a stack. It involves taking user input for the number, initializing a stack and a variable ( 'top' ) to track the stack's top, and then pushing elements onto the stack.

The time complexity of an algorithm is a measure of the amount of time it takes to run as the input size grows. O(N) represents linear time complexity, meaning the time grows proportionally to the input size.

The simplest case in a recursive algorithm where the solution is directly obtainable without further recursion. In the Tower of Hanoi, it's moving the single remaining disk to the destination peg.

The part of a recursive algorithm that breaks down the problem into smaller, similar subproblems that are solved recursively until the base case is reached. In the Tower of Hanoi, it's moving a stack of disks by recursively moving smaller stacks.

Moving a set of n-1 disks from one peg to another using a temporary holding peg. This involves moving disks recursively until the largest disk is free to move. It's a crucial part of the recursive solution to the Tower of Hanoi.

In the Tower of Hanoi problem, it's the peg that holds the target location for all disks. After the recursive steps are complete, all disks are moved to this peg according to the puzzle's rules.

The peg used as a temporary holding area in the Tower of Hanoi puzzle while moving disks from the source peg to the destination peg. It allows for the strategic movement of smaller disks when the largest disk is blocked.

The peg where the disks start in the Tower of Hanoi puzzle. The goal is to move these disks, one at a time, following the specific rules to the destination peg.

The ability to break down a problem into smaller, identical versions of itself, each solved by a recursive call until a base case is reached. It's a powerful technique for solving complex problems.

A technique used to find solutions to problems by breaking them into subproblems and recursively solving them. It's often used in algorithms like the Tower of Hanoi.

A sorting algorithm that repeatedly steps through the list, compares adjacent elements and swaps them if they are in the wrong order, moving the larger elements towards the end of the list. The algorithm continues until the list is sorted.

The number of times the algorithm iterates through the list. For a list of 'n' elements, Bubble Sort needs 'n-1' passes to sort the list completely.

The process of exchanging the positions of two elements in the array.

The largest element is moved to its correct position in each pass, ensuring that the largest elements are gradually placed at the rightmost positions of the list.

The algorithm's efficiency depends on the size of the input data. Time complexity refers to how long the algorithm takes to complete its task. Bubble Sort has a time complexity of O(N2), meaning that its execution time increases proportionally to the square of the number of elements in the list, making it inefficient for larger datasets.

The algorithm only uses the memory space needed to store the original list. It does not require extra memory to perform the sorting operation.

Maintaining the relative order of elements that have the same value in the initial list. This means elements with the same value will be placed in the sorted list in the same order they were in the original list.

An algorithm that divides the input list into a sorted and unsorted part. The algorithm iterates through the unsorted part, taking the current element and comparing it to the sorted elements until it finds its appropriate position and inserts it in the sorted part. The process is repeated until the entire list is sorted.

The process of removing the first node from a circular linked list. If the list is empty, do nothing. If it has one element, delete the node and set the last pointer to null. Otherwise, update the last node's next pointer to skip the head, delete the head, and return the updated last pointer.

A recursive function that counts the number of nodes in a linked list. It checks if the given node is null. If it is, it returns 0. Otherwise, it recursively calls itself with the next node and adds 1 to the result.

A circularly linked list where the last node's next pointer points back to the head node. This creates a continuous loop.

The process of removing a specific node from a circular linked list. If the list is empty, do nothing. If it has one element and it's the target, delete it and set the last pointer to null. If the target is the head, update the last node's next pointer to skip the head and delete the head. For other nodes, traverse the list and update the previous node's next pointer to skip the target node. If the target is the last node, update the last pointer accordingly. If the target isn't found, do nothing.

The process of removing the last node from a circular linked list. If the list is empty, do nothing. If it has one element, delete the node and set the last pointer to null. Otherwise, traverse the list to find the second last node, update its next pointer back to the head, delete the last node, and return the updated last pointer.

The process of searching for a specific node in a circular linked list. You start at a given node and traverse the list until you find the target value or return to the starting node.

This is the node where the traversal of the linked list begins. Often, it's also the node pointed to by the 'head' pointer.

The end of the linked list. It is often marked with a null pointer to indicate that there are no more nodes following it.