Data Structures Quiz

A data structure that stores elements in a specific order, where the last element added is the first one to be removed.

A function that adds an element to the top of the stack.

A function that removes and returns the element at the top of the stack.

A function that returns the element at the top of the stack without removing it.

A data structure that stores elements in a specific order, where the first element added is the first one to be removed.

A function that adds an element to the rear (end) of the queue.

A function that removes and returns the element at the front of the queue.

A condition where the queue has no elements.

A circular linked list is a data structure where the last node's next pointer points back to the first node, forming a circle.

In a circular linked list, there's a head pointer, but no specific starting node. The head is used to access the list's elements.

Creating a circular linked list is similar to creating a singly linked list. The difference is that the last node's next pointer points to the head node, closing the loop.

Traversing a circular linked list involves using a pointer that moves from node to node until it reaches the head node again. A 'do-while' loop is used for this purpose.

In a circular linked list, traversal is achieved by moving a pointer through each node until it reaches the head node again. This simple process enables other operations like insertion and deletion to be executed similarly to a linear linked list.

A 'do-while' loop is ideal for traversal in a circular linked list. It ensures that the loop runs at least once, and the condition checks if the pointer has returned to the head, indicating the completion of a cycle.

The function 'linkedListTraversal' takes the head pointer of the linked list as input and iterates through the nodes using a 'do-while' loop. It prints the data of each node until the pointer reaches the head node again.

The 'find_data' function searches for a specific data value in the circular linked list. It compares the data of each node with the target value. If a match is found, it returns the position of the node. Otherwise, it returns -1, indicating that the data was not found.

A data structure where elements are added and removed from the front (head) but accessed from the end (tail).

A process of adding a new element at the end (rear) of the queue.

A process of removing the element from the front (head) of the queue.

Returns the element at the front of the queue without removing it.

It checks if a queue is empty by comparing the front and rear pointers.

It checks if a queue only contains one element by comparing the front and rear pointers.

It removes the element at the front (head) of the queue by advancing the front pointer and reconnecting the rear to the new front.

A data structure where elements are prioritized and are removed based on their priority.

This function traverses the linked list starting from the head (the first node) and iterates through each node until it finds a node whose data value matches the given 'item'. If the value is found, the function prints its position and returns. Otherwise, it prints a message indicating the value is not in the list.

The function checks if the current pointer's data value matches the input value. If they match, the function prints the position and returns. Otherwise, the function moves on to the next node by updating the 'current' pointer to 'current->next' and increments the 'pos' counter which tracks the position in the linked list.

This line of code inserts a new node 'link' at the end of the linked list. It updates the 'next' pointer of the last node to point to the newly added node.

It initializes a pointer called 'current' to point to the head of the linked list, and then iterates through the list while the 'next' pointer of the current node is not NULL. This ensures that it iterates through all the nodes in the list.

This loop iterates through the list, comparing the data value of each node to the 'value' being searched. If a match is found, it performs the deletion operation.

It creates two pointers, 'p' and 'q'. 'p' points to the current node, and 'q' points to the next node. This allows the function to compare the data values of the current and next nodes in the linked list.

The deleteByValue function takes the head of the linked list and the value to be deleted as input. It finds the node with the matching value and removes it by adjusting pointers and freeing the memory allocated to the removed node. Finally, it returns the updated head of the linked list.

If the value is found in the linked list, the node containing the value is removed by removing the next pointer of the preceding node, making it point to the node after the one being removed. Then, the memory allocated to the removed node is freed using free(). If the value is not found, the function does nothing but returns the head of the linked list.

In a circular queue, if the queue becomes empty after a dequeue operation (front equals rear), both front and rear pointers are reset to -1. This signifies that the queue is empty.

Circular Queue is a linear data structure that uses a fixed-size array for storing elements. It operates like a regular queue but with a twist: the last element of the array is considered to be adjacent to the first element, forming a circular path.

When the queue is full, the condition (rear + 1) % max == front holds true. This means that the next position after the rear pointer is occupied by the front pointer, indicating no space is available for new elements.

When the queue is empty, both front and rear pointers are set to -1 (front == -1 && rear == -1). This indicates an empty queue, no data is stored.

In the enqueue operation, if the queue is not empty (front != -1 && rear != -1), rear pointer is incremented by one, wrapping around the array using (rear + 1) % max. The new element is then inserted at the updated rear position.

When the queue is empty (front == -1 && rear == -1), during the enqueue operation, both front and rear pointers are set to 0, the first element is inserted at the rear position (index 0).

In the dequeue operation, if the queue contains a single element (front == rear), the element is retrieved from the front position, and the front and rear pointers are reset to -1 to indicate that the queue is empty.

In the dequeue operation, when the queue has multiple elements (front != rear), the element at the front is retrieved and displayed. The front pointer is then incremented by one, wrapping around the array using (front + 1) % max.

A priority queue where the element with the smallest priority is always removed first. Elements can be inserted in any order.

A priority queue where the element with the highest priority is always removed first. Elements can be inserted in any order.

The property in a heap where each node is always greater than its child nodes. The root node has the highest value in the heap.

The property in a heap where each node is always smaller than its child nodes. The root node has the smallest value in the heap.

A binary tree where all levels are fully filled except possibly the last level, which is filled from left to right.

A binary tree where every node has either zero or two children. There are no nodes with only one child.