Introduction to Data Structures and Algorithms With Modern Javascript
Tags: javascript, webdev, beginners, datastructures
Published: 2022-02-21 12:01:40

**What is Data Structure and Algorithms**
A data structure (DS) is a way of organising data so that it can be used effectively.
An algorithm is a series of step-by-step instructions that describe how to do something.

**Why Data Structures and Algorithms are important**
- Learning data structures will help to write clean and consistent code.
- Effective algorithms helps to break a problem down into smaller parts and think carefully about how to solve each part with code.

This article will go through a list of following Data Structures and Algorithms: Arrays, Queue, Stack, Linked list.

**Arrays**
An array is a special variable, which can hold more than one value.
Using an array literal is the easiest way to create a JavaScript Array.
`const array_name = [item1, item2, ...];`
Example:
`const snacks = ["Ice cream", "Nuggets", "Popcorn"];`
Operations available in an array include:
- Accessing Array Elements
- Changing an Array Element
- Looping Array Elements
- Adding Array Elements

**Queue**
A queue is an ordered list of elements where an element is inserted at the end of the queue and is removed from the front of the queue. A queue works based on the first-in, first-out (FIFO) principle, which is different from a stack, which works based on the last-in, first-out (LIFO) principle.
A queue has two main operations:
- Enque. Insert a new element at the end of the queue. 
- Dequeue. Remove an element from the front of the queue.
Enqueue
```
enqueue(element){
         this.items[this.count] = element;
         this.count ++;
     }
```

Dequeue
```
dequeue(){
         if (this.isEmpty()) {
             return undefined;
         }
         let result = this.items[this.lowestCount]; 
         delete this.items[this.lowestCount]; 
         this.lowestCount ++; 
         return result; 

     }
```
**Stack**
Stack is a linear data structure in which addition or removal of element follows a particular order i.e. LIFO(Last in First Out) AND FILO(First in Last Out).
The following is an example of a stack class using array:
```
// Stack class
class Stack {

	// Array is used to implement stack
	constructor()
	{
		this.items = [];
	}

	// Functions to be implemented
	// push(item)
	// pop()
	// peek()
	// isEmpty()
	// printStack()
}
```
The following is a list of operations available in implementing a stack

- Push : Insert an element.
- Pop : Remove an element
- Peek : Get the topmost element.
- Size : Get size of the stack.
- isEmpty : Check if the stack is empty if empty return true else false.
- Clear : Reset the stack.

**Linked List**
A linked list is a linear data structure where  each element is a separate object that contains a pointer or a link to the next object in that list. Each element (commonly called nodes) contains two items: the data stored and a link to the next node. 
The following an example of a Linked List Node: 
```
// User defined class node
class Node {
	// constructor
	constructor(element)
	{
		this.element = element;
		this.next = null
	}
}
```
List Of Operations Available in linked list 
- Push: Insert an element at the end of the linked list.
- Insert: Insert an element at the given index of the linked list.
- Remove: Remove the end element of the linked list.
- RemoveAt: Remove the element at the given index of the linked list.
- GetElementAt: Get the element at the given index of the linked list.
- IndexOf: Return the index of the element in the linked list.

**Conclusion**
Data structures will help to write clean and consistent code and algorithms helps to break a problem down into smaller parts and think carefully about how to solve each part with code. Some of these data structures and algorithms are: Arrays, Queue, Stack, Linked list. I hope this article has introduced them to your understanding and satisfaction.