# Which Are the Linear Data Structure?

//

Scott Campbell

Which Are the Linear Data Structures?

Data structures are essential elements in computer science that allow us to store and organize data efficiently. One type of data structure is the linear data structure, which stores its elements sequentially. In this article, we will explore some of the commonly used linear data structures and how they can be implemented.

## Arrays

An array is a fixed-size collection of elements of the same type. It provides direct access to its elements using an index. Arrays are widely used due to their simplicity and efficiency in accessing elements.

To declare an array in most programming languages, you need to specify the size and data type:

``````
int[] numbers = new int;
```
```

In this example, we declare an array called numbers with a size of 5, capable of storing integers.

A linked list consists of nodes, where each node contains a value and a reference (or link) to the next node in the list. Unlike arrays, linked lists can dynamically grow or shrink as needed.

Here’s an example implementation of a linked list node:

``````
class Node {
int value;
Node next;
}
```
```

In this implementation, each node holds an integer value and a reference to the next node in the list.

## Stacks

A stack is a Last-In-First-Out (LIFO) linear data structure. It allows adding elements (push) and removing elements (pop) only from one end called the top. The element that was added last is the first one to be removed.

Here’s an example of a stack implementation:

``````
class Stack {
private int[] elements;
private int top;

public Stack(int capacity) {
elements = new int[capacity];
top = -1;
}

public void push(int element) {
elements[++top] = element;
}

public int pop() {
return elements[top--];
}
}
```
```

In this example, the stack is implemented using an array. The push() method adds an element to the top of the stack, while the pop() method removes and returns the top element.

## Queues

A queue is a First-In-First-Out (FIFO) linear data structure. It allows adding elements (enqueue) at one end called the rear and removing elements (dequeue) from the other end called the front. The element that was added first is the first one to be removed.

An example implementation of a queue:

``````
class Queue {
private int[] elements;
private int front;
private int rear;

public Queue(int capacity) {
elements = new int[capacity];
front = rear = -1;
}

public void enqueue(int element) {
if (rear == -1) {
front++;
}
elements[++rear] = element;
}

public int dequeue() {
return elements[front++];
}
}
```
```

In this example, we use an array to implement a queue. The enqueue() method adds an element to the rear of the queue, while the dequeue() method removes and returns the element from the front.

## Conclusion

Linear data structures are fundamental in computer science and have various applications. Understanding their characteristics and implementations can greatly benefit your programming skills.

In this article, we’ve explored arrays, linked lists, stacks, and queues as examples of linear data structures. Remember to choose the appropriate data structure based on your specific needs and requirements.