# Which Data Structure Is Implemented in First Come First Served?

//

Scott Campbell

Which Data Structure Is Implemented in First Come First Served?

When it comes to scheduling algorithms in operating systems, the First Come First Served (FCFS) algorithm is one of the simplest and most straightforward options. As the name suggests, this algorithm schedules processes in the order they arrive.

But have you ever wondered what data structure lies behind this seemingly simple algorithm? Let’s dive into it!

## The FCFS Algorithm

In FCFS, the process that arrives first is given the highest priority and begins execution immediately. It continues until completion or until it is preempted by a higher-priority process. The next arriving processes are placed at the end of the queue and wait for their turn.

To implement this algorithm efficiently, a suitable data structure is needed to manage the queue of processes. The data structure chosen for FCFS is usually a linked list.

A linked list is an ordered collection of elements where each element contains a reference to the next element in the list. In FCFS, each element represents a process waiting to be executed.

To illustrate this, let’s consider an example:

```Process A -> Process B -> Process C -> Process D
```

In this linked list representation, Process A arrives first and is added to the list. Then Process B arrives and is added after Process A, creating a link between them. This pattern continues as more processes arrive.

• The insertion of new elements at the end of the list can be done efficiently with a time complexity of O(1).
• It allows for dynamic memory allocation, making it suitable for managing processes that arrive at different times.
• Limitations of Using a Linked List:
• Accessing elements in the middle of the list has a time complexity of O(n), where n is the number of elements. However, since FCFS only requires appending new processes to the end, this limitation doesn’t affect its performance.
• Deleting elements from the middle of the list can be inefficient with a time complexity of O(n). However, FCFS doesn’t require deleting processes once they are added to the queue.

## Conclusion

In summary, the First Come First Served (FCFS) scheduling algorithm uses a linked list as its underlying data structure. This choice allows for efficient insertion and management of processes in the order they arrive.

While a linked list has limitations in terms of accessing and deleting elements from the middle, these limitations do not impact FCFS’s performance as it only requires appending new processes to the end. Understanding how data structures support scheduling algorithms provides insights into their efficiency and helps in designing more complex algorithms.

So, next time you come across FCFS, remember that behind its simplicity lies a well-structured linked list!