Collins Etemesi

Posted on

# Introduction to Data Structures and Algorithms With Modern Javascript

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

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.

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.