__________ stacks and queues are implemented as linked lists.

Stacks and queues are both linear data structures that store items in an ordered manner. In a stack, the operations are performed in a LIFO (Last In First Out) manner. This means that the item that was added last will be removed first. In a queue, the operations are performed in a FIFO (First In First Out) manner. This means that the item that was added first will be removed first.

Firstly, we need to create a Node class to represent the elements of a linked list. This class should have two attributes: data, which stores the value of the node, and next, which is a reference to the next node in the list. Here's an example of how to create a Node class in Python: ```python class Node: def __init__(self, data): self.data = data self.next = None ```

To implement a stack using a linked list, we need to perform the following operations: 1. Push: Add an element to the top of the stack. 2. Pop: Remove the top element from the stack. 3. Peek: View the top element without removing it. Here's an example of a basic Stack class implementation in Python: ```python class Stack: def __init__(self): self.head = None def push(self, data): new_node = Node(data) new_node.next = self.head self.head = new_node def pop(self): if self.head is None: return None pop_value = self.head.data self.head = self.head.next return pop_value def peek(self): return self.head.data if self.head is not None else None ```

To implement a queue using a linked list, we need to perform the following operations: 1. Enqueue: Add an element to the end of the queue. 2. Dequeue: Remove the front element from the queue. 3. Front: View the front element without removing it. Here's an example of a basic Queue class implementation in Python: ```python class Queue: def __init__(self): self.head = None self.tail = None def enqueue(self, data): new_node = Node(data) if self.tail is None: self.head = self.tail = new_node return self.tail.next = new_node self.tail = new_node def dequeue(self): if self.head is None: return None dequeued_value = self.head.data self.head = self.head.next if self.head is None: self.tail = None return dequeued_value def front(self): return self.head.data if self.head is not None else None ``` Now we have successfully created basic Stack and Queue classes using linked lists as their underlying data structure. These classes can be used to perform the basic operations of push, pop, enqueue, and dequeue as required.