DEV Community: Edwin

Inverting A Binary Tree in JavaScript and Python

Edwin — Sat, 13 Mar 2021 08:32:34 +0000

Famously the creator of Homebrew failed a google interview because he failed to invert a binary tree on a whiteboard. Let's go through implementing it. Inverting a binary tree involves switching non-leaf nodes on the left side with the ones on the Right.
The image below shows a brief representation of the process.
.

The steps to follow:-

store the left property to the node
set the left property to the right property of the node 3 set the right property to the stored left property
recursively call InvertBinary on the left property of the node then on the right property of the node.
return the tree.

Code implementation in JavaScript:-

class Node{
    constructor(val){
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

class BST{
    constructor(){
        this.root = null;
    }

    insert(val){
        let newNode = new Node(val);
        if(!this.root){
            this.root = newNode;
        }else{
            let current = this.root;
            while(true){
                if(val < current.val){
                    if(current.left === null){
                        current.left = newNode;
                        return this
                    }else{
                        current = current.left;
                    }
                }else{
                    if(current.right === null){
                        current.right = newNode;
                        return this
                    }else{
                        current = current.right
                    }
                }
            }

        }

    }

       DFSInOrder(){
        let data=[];
        function traverse(node){
            if(node.left) traverse(node.left);
            data.push(node.val);
            if(node.right) traverse(node.right);
        }
        traverse(this.root);
        return data;

    }

    IBT(){
        function Invert(node){
            if(node === null) return ;
            let temp = node.left;
            node.left = node.right;
            node.right = temp;

            Invert(node.left);
            Invert(node.right);
        }
        Invert(this.root)
        return this.DFSInOrder()
    }



}

let tree = new BST();
tree.insert(100);
tree.insert(200);
tree.insert(150);
tree.insert(80);
tree.insert(90);
tree.insert(50);
tree.insert(30);
tree.insert(20);
tree.insert(180);
tree.insert(190);
tree.DFSInOrder();
tree.IBT();

in Python:-

class Node:
    def __init__(self,val):
        self.val = val
        self.left = None
        self.right = None


class BST:
    def __init__(self):
        self.root= None

    def insert(self, val):
         newNode = Node(val)
         if self.root == None:
             self.root= newNode
         else:
             current = self.root
             while True:
                 if val< current.val:
                     if current.left == None:
                         current.left = newNode
                         return self
                     else:
                         current= current.left 
                 else:
                     if(current.right == None):
                         current.right = newNode
                         return self
                     else:
                         current = current.right


    def dfsInorder(self):
        data =[]

        def traverse(node):
            if(node.left): traverse(node.left)
            data.append(node.val)
            if(node.right): traverse(node.right)
        traverse(self.root)         
        return data




    def IBT(self):
        def InvertTree(node):
            if node == None: return 

            temp= node.left
            node.left = node.right
            node.right = temp

            InvertTree(node.left)
            InvertTree(node.right)
        InvertTree(self.root) 

        return self.dfsInorder()

bst = BST()
bst.insert(100)
bst.insert(200)
bst.insert(150)
bst.insert(175)
bst.insert(160)
bst.insert(180)
bst.insert(75)
bst.insert(50)
bst.insert(65)
bst.insert(40)
bst.insert(55)
bst.insert(20)

print(bst.dfsInorder())
print(bst.IBT())

Have a nice weekend.

Depth First Search Binary Tree

Edwin — Thu, 11 Mar 2021 10:15:48 +0000

Depth-first search

This approach involves backtracking for traversal and the deepest node is visited first and then backtracks up to the parent. There are three types of DFS traversal:-

Preorder
Inorder
postorder

PreOrder

In pre-order traversal of a binary tree, we first traverse the root, then the left subtree, and then finally the right subtree. We do this recursively to benefit from the fact that left and right subtrees are also trees.

The steps to follow.

Create a function traverse and call it on the root
call traverse on the left sub-tree.
call traverse on the right sub-tree.

InOrder

In the In-order traversal of a binary tree, we first traverse the left subtree, then traverse the root, and then finally the right subtree. We do this recursively to benefit from the fact that left and right subtrees are also trees.

The steps to follow.

call traverse on the left sub-tree.
Create a function traverse and call it on the root
call traverse on the right sub-tree.

PostOrder

In post-order traversal of a binary tree, we first traverse the left subtree, then the right subtree, and then finally the root. We do this recursively to benefit from the fact that left and right subtrees are also trees.

JavaScript implementation:-

class Node{
    constructor(val){
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

class BST{
    constructor(){
        this.root = null;
    }

    insert(val){
        let newNode = new Node(val);
        if(!this.root){
            this.root = newNode;
        }else{
            let current = this.root;
            while(true){
                if(val < current.val){
                    if(current.left === null){
                        current.left = newNode;
                        return this
                    }else{
                        current = current.left;
                    }
                }else{
                    if(current.right === null){
                        current.right = newNode;
                        return this
                    }else{
                        current = current.right
                    }
                }
            }

        }

    }
    find(val){
        let current  = this.root;
        let found = false;
        while(current && !found){
            if(val < current.val){
                if(current.val === val){
                    found = true;
                    return current;
                }else{
                    current = current.left;
                }
            }else{
                if(current.val === val){
                    found = true;
                    return current;
                }else{
                    current = current.right;
                }
            }
        }
        return 'not found'
    }


    DFSPreOrder(){
        let data=[];
        function traverse(node){
            data.push(node.val);
            if(node.left) traverse(node.left);
            if(node.right) traverse(node.right);
        }
        traverse(this.root);
        return data;

    } 

        DFSPostOrder(){
        let data=[];
        function traverse(node){
            if(node.left) traverse(node.left);
            if(node.right) traverse(node.right);
            data.push(node.val);
        }
        traverse(this.root);
        return data;

    }

       DFSInOrder(){
        let data=[];
        function traverse(node){
            if(node.left) traverse(node.left);
            data.push(node.val);
            if(node.right) traverse(node.right);
        }
        traverse(this.root);
        return data;

    }
}

Python implementation:-

class Node:
    def __init__(self,val):
        self.val = val
        self.left = None
        self.right = None


class BST:
    def __init__(self):
        self.root= None

    def insert(self, val):
         newNode = Node(val)
         if self.root == None:
             self.root= newNode
         else:
             current = self.root
             while True:
                 if val< current.val:
                     if current.left == None:
                         current.left = newNode
                         return self
                     else:
                         current= current.left 
                 else:
                     if(current.right == None):
                         current.right = newNode
                         return self
                     else:
                         current = current.right

    def  find(self, val):          
                current= self.root
                found = False
                while current and not found:
                    if val < current.val:
                        current = current.left
                    elif val > current.val:
                        current= current.right
                    else:
                        found = True
                if(not found): return "not found"
                return current

    def dfspreorder(self):
        data =[]

        def traverse(node):
            data.append(node.val)
            if(node.left): traverse(node.left)
            if(node.right): traverse(node.right)
        traverse(self.root)         
        return data


    def dfsInorder(self):
        data =[]

        def traverse(node):
            if(node.left): traverse(node.left)
            data.append(node.val)
            if(node.right): traverse(node.right)
        traverse(self.root)         
        return data


    def dfspostorder(self):
        data =[]

        def traverse(node):
            if(node.left): traverse(node.left)
            if(node.right): traverse(node.right)
            data.append(node.val)
        traverse(self.root)         
        return data


bst = BST()
bst.insert(100)
bst.insert(200)
bst.insert(150)
bst.insert(175)
bst.insert(160)
bst.insert(180)
bst.insert(75)
bst.insert(50)
bst.insert(65)
bst.insert(40)
bst.insert(55)
bst.insert(20)

print(bst.bfs())
print(bst.dfspreorder())

Binary Tree Part 3 'Breadth-First Search' JavaScript and Python

Edwin — Wed, 10 Mar 2021 02:01:32 +0000

Breadth-First Search

This is an algorithm for traversing a tree where the traversing starts from a selected node normally the root and the traversing happens layerwise from left to right.

In the diagram above if we traversed the tree and stored the results in an array the result array would be [0,1,2,3,4,5,7]

Steps to implement

Create a node variable set it to the root property
Create data and queue variables set them to an empty array or List.
Add the node variable at the end of the queue.
Iterate while the queue is no empty, on each Iteration set the node the first node remove from the queue array. Add the node value property to the data array then check if a left property exists on the node if it does add it to the queue check if the right property exists and add it to the node.

The JavaScript code implementation is as below BFS:

class Node{
    constructor(val){
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

class BST{
    constructor(){
        this.root = null;
    }

    insert(val){
        let newNode = new Node(val);
        if(!this.root){
            this.root = newNode;
        }else{
            let current = this.root;
            while(true){
                if(val < current.val){
                    if(current.left === null){
                        current.left = newNode;
                        return this
                    }else{
                        current = current.left;
                    }
                }else{
                    if(current.right === null){
                        current.right = newNode;
                        return this
                    }else{
                        current = current.right
                    }
                }
            }

        }

    }
    find(val){
        let current  = this.root;
        let found = false;
        while(current && !found){
            if(val < current.val){
                if(current.val === val){
                    found = true;
                    return current;
                }else{
                    current = current.left;
                }
            }else{
                if(current.val === val){
                    found = true;
                    return current;
                }else{
                    current = current.right;
                }
            }
        }
        return 'not found'
    }

    BFS(){
        let data=[];
        let queue=[];
        let node= this.root;
        queue.push(node);
        while(queue.length){
            node = queue.shift();
            data.push(node.val);
            if(node.left)queue.push(node.left);
            if(node.right)queue.push(node.right);
        }
        return data
    }
}

let tree = new BST();
tree.insert(100);
tree.insert(200);
tree.insert(150);
tree.insert(80);
tree.insert(90);
tree.insert(50);
tree.insert(30);
tree.insert(20);
tree.insert(180);
tree.insert(190);
console.log(tree,BFS())

In python :-

class Node:
    def __init__(self,val):
        self.val = val
        self.left = None
        self.right = None


class BST:
    def __init__(self):
        self.root= None

    def insert(self, val):
         newNode = Node(val)
         if self.root == None:
             self.root= newNode
         else:
             current = self.root
             while True:
                 if val< current.val:
                     if current.left == None:
                         current.left = newNode
                         return self
                     else:
                         current= current.left 
                 else:
                     if(current.right == None):
                         current.right = newNode
                         return self
                     else:
                         current = current.right

    def  find(self, val):          
                current= self.root
                found = False
                while current and not found:
                    if val < current.val:
                        current = current.left
                    elif val > current.val:
                        current= current.right
                    else:
                        found = True
                if(not found): return "not found"
                return current
    def bfs(self):
        node = self.root
        data = []
        queue = []
        queue.append(node)
        while len(queue)!= 0:
            node = queue.pop(0)
            data.append(node.val)

            if(node.left): queue.append(node.left)
            if(node.right): queue.append(node.right)

        return data





bst = BST()
bst.insert(100)
bst.insert(200)
bst.insert(150)
bst.insert(175)
bst.insert(160)
bst.insert(180)
bst.insert(75)
bst.insert(50)
bst.insert(65)
bst.insert(40)
bst.insert(55)
bst.insert(20)

print(bst.bfs())

Next we will take a look at depth first search preorder.

Binary Search Tree Series Part 2

Edwin — Tue, 09 Mar 2021 06:39:59 +0000

Find or Search Implementation.

When looking for a node with a particular value on the tree, the arrangement of the nodes where the lesser value than the parent node. This means there is a particular optimization done when storing data in a binary tree. After every iteration when looking for the node the number of possible nodes is halved. This lets us get to the solution much more quickly.

Example.

Given we have 1000,000 elements in our data stored in an array and the array is sorted. Assume the node we are searching for is near the end of the let's say 1000,000nth node, Instead of making 1 million comparisons looking the for the node since we know our array is sorted we would compare our value with the middle value in the array, if the value is greater than the middle value then we would know the value most probably exists in the top half of the array(from element 500,000- 1000,000) I say probably because the value might not exist at all in our data and we have to account for the possibility. By gaining this key insight we can ignore the bottom half of our array and make the next comparisons between our target value and the middle value in the top half of the array which would be the 750,000th element. We do this iteratively until we find or value or reach the end in which we return -1 or not found. This search methodology is faster because it always is eliminating half the search data where there is 100% certainty the value does not exist.from 1000,000, to 500,000 ... 250,000... 125,000,
The time complexity becomes O(log n) instead of O(n^2). See the below as a reference.

This is exactly how the search works in a tree.
Pseudo Code/ Steps to follow:

First create variables current, it to the root node and found set it to false.
Start looping while the current node exists and the found variable is still false.
If the value is less than the value stored in the current node then set current to the left property of the current variable
If the value is greater than the current's value property then set the current to the current variable right property.
Otherwise set found variable to true.
outside the while check if the found is still false then return undefined if it is, otherwise returns the current variable Code implementation in JavaScript:

class Node{
    constructor(val){
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

class BST{
    constructor(){
        this.root = null;
    }
// implementation and explanation in the first part of the //series.
    insert(val){
        let newNode = new Node(val);
        if(!this.root){
            this.root = newNode;
        }else{
            let current = this.root;
            while(true){
                if(val < current.val){
                    if(current.left === null){
                        current.left = newNode;
                        return this
                    }else{
                        current = current.left;
                    }
                }else{
                    if(current.right === null){
                        current.right = newNode;
                        return this
                    }else{
                        current = current.right
                    }
                }
            }

        }

    }
    find(val){
        let current  = this.root;
        let found = false;
        while(current && !found){
            if(val < current.val){
                 current = current.left;
                }
            }else if(val > current.val){
                current = current.right;
                }else{
              found = true
            }
        }
        if(!found) return undefined
        return current
    }


    }

In Python:-

class Node:
    def __init__(self,val):
        self.val = val
        self.left = None
        self.right = None


class BST:
    def __init__(self):
        self.root= None

    def insert(self, val):
         newNode = Node(val)
         if self.root == None:
             self.root= newNode
         else:
             current = self.root
             while True:
                 if val< current.val:
                     if current.left == None:
                         current.left = newNode
                         return self
                     else:
                         current= current.left 
                 else:
                     if(current.right == None):
                         current.right = newNode
                         return self
                     else:
                         current = current.right

    def  find(self, val):          
                current= self.root
                found = False
                while current and not found:
                    if val < current.val:
                        current = current.left
                    elif val > current.val:
                        current= current.right
                    else:
                        found = True
                if(not found): return "not found"
                return current



bst = BST()
bst.insert(100)
bst.insert(200)
bst.insert(150)
bst.insert(175)
bst.insert(160)
bst.insert(180)
bst.insert(75)
bst.insert(50)
bst.insert(65)
bst.insert(40)
bst.insert(55)
bst.insert(20)

print(bst.find(21))

Next in this series, we will take a look at the search Methodologies. Starting with Breadth-First Search.

Binary Search Tree(JavaScript and Python)

Edwin — Mon, 08 Mar 2021 07:48:04 +0000

What is a binary search tree?

A binary search tree is a data structure that quickly allows us to maintain a sorted list of numbers.

It is called a binary tree because each tree node has a maximum of two children.
It is called a search tree because it can be used to search for the presence of a number in O(log(n)) time.

The value of the key of the left sub-tree is less than the value of its parent (root) node's key. The value of the key of the right sub-tree is greater than or equal to the value of its parent (root) node's key.
The logic being lower value as compared to the parent node should always be on the left.

Here is an amazing site to visualize the different operations on Binary Tree and other data structures visualgo

Operation on Binary Search Tree

Insertion
Search

Insertion

When a value is to be inserted, we must first find its proper location.

First we have to check if there exists a root node if not we insert the value at the root.
If we have a root value then we check if the value is less or greater than the parent node.
If the value is less than the parent move to the left and check if the location is empty if not do a greater than or less then check with that value and move either to the right or left. if you find an empty location with the criteria above insert the value. 4 return the tree when done.

Code implementation in JavaScript:

class Node{
    constructor(val){
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

class BST{
    constructor(){
        this.root = null;
    }

    insert(val){
        let newNode = new Node(val);
        if(!this.root){
            this.root = newNode;
        }else{
            let current = this.root;
            while(true){
                if(val < current.val){
                    if(current.left === null){
                        current.left = newNode;
                        return this
                    }else{
                        current = current.left;
                    }
                }else{
                    if(current.right === null){
                        current.right = newNode;
                        return this
                    }else{
                        current = current.right
                    }
                }
            }

        }

    }

In Python:-

class Node:
    def __init__(self,val):
        self.val = val
        self.left = None
        self.right = None


class BST:
    def __init__(self):
        self.root= None

    def insert(self, val):
         newNode = Node(val)
         if self.root == None:
             self.root= newNode
         else:
             current = self.root
             while True:
                 if val< current.val:
                     if current.left == None:
                         current.left = newNode
                         return self
                     else:
                         current= current.left 
                 else:
                     if(current.right == None):
                         current.right = newNode
                         return self
                     else:
                         current = current.right

There is an issue that arises when implementing a BST. That is how do you handle equality. This is an edge case and the person implementing the BST might have to make a decision that best suits them, from either ignoring it outright or returning undefined or null or None. My choice was to insert on the right always if equality is ever encountered.
Next on the series, I will implement the search functionality.

Stack and Queues Implementations in JavaScript and Python

Edwin — Sat, 06 Mar 2021 16:15:09 +0000

What is a stack?

A stack is a linear data structure that follows a particular order in which the operations are performed

An example is the call stack in JavaScript, it is what a program uses to keep track of method calls. It works based on the LIFO principle i.e., last-in-first-out. This means whatever item or function that is called last is executed first. In this article, we will use SLL(singly linked list) to build a call stack. Look up how the call stack handles recursion here.

There two different approaches we can implement the call stack but one is optimized and will take less time. The first approach is adding a node at the end and removing it from the end also. Here we have adhered to the LIFO principle but when removing we have to loop to the 2nd last node before we remove the last node. if we assume our list is big enough this approach is time expensive O(n). A better approach would be to use a doubly-linked list to avoid using the loop or our 2nd approach.

In this 2nd approach, we will be adding at the beginning and removing from the beginning also our time complexity will always be O(1). Hence this is the approach we will use.

What is a Queue?

A queue is an abstract data structure, somewhat similar to Stacks. Unlike stacks, a queue is open at both its ends. One end is always used to insert data (enqueue) and the other is used to remove data (dequeue). Queue follows First-In-First-Out methodology, i.e., the data item stored first will be accessed first.
Think about a line at the bank, how you want the system to work is by serving the person who came first always.

Just as the call stack we can implement a queue taking two approaches. Although both approaches will work, only one approach works optimally. That is by adding a node at the end of the list and removing it at the beginning. Try and think about the other approach you can use, and why I have opted not to use it?.

I have implemented both stack and queue using an SLL but you can also use the DLL or even arrays in javascript so long as you adhere to the LIFO and FIFO principles.
Call stack

Stack in JavaScript:

class Node{
    constructor(val){
        this.val = val;
        this.next = null;
    }
}
class Stack{
    constructor(){
        this.first = null;
        this.last = null;
        this.size = 0;
    }
 push (val){
        let newNode = new Node(val);
        if(!this.first){
            this.first= newNode;
            this.last = newNode;
        }else{
            newNode.next = this.first;
            this.first = newNode;
        }
        this.size++;
        return this;
    }
    pop(){
        if(!this.first)return undefined;
        let temp = this.first;
        this.first = this.first.next;
        this.size--;
        if(this.size ===0){
            this.last = null;
        }
        return temp;
    }

}

let stack  = new Stack();
stack.push(19);
stack.push(20);
stack.push(21);
stack.push(22);
stack.push(23);
stack.push(24);
stack.push(25);

In python:

class Node:
    def __init__(self,val):
        self.val = val
        self.next = None


class Stack:
    def __init__(self):
        self.first = None
        self.last =None
        self.size =0

    def push(self,val): 
        newNode = Node(val)
        if self.first == None:
            self.first= newNode
            self.last = newNode
        else:
            newNode.next = self.first
            self.first = newNode
        self.size+=1
        return self


    def pop(self):
        if self.first == None: return 
        temp = self.first
        self.first = self.first.next
        self.size-=1
        if(self.size == 0):
            self.last = None
        return temp

Queue in JavaScript:

class Node{
    constructor(val){
        this.val = val;
        this.next = null;
    }
}
// FIFO First in First out
class Queue{
    constructor(){
        this.first = null;
        this.last = null;
        this.size = 0
    }
    //  add at the beginning and remove at the beginning
    enqueue(val){
        let newNode = new Node(val);
        if(!this.first){
            this.first= newNode;
            this.last = newNode;
        }else{
            this.last.next = newNode;
            this.last = newNode;
        }
        this.size++
        return this
    }

    dequeue(){
        if(!this.first) return undefined
        let temp = this.first
        this.first = this.first.next
        this.size--
        if(this.size === 0){
            this.last = null
        }
        return temp


    }
}

let queue = new Queue()
queue.enqueue(19)
queue.enqueue(20)
queue.enqueue(21)
queue.enqueue(22)
queue.enqueue(23)
queue.enqueue(24)
queue.enqueue(25)
queue.enqueue(26)

In python:


class Node:
    def __init__(self,val):
        self.val = val
        self.next = None


class Queue:
    def __init__(self):
        self.first = None
        self.last =None
        self.size =0

    def enqueue(self,val):   
        newNode =  Node(val)
        if self.first == None:
            self.first = newNode
            self.last = newNode
            self.size+=1
            return self
        self.last.next= newNode
        self.last = newNode
        self.size+=1
        return self


    def dequeue(self):
        if self.first == None: return 
        temp = self.first
        self.first = self.first.next
        self.size-=1
        if(self.size == 0):
            self.last = None
        return temp

Conclusion
The implementations of Stack and Queue is simple as long as you adhere to its LIFO(Last-In-First-Out) and FIFO(First-In-First-Out) Principles, you can use arrays in JavaScript or Lists in Python, SLL, DLL the main objective however will be keeping the time complexity at O(1) for optimum performance.

Doubly Linked Lists Implementation JavaScript and Python

Edwin — Fri, 05 Mar 2021 14:49:32 +0000

What is Doubly Linked List?

We already know what a linked list is, from the first section definition. A doubly linked list is by definition and function still the same as an SLL(singly linked lists) with the only difference being that a DLL(doubly linked list)has prev property attached to the node hence you can go back either forward or backwards.

For simplicity, I copied the code from the previous section and adjusted it to include the previous property. Also, the steps in each operation will need to be adjusted a little bit. Let's begin:-

Operations we to be Implemented

push //add node a the end
pop // remove node at the end
shift // remove node at the beginning
unshift // add a node at the beginning
get // get node at a specific index or according to criteria
set // change node value attribute
insert //
remove
reverse // reverse the direction of the list

NB: Below I have done a deep dive into each function or method implementation. All the functions or methods are inside the class: Skip to the end to see the full code implementation then comeback and follow-through

Let's begin, ps: I will be doing the implementations in both Javascript and Python.

Push

In the push function, you will always be adding a node at the end of the list. The steps to follow are outlined below.

Step 1 - Create a newNode with given value and newNode → next as NULL.
Step 2 - Check whether list is Empty (head == NULL).
Step 3 - If it is Empty then, set head = newNode.
Step 4 - If it is Not Empty then point the tails next attribute to the newNode
step 5 - set the newNode's prev property to the current tail node
Step 6 - then reset the tail to point to the newNode and increment the size

code implementation in JavaScript:

class Node{
    constructor(val){
        this.val= val
        this.prev = null
        this.next=null

    }
}

class DLL{
    constructor(){
        this.head= null
        this.tail= null
        this.size= 0

    }

    push(val){
        let newNode= new Node(val);
        if(!this.head){
            this.head=newNode
            this.tail= newNode
            this.size++
            return this
        }
        this.tail.next = newNode
        newNode.prev =this.tail
        this.tail = newNode
        this.size++
        return this
    }
}

let list =new DLL()
list.push(20)
list.push(21)
list.push(22)
list.push(23)

In python:


class Node:
    def __init__(self, val):
        self.val = val
        self.prev = None
        self.next = None


class DLL:
    def __init__(self):
        self.head=None
        self.tail= None
        self.size=0

    def traverse_list(self):
        if(self.head is None):
            print("No elements in this list")
            return
        else:
            n = self.head
            while n is not None:
                print(n.val)
                n = n.next


    def push(self,val):
        newNode =  Node(val)

        if(self.head == None):
            self.head = newNode
            self.tail = newNode
            self.size+=1
            return self
        self.tail.next= newNode
        newNode.prev = self.tail
        self.tail = newNode
        self.size+=1
        return self
list = DLL()
list.push(20)
list.push(21)
list.push(22)
list.push(23)
list.traverse_list()

Pop

In the pop function, this involves always removing from the end. The steps to follow are as below

step 1 - Handle the edge case if the list is empty return None or undefined
step 2 - Create a temp and set it to the tail node
step 3 - If the size property is equal to 1 set the head and tail properties to null
step 4 - Set the tail attribute equal to the current tails prev attribute. Also, set the tail's next property to null and the temp variable's prev property to null.
step 5 - return the list

Code implementation in Javascript :

pop(){
        if(!this.head) return undefined;
        let temp = this.tail
        if(this.size ===1){
            this.head = null;
            this.tail = null;
        }else{
        this.tail= this.tail.prev;
        this.tail.next= null;
        temp.prev = null
        }
        this.size--;

        return this
    }

In python:

def pop(self):
        if self.head ==None:return
        temp = self.tail
        if self.size == 1:
            self.head = None
            self.tail = None
        else:       
            self.tail = self.tail.prev
            self.tail.next = None
            temp.prev = None 
        self.size-=1

        return self

Shift

This involves removing the first node in the list.
The steps to follow are below:

step 1: Check if the head exists otherwise return early
step 2: Initiate a variable called temp set it equal to the head property
step 3: If the size property is one the set the head and tail property to null or None
step 4: Otherwise set the head property to be the current heads next property
step 5: Set the current head's prev property to null
step 6: decrement the size by 1
step 6: Return the list

Code implementation in Javascript :

shift(){
       if(!this.head) return undefined
       let temp = this.head
       if(this.size ===1){
           this.head = null
           this.tail =null
       }else
       this.head = this.head.next;
       this.head.prev = null;
       }
       this.size --

       return temp
   }

In python:

def shift(self):
        if self.head == None: return 
        temp = self.head
        if(self.size == 1):
            self.head = None
            self.tail = None
        else:
            self.head = self.head.next
            self.head.prev = None
        self.size-=1

        return temp

Unshift

From the name unshift you can guess it is the opposite of shift and it involves adding a node a the beginning. Follow the steps below:

step 1: Create a variable newNode and instantiate the Node class will the val passed in.
step 2: If there is no head property set the head property and tail property equal to the newNode
step 3: if there is a head property set the newNodes's next property to the head property, set the head's prev property to the newNode and then set the head property to the newNode
step 4: Increment the size by 1 and return the list

Code implementation in Javascript :

 unshift(val){
       let newNode = new Node(val);
       if(!this.head){
           this.head= newNode;
           this.tail = newNode;
       }else{
           newNode.next = this.head;
           this.head.prev = newNode;
           this.head = newNode;
       }
       this.size++;
       return this;


   }

In python:

def unshift(self,val):
        newNode = Node(val)
        if self.head == None:
            self.head = newNode
            self.tail = newNode
        else:
            newNode.next = self.head
            self.head.prev = newNode
            self.head = newNode
        self.size+=1
        return self

Get

Get method is just is a search criterion for a node it can use an index or value of the node but in this case, I will just use the index. This implementation is optimized to reduce the number of traversals by half. If the index is greater than half the size of the list we assume it is towards the end of the list, it makes more sense to start searching from the tail and vice versa if it is less than half the size. Follow the steps outline below:

step 1: If the index is less than 0 or greater than or equal to the size property return early
step 2: if index > (size/2) then we set the count to the size property minus one, set the current variable to tail node and start a while loop as long as count is not equal to index, setting current to the current's prev node and decrementing count by one each time
step 2: if index <= (size/2) then we set the count variable to zero, set the current variable to head property, and start a while loop as long as the count is not equal to index, setting current to the current's next node and incrementing count by one each time
step 4: when the loop breaks return current node

Code implementation in Javascript :


  get(index){
       if(index<0 || index >= this.size)return undefined;
       if(index>Math.floor(this.size/2)){
       let count=this.size -1;
       let current= this.tail;
       while(count !== index){
           current= current.prev;
           count--
       }
        }else{
        let count =0;
        let current = this.head
        while(count !== index){
           current= current.next;
           count++
       }

        }

       return current;


   }

In python:

def get(self,index):
        if index <0 or index >=self.size:return
        if index > math.floor(self.size/2):      
            current= self.tail
            count = self.size -1
            while count != index:       
                current = current.next
                count-=1
        else:
            current= self.head
            count = 0
            while count != index:   
                current = current.next
                count+=1
        return current

set

This method will use the Get method to find the node we want and set its value attribute to something else. Follow the steps outlined below:

step 1 : Create a node variable set it to the function get with index passed in as a parameter
step 2 : If the node variable is set to a Non-null or Non- None value set the val property of the node to the new val then return true otherwise return false

Code implementation in Javascript :


  set(index, val){
        let node = this.get(index);
        if(node){
            node.val = val;
            return true;
        }
        return false;
   }

In python:

def set(self,index,val):
        node = self.get(index)
        if node :
            node.val = val
            return True
        return False

Insert

This method will insert a node at a specific point, it will also use the Get method as a helper method to determine where to insert the node. Follow the steps below:

Step 1: If the index parameter is less than zero or greater than the size property return early
step 2: if the index parameter is equal to zero, then return the unshift method with the val parameter passed in
step 3: if the index is equal to the size property return the push method with the val parameter passed in
step 4: Create a variable newNode and instantiate the Node class will the value passed in.
step 5: Get the node at the index -1 position
step 6: Create a nextNode's variable and set it equal to the current node's next property
step 7: set the current node's next property to the newNode and the newNodes's prev property to the node variable, set the newNode's next property to the nextNode and the nextNodes's prev property to the newNode
step 8: Increment the size property by 1 and return the list

Code implementation in Javascript :


insert(index, val){
       if(index<0 || index > this.size ) return undefined
       if(index === 0){
           this.unshift(val);
       }else if(index === this.size){
           this.push(val);
       }else{
           let newNode = new Node(val);
           let node  = this.get(index-1);
           let nextNode = node.next;
           node.next = newNode, newNode.prev = node;
           newNode.next = nextNode, nextNode.prev = newNode;
       }

      this.size++;
      return this;

   }

In python:

def insert(self,index, val):
        if index<0 or index> self.size: return
        if index == 0: return self.unshift(val)
        if index == self.size: return self.push(val)
        newNode = Node(val)
        prevNode = self.get(index-1)
        nextNode = prevNode.next
        prevNode.next = newNode 
        newNode.prev= prevNode
        newNode.next = nextNode 
        nextNode.prev = newNode
        self.size+=1
        return self

Remove

This method removes an element from the list.The steps to follow are outlined below:

Step 1: If the index parameter is less than zero or greater than or equal to the size property return early
step 2: if the index parameter is equal to zero, the return the shift shift method.
step 3: if the index is equal to the size property minus
1 return the pop method.
step 4: Create a variable prevNode and set it to the results of get method with index-1.
step 5: Get the node at the index -1 position,
step 6: Create a temp variable and set it equal to the prevNode's next property, create another afterNode and set it to be the temp's variable next property, then set the prevNode's next property to be the afterNode, set the afterNode prev's property to be the prevNode, set hte temp's next and temp's prev property to null
step 7: decrement the size property by 1 and return the list

Code implementation in Javascript :


   remove(index){
       if(index<0 || index >= this.size ) return undefined
       if(index === 0) return this.shift()
       if(index === this.size-1) return this.pop()
        let prevNode = this.get(index-1)
        let temp = prevNode.next
        let afterNode = temp.next
        prevNode.next = afterNode
        afterNode.prev = prevNode
        temp.next = null
        temp.prev = null
        this.size--
        return this

   }

In python:

def remove(self,index):
         if index<0 or index>= self.size: return
         if index == 0:
             return self.shift()
         if index == self.size-1:
            return self.pop()
         prevNode = self.get(index-1)
         temp = prevNode.next
         afterNode = temp.next
         prevNode.next = afterNode
         afterNode.prev = prevNode
         temp.next = None
         temp.prev = None
         self.size-=1
         return self

Final Code solution for JavaScript :

class Node{
    constructor(val){
        this.val= val
        this.prev = null
        this.next=null

    }
}

class DLL{
    constructor(){
        this.head= null
        this.tail= null
        this.size= 0

    }

    push(val){
        let newNode= new Node(val);
        if(!this.head){
            this.head=newNode
            this.tail= newNode
            this.size++
            return this
        }
        this.tail.next = newNode
        newNode.prev =this.tail
        this.tail = newNode
        this.size++
        return this
    }
    pop(){
        if(!this.head) return undefined;
        let temp = this.tail
        if(this.size ===1){
            this.head = null;
            this.tail = null;
        }else{
        this.tail=this.tail.prev;
        this.tail.next = null;
        temp.prev= null;
        }
        this.size--;

        return this;
    }

   //shift
   shift(){
       if(!this.head) return undefined
       let temp = this.head;
       if(this.size ===1){
           this.head = null
           this.tail =null;
       }else{
       this.head = this.head.next;
       this.head.prev = null
       }
       this.size --;

       return temp
   }
   //unshift
   unshift(val){
       let newNode = new Node(val);
       if(!this.head){
           this.head= newNode;
           this.tail = newNode;
       }else{
           newNode.next = this.head;
           this.head.prev = newNode;
           this.head = newNode;
       }
       this.size++;
       return this;


   }
   //get
   get(index){
       if(index<0 || index >= this.size)return undefined;
       let current;
       if(index >Math.floor(this.size/2)){
           let count=this.size-1;
            current= this.tail;
          while(count !== index){
             current= current.prev;
             count--
       }

       }else{
           let count=0;
            current= this.head;
           while(count !== index){
              current= current.next;
              count++
       }
       }
       return current;
   }
   //set
   set(index, val){
        let node = this.get(index);
        if(node){
            node.val = val;
            return true;
        }
        return false;
   }
   //insert
   insert(index, val){
       if(index<0 || index > this.size ) return undefined
       if(index === 0){
           this.unshift(val);
       }else if(index === this.size){
           this.push(val);
       }else{
           let newNode = new Node(val);
           let node  = this.get(index -1);
           let nextNode = node.next;
               node.next = newNode, newNode.prev = node;
               newNode.next = nextNode, nextNode.prev = newNode
       }

      this.size++;
      return this;

   }
   //remove
   remove(index){
       if(index<0 || index >= this.size ) return undefined
       if(index === 0) return this.shift()
       if(index === this.size-1) return this.pop()
        let prevNode = this.get(index-1)
        let temp = prevNode.next
        let afterNode = temp.next
        prevNode.next = afterNode
        afterNode.prev = prevNode
        temp.next = null
        temp.prev = null

        this.size--
        return temp

   }
   //reverse

   //print
   print(){
       let current= this.head
       let arr = []
       while(current){
           arr.push(current.val)
           current = current.next
       }
       return arr
   }
}
let list =new DLL()
list.push(20)
list.push(21)
list.push(22)
list.push(23)

for Python:

import math
class Node:
    def __init__(self, val):
        self.val = val
        self.prev = None
        self.next = None


class DLL:
    def __init__(self):
        self.head=None
        self.tail= None
        self.size=0

    def traverse_list(self):
        if(self.head is None):

            print("No elements in this list")
            return
        else:
            n = self.head
            while n is not None:
                print(n.val)
                n = n.next


    def push(self,val):
        newNode =  Node(val)

        if(self.head == None):
            self.head = newNode
            self.tail = newNode
            self.size+=1
            return self
        self.tail.next= newNode
        newNode.prev = self.tail
        self.tail = newNode
        self.size+=1
        return self

    def pop(self):

        if self.head ==None:return
        temp = self.tail
        if self.size == 1:
            self.head = None
            self.tail = None
        else:       
            self.tail = self.tail.prev
            self.tail.next = None
            temp.prev = None 
        self.size-=1

        return self

    def shift(self):
            if self.head == None: return 
            temp = self.head
            if(self.size == 1):
                self.head = None
                self.tail = None
            else:
                self.head = self.head.next
                self.head.prev = None
            self.size-=1

            return temp

    def unshift(self,val):
        newNode = Node(val)
        if self.head == None:
            self.head = newNode
            self.tail = newNode
        else:
            newNode.next = self.head
            self.head.prev = newNode
            self.head = newNode
        self.size+=1
        return self

    def get(self,index):
        if index <0 or index >=self.size:return
        if index > math.floor(self.size/2):      
            current= self.tail
            count = self.size -1
            while count != index:       
                current = current.next
                count-=1
        else:
            current= self.head
            count = 0
            while count != index:   
                current = current.next
                count+=1
        return current

    def set(self,index,val):
        node = self.get(index)
        if node :
            node.val = val
            return True
        return False

    def insert(self,index, val):
        if index<0 or index> self.size: return
        if index == 0: return self.unshift(val)
        if index == self.size: return self.push(val)
        newNode = Node(val)
        prevNode = self.get(index-1)
        nextNode = prevNode.next
        prevNode.next = newNode 
        newNode.prev= prevNode
        newNode.next = nextNode 
        nextNode.prev = newNode
        self.size+=1
        return self

    def remove(self,index):
         if index<0 or index>= self.size: return
         if index == 0:
             return self.shift()
         if index == self.size-1:
            return self.pop()
         prevNode = self.get(index-1)
         temp = prevNode.next
         afterNode = temp.next
         prevNode.next = afterNode
         afterNode.prev = prevNode
         temp.next = None
         temp.prev = None
         self.size-=1
         return self

list = DLL()
list.push(20)
list.push(21)
list.push(22)
list.push(23)
list.traverse_list()   

print("==============")
list.remove(2)
print("==============")
print("==============")
list.traverse_list()   

print("==============")

As you can observe the final solution bears some similarity to the SLL solution with some small differences.

Advantages Of DLL:

Reversing the doubly linked list is very easy.
It can allocate or reallocate memory easily during its execution.
As with a singly linked list, it is the easiest data structure to implement.
The traversal of this doubly linked list is bidirectional which is not possible in a singly linked list.
Deletion of nodes is easy as compared to a Singly Linked List. A singly linked list deletion requires a pointer to the node and previous node to be deleted but in the doubly linked list, it only required the pointer which is to be deleted.

Disadvantages Of DLL:

It uses extra memory when compared to the array and singly linked list.
Since elements in memory are stored randomly, therefore the elements are accessed sequentially no direct access is allowed.

Conclusion

You can look up this article for more information on doubly linked lists and their uses. Next in this series, We will take a look at implementing stack and Queues using Linked lists.

Singly Linked Lists Implementation in JavaScript and Python

Edwin — Thu, 04 Mar 2021 14:55:22 +0000

What is a Linked List?

A linked list according to codementor is a data structure that can store an indefinite amount of items. These items are connected using pointers in a sequential manner. The elements of a linked list are called the nodes. A node has two fields i.e. data and next. The data field contains the data being stored in that specific node. It cannot just be a single variable. There may be many variables presenting the data section of a node. The next field contains the address of the next node. So this is the place where the link between nodes is established. I will use the abbrev SLL to refer to a linked list.

My definition is simple, it is a data structure that consists of nodes with a value property for storing data and the next property pointing to the next node. In this way, a node only knows about its next node and not about the rest of the nodes in the chain.

Operations we to be Implemented

push //add node a the end
pop // remove node at the end
shift // remove node at the beginning
unshift // add a node at the beginning
get // get node at a specific index or according to criteria
set // change node value attribute
insert //
remove
reverse // reverse the direction of the list

Let's begin, ps: I will be doing the implementations in both Javascript and Python.

Push

In the push function, you will always be adding a node at the end of the list. The steps to follow are outlined below.

Step 1 - Create a newNode with given value and newNode → next as NULL.
Step 2 - Check whether list is Empty (head == NULL).
Step 3 - If it is Empty then, set head = newNode.
Step 4 - If it is Not Empty then point the tails next attribute to the newNode
Step 5 - then reset the tail to point to the newNode and increment the size

code implementation in JavaScript:

class Node{
    constructor(val){
        this.val= val
        this.next=null

    }
}

class SLL{
    constructor(){
        this.head= null
        this.tail= null
        this.size= 0

    }

    push(val){
        let newNode= new Node(val);
        if(!this.head){
            this.head=newNode
            this.tail= newNode
            this.size++
            return this
        }
        this.tail.next = newNode
        this.tail = newNode
        this.size++
        return this
    }
}

let list =new SLL()
list.push(20)
list.push(21)
list.push(22)
list.push(23)

In python:


class Node:
    def __init__(self, val):
        self.val = val
        self.next = None


class SLL:
    def __init__(self):
        self.head=None
        self.tail= None
        self.size=0

    def traverse_list(self):
        if(self.head is None):
            print("No elements in this list")
            return
        else:
            n = self.head
            while n is not None:
                print(n.val)
                n = n.next


    def push(self,val):
        newNode =  Node(val)

        if(self.head == None):
            self.head = newNode
            self.tail = newNode
            self.size+=1
            return self
        self.tail.next= newNode
        self.tail = newNode
        self.size+=1
        return self
list = SLL()
list.push(20)
list.push(21)
list.push(22)
list.push(23)
list.traverse_list()

Pop

In the pop function, this involves always removing from the end. The steps to follow are as below

step 1 - Handle the edge case if the list is empty return None or undefined
step 2 - Create a current and newTail variable, set the current variable to the head node then set the newTail to the current variable
step 3 - traverse the list while current.next exists and setting newTail equal to the current node after each iteration.
The loop will break at the n-1 node if we assume the size of the nodes is n
step 4 - Set the tail attribute equal to the new tail. the tail .next equal to null and decrement the size of the list by 1.
step 5 - check if the size is zero, if so set the head and tail equal to None or null then return the removed node or list

Code implementation in Javascript :

pop(){
        if(!this.head) return undefined;
        let current= this.head;
        let newTail=current;
        while(current.next){
            newTail = current;
            current= current.next;
        }
        this.tail= newTail;
        this.tail.next= null;
        this.size--;
        if(this.size ===0){
            this.head = null;
            this.tail = null;
        }
        return this
    }

In python:

def pop(self):
        if self.head ==None:return
        current = self.head
        new_tail = None
        while current.next is not None:
            new_tail = current
            current = current.next

        self.tail = new_tail
        self.tail.next = None
        self.size-=1
        if self.size == 0:
            self.head = None
            self.tail = None
        return self

Shift

This involves removing the first node in the list.
The steps to follow are below:

step 1: Check if the head exists otherwise return early
step 2: Initiate a variable called temp set it equal to the head property
step 3: set the head property to be the current heads next property
step 4: decrement the size by 1
step 5: Edge case check if the size is down to zero if it is set the tail to null and return the list

Code implementation in Javascript :

shift(){
       if(!this.head) return undefined
       let temp = this.head
       this.head = this.head.next
       this.size --
       if(this.size ===0){
           this.tail =null
       }
       return temp
   }

In python:

def shift(self):
        if self.head == None: return 
        temp = self.head
        self.head = self.head.next
        self.size-=1
        if(self.size == 0):
            self.tail = None
        return temp

Unshift

From the name unshift you can guess it is the opposite of shift and it involves adding a node a the beginning. Follow the steps below:

step 1: Create a variable newNode and instantiate the Node class will the val passed in.
step 2: If there is no head property set the head property and tail property equal to the newNode
step 3: if there is a head property set the newNodes's next property to the head property and then set the head property to the newNode
step 4: Increment the size by 1 and return the list

Code implementation in Javascript :

 unshift(val){
       let newNode = new Node(val);
       if(!this.head){
           this.head= newNode;
           this.tail = newNode;
       }else{
           newNode.next = this.head
           this.head = newNode
       }
       this.size++
       return this


   }

In python:

def unshift(self,val):
        newNode = Node(val)
        if self.head == None:
            self.head = newNode
            self.tail = newNode
        else:
            newNode.next = self.head
            self.head = newNode
        self.size+=1
        return self

Get

Get method is just is a search criterion for a node it can use an index or value of the node but in this case, I will just use the index. Follow the steps outline below:

step 1: If the index is less than 0 or greater than or equal to the size property return early
step 2 Create variable count set to zero , create variable current set it equal to the head property
step 3: count is not equal to index set current=current.next and increment count by 1
step 4: when the loop breaks return current

Code implementation in Javascript :


  get(index){
       if(index<0 || index >= this.size)return undefined;
       let count=0;
       let current= this.head;
       while(count !== index){
           current= current.next;
           count++
       }
       return current;


   }

In python:

def get(self,index):
        if index <0 or index >=self.size:return
        current= self.head
        count = 0
        while count != index:
            current = current.next
            count+=1
        return current

set

This method will use the Get method to find the node we want and set its value attribute to something else. Follow the steps outlined below:

step 1 : Create a node variable set it to the function get with index passed in as a parameter
step 2 : If the node variable is set to a Non-null or Non- None value set the val property of the node to the new val then return true otherwise return false

Code implementation in Javascript :


  set(index, val){
        let node = this.get(index);
        if(node){
            node.val = val;
            return true;
        }
        return false;
   }

In python:

def set(self,index,val):
        node = self.get(index)
        if node :
            node.val = val
            return True
        return False

Insert

This method will insert a node at a specific point, it will also use the Get method as a helper method to determine where to insert the node. Follow the steps below:

Step 1: If the index parameter is less than zero or greater than the size property return early
step 2: if the index parameter is equal to zero, the return the unshift method with the val parameter passed in
step 3: if the index is equal to the size property return the push method with the val parameter passed in
step 4: Create a variable newNode and instantiate the Node class will the val passed in.
step 5: Get the node at the index -1 position
step 6: Create a temp variable and set it equal to the current node's next property
step 7: set the current node's next property to the newNode and newNodes's next property to temp.
step 8: Increment the size property by 1 and return the list

Code implementation in Javascript :


insert(index, val){
       if(index<0 || index > this.size ) return undefined
       if(index === 0){
           this.unshift(val);
       }else if(index === this.size){
           this.push(val);
       }else{
           let newNode = new Node(val);
           let node  = this.get(index-1);
           let temp = node.next;
               node.next = newNode;
               newNode.next = temp;
       }

      this.size++;
      return this;

   }

In python:

def insert(self,index, val):
        if index<0 or index> self.size: return
        if index == 0: return self.unshift(val)
        if index == self.size: return self.push(val)
        newNode = Node(val)
        prevNode = self.get(index-1)
        temp = prevNode.next
        prevNode.next = newNode
        newNode.next = temp
        self.size+=1
        return self

Remove

This method removes an element from the list.The steps to follow are outlined below:

Step 1: If the index parameter is less than zero or greater than or equal to the size property return early
step 2: if the index parameter is equal to zero, the return the shift shift method.
step 3: if the index is equal to the size property minus
1 return the pop method.
step 4: Create a variable prevNode and set it to the results of get method with index-1.
step 5: Get the node at the index -1 position
step 6: Create a temp variable and set it equal to the prevNode's next property
step 7: set the prevNode's next property to the temp's variable next property
step 8: decrement the size property by 1 and return the list

Code implementation in Javascript :


   remove(index){
       if(index<0 || index >= this.size ) return undefined
       if(index === 0) return this.shift()
       if(index === this.size-1) return this.pop()
        let prevNode = this.get(index-1)
        let temp = prevNode.next
        prevNode.next = temp.next
        this.size--
        return this

   }

In python:

def remove(self,index):
         if index<0 or index>= self.size: return
         if index == 0:
             return self.shift()
         if index == self.size-1:
            return self.pop()
         prevNode = self.get(index-1)
         temp = prevNode.next
         prevNode.next = temp.next
         self.size-=1
         return self

Reverse

This method will reverse the direction of the list. The start will be the end and the end the new start. Basically, we will be starting from the end going backwards to the start.The steps to follow are outlined below

step 1 : Create a node variable and set it equal to head property
step 2: Set the head property to the tail property and the tail property to the node variable
step 3: Create a Next and prev variable and set them both to null or None.
step 4: Start a loop for when it is within the size property's range take 1 step from zero.
step 5: In each step set the Next variable to the current node's next property, set the current node's next property to the prev variable, set the prev variable to the current node and finally set the node variable to the Next variable.
step 6: Return the list

NB If you check the final solution there is an extra method called print, the method puts the values in an array in order and returns the array, I included it for testing the reverse method only, otherwise, it is not needed. If you print the list for the first time, it should return the list in the order entered, reverse the list and print again. the array returned should be in reverse to show the operation was successfull.
Code implementation in Javascript :

 reverse(){
       let node = this.head;
       this.head= this.tail;     // 20 -> 21 -> 22 -> 23
       this.tail = node;     // reversed           21 -> 20 -> null
       let Next,
           prev=null;
       for(let i =0;i< this.size;i++){
           Next= node.next
           node.next=prev
           prev = node
           node = Next        
       }
       return this

   }

In python:

def reverse(self):
        node = self.head
        self.head = self.tail
        self.tail = node
        prev = Next =None
        for i in range(self.size):
            Next = node.next
            node.next = prev
            prev = node
            node = Next
            i+=1
        return self

Final Code solution for JavaScript :

class Node{
    constructor(val){
        this.val= val
        this.next=null

    }
}

class SLL{
    constructor(){
        this.head= null
        this.tail= null
        this.size= 0

    }

    push(val){
        let newNode= new Node(val);
        if(!this.head){
            this.head=newNode
            this.tail= newNode
            this.size++
            return this
        }
        this.tail.next = newNode
        this.tail = newNode
        this.size++
        return this
    }
    pop(){
        if(!this.head) return undefined;
        let current= this.head;
        let newTail=current;
        while(current.next){
            newTail = current;
            current= current.next;
        }
        this.tail= newTail;
        this.tail.next= null;
        this.size--;
        if(this.size ===0){
            this.head = null;
            this.tail = null;
        }
        return this;
    }

   //shift
   shift(){
       if(!this.head) return undefined
       let temp = this.head;
       this.head = this.head.next;
       this.size --;
       if(this.size ===0){
           this.tail =null;
       }
       return temp
   }
   //unshift
   unshift(val){
       let newNode = new Node(val);
       if(!this.head){
           this.head= newNode;
           this.tail = newNode;
       }else{
           newNode.next = this.head;
           this.head = newNode;
       }
       this.size++;
       return this;


   }
   //get
   get(index){
       if(index<0 || index >= this.size)return undefined;
       let count=0;
       let current= this.head;
       while(count !== index){
           current= current.next;
           count++
       }
       return current;


   }
   //set
   set(index, val){
        let node = this.get(index);
        if(node){
            node.val = val;
            return true;
        }
        return false;
   }
   //insert
   insert(index, val){
       if(index<0 || index > this.size ) return undefined
       if(index === 0){
           this.unshift(val);
       }else if(index === this.size){
           this.push(val);
       }else{
           let newNode = new Node(val);
           let node  = this.get(index-1);
           let temp = node.next;
               node.next = newNode;
               newNode.next = temp;
       }

      this.size++;
      return this;

   }
   //remove
   remove(index){
       if(index<0 || index >= this.size ) return undefined
       if(index === 0) return this.shift()
       if(index === this.size-1) return this.pop()
        let prevNode = this.get(index-1)
        let temp = prevNode.next
        prevNode.next = temp.next
        this.size--
        return this

   }
   //reverse
   reverse(){
       let node = this.head;
       this.head= this.tail;     // 20 -> 21 -> 22 -> 23
       this.tail = node;     // reversed           21 -> 20 -> null
       let Next,
           prev=null;
       for(let i =0;i< this.size;i++){
           Next= node.next
           node.next=prev
           prev = node
           node = Next        
       }
       return this

   }

   //print
   print(){
       let current= this.head
       let arr = []
       while(current){
           arr.push(current.val)
           current = current.next
       }
       return arr
   }
}

let list =new SLL()
list.push(20)
list.push(21)
list.push(22)
list.push(23)

for Python:

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None


class SLL:
    def __init__(self):
        self.head=None
        self.tail= None
        self.size=0

    def traverse_list(self):
        if(self.head is None):
            print("No elements in this list")
            return
        else:
            n = self.head
            while n is not None:
                print(n.val)
                n = n.next


    def push(self,val):
        newNode =  Node(val)

        if(self.head == None):
            self.head = newNode
            self.tail = newNode
        else:
            self.tail.next= newNode
            self.tail = newNode      
        self.size+=1
        return self

    def pop(self):
        if self.head ==None:return
        current = self.head
        new_tail = None
        while current.next is not None:
            new_tail = current
            current = current.next

        self.tail = new_tail
        self.tail.next = None
        self.size-=1
        if self.size == 0:
            self.head = None
            self.tail = None
        return self


    def shift(self):
        if self.head == None: return 
        temp = self.head
        self.head = self.head.next
        self.size-=1
        if(self.size == 0):
            self.tail = None
        return temp

    def unshift(self,val):
        newNode = Node(val)
        if self.head == None:
            self.head = newNode
            self.tail = newNode
        else:
            newNode.next = self.head
            self.head = newNode
        self.size+=1
        return self



    def get(self,index):
        if index <0 or index >=self.size:return
        current= self.head
        count = 0
        while count != index:
            current = current.next
            count+=1
        return current

    def set(self,index,val):
        node = self.get(index)
        if node :
            node.val = val
            return True
        return False


    def insert(self,index, val):
        if index<0 or index> self.size: return
        if index == 0: return self.unshift(val)
        if index == self.size: return self.push(val)
        newNode = Node(val)
        prevNode = self.get(index-1)
        temp = prevNode.next
        prevNode.next = newNode
        newNode.next = temp
        self.size+=1
        return self


    def remove(self,index):
         if index<0 or index>= self.size: return
         if index == 0:
             return self.shift()
         if index == self.size-1:
            return self.pop()
         prevNode = self.get(index-1)
         temp = prevNode.next
         prevNode.next = temp.next
         self.size-=1
         return self



    def print(self):
        arr=[]
        current= self.head
        while current:
            arr.append(current.val)
            current= current.next
        return arr


    def reverse(self):
        node = self.head
        self.head = self.tail
        self.tail = node
        prev = Next =None
        for i in range(self.size):
            Next = node.next
            node.next = prev
            prev = node
            node = Next
            i+=1
        return self


list = SLL()
list.push(20)
list.push(21)
list.push(22)
list.push(23)
print("|||||||||||||")

list.traverse_list
print("***************")
print(list.print())
print("===============")
list.reverse()
print("===============")
print(list.print())

Advantages Of Linked List:

Dynamic data structure: A linked list is a dynamic arrangement so it can grow and shrink at runtime by allocating and deallocating memory. So there is no need to give the initial size of the linked list.
No memory wastage: In the Linked list, efficient memory utilization can be achieved since the size of the linked list increase or decrease at run time so there is no memory wastage and there is no need to pre-allocate the memory.
Implementation: Linear data structures like stack and queues are often easily implemented using a linked list. Insertion and Deletion Operations: Insertion and deletion operations are quite easier in the linked list. There is no need to shift elements after the insertion or deletion of an element only the address present in the next pointer needs to be updated.

Disadvantages Of Linked List:

Memory usage: More memory is required in the linked list as compared to an array. Because in a linked list, a pointer is also required to store the address of the next element and it requires extra memory for itself.
Traversal: In a Linked list traversal is more time-consuming as compared to an array. Direct access to an element is not possible in a linked list as in an array by index. For example, for accessing a mode at position n, one has to traverse all the nodes before it.
Reverse Traversing: In a singly linked list reverse traversing is not possible, but in the case of a doubly-linked list, it can be possible as it contains a pointer to the previously connected nodes with each node. For performing this extra memory is required for the back pointer hence, there is a wastage of memory.
Random Access: Random access is not possible in a linked list due to its dynamic memory allocation.

Conclusion

The implementation of a linked list is language agnostic, once you understand the logic behind it, you can implement it with any language of your choosing.Just follow the steps outlined above.

SSH - Configurations

Edwin — Thu, 04 Mar 2021 11:21:43 +0000

SSH COMMANDS

Generate the ssh-key run the command in your terminal
then either rename your key or type enter to continue with the generic given name which is id_rsa for private key and id_rsa.pub for public key

ssh-keygen -t rsa

add Identity

ssh-add /home/user/.ssh/id_rsa

Add the Identity to Github

cat /home/user/.ssh/id_rsa.pub

If the ssh key is meant for GitHub, go to settings look for ssh keys and gpg keys, and paste the copied keys after running the cat command here. Then you are done. You can now use the key to access your GitHub.

Server Key

If the key was meant to be a server key then ssh into your server using your root password and run the following commands in root.

mkdir /home/user/.ssh

touch /home/user/authorized_keys

sudo nano /home/user/authorized_keys

Run the following command on your local machine:

cat /home/user/.ssh/id_rsa.pub

This will give you the public which you copy and paste into the authorized_keys file after the sudo nano command opens the file.ctr + x, you will be prompted if you want to save the file type 'Y' for yes then enter to save. Now exit the server by typing exit then ssh into the server as shown below:

ssh user@134.565.56.31

Replace the user with your username and the IP address with your IP and it should automatically ssh you into your server without needing the password.

Disable Root Password Login For the Server

Type the following commands in your bash terminal to open the file

sudo nano /etc/ssh/sshd_config

After which navigate to the section similar to as below and change the yes to no.

#LoginGraceTime 2m
PermitRootLogin yes
#StrictModes yes
#MaxAuthTries 6
#MaxAuthSessions 10

After changing the option to no CTR + x a prompt of whether you want to save the new file will appear type 'Y' then enter to save.

Reload the saved file by typing the command below and

sudo systemctl reload sshd

then you are done no one can ssh using the root password to your server. This is mainly to protect against brute force attacks into your server.

Adding an SSH-KEY into your server

You will mainly do this when you want to be able to access other commands like git cloning or pull from Github or GitLab without being prompted for the password each time.
First, confirm that the user created in your server owns the ssh file.run

ls -la

then look for the ssh file

edwin edwin 807 Sep 7 11:09 .profile
2 root root .ssh

As you can see my file is owned by the root, hence if I try to generate any ssh key I will get a permission denied error. I have to change ownership from root to the user I created. I do this by running the commands below in the terminal.

 sudo chown -R edwin:edwin /home/edwin

If you run ls -la again you will notice the ssh file switched ownership from root to your current user. i.e mine is now edwin edwin .ssh

After this is done you can run in the terminal:

ssh-keygen -t rsa

You will get prompted with a file path in case you want to rename the ssh file type if you don't need this, otherwise, type the same path.i.e /home/user/.ssh/id_rsa_github.
Then type enter and enter a passphrase in, this is just for some extra security or you can skip this step by just pressing enter again until you see the weird figure below.
The key's randomart image is:

+---[RSA 3072]----+
| ..+ |
| ..o. |
| OoE+.o |
| o=B==* |
| =+SBo* |
| o *+oo |
| o + .o |
| . o =. . |
| . +o |
+----[SHA256]-----+

run:

eval `ssh-agent -s`

then:


ssh-add /home/*user*/.ssh/id_rsa_github

This will add the Identity the cat the id_rsa_github.pub or whatever you named your public key by running the command below.

cat /home/*user*/.ssh/id_rsa_github.pub

copy this whatever is inside the file and paste it again to GitHub.
and now you are done.

# Sorting Algorithms

Edwin — Sat, 21 Nov 2020 19:01:09 +0000

If you google sorting Google will tell you that sorting is any process of arranging items systematically either in descending or ascending order.
sorting can be achieved in so many ways but my goal is to show how the various sorting algorithms are executed and help you understand the logic behind them.

First, there are many sorting algorithms out there I will go through the common ones. This will be a two-part series. In the first part, we will talk about Bubble sort, selection sort, and insertion sort. These are relatively slow Algorithms mainly because they make comparisons while sorting.

1. Bubble Sort

This sorting algorithm basically pushes the largest to the end after every iteration. That's why it is called bubble sort, the largest value bubbles up.
The logic involved is below:-

initiate a loop i and iterate through from the end to the beginning
initiate an inner loop j and iterate from the beginning to i-1
this is because when the loop runs the first time the largest value will bubble to the end hence this last value is already in its right position hence no need to move it. After the 2nd iteration, the 2nd largest value will bubble to the 2nd last place, and so on. Hence for the optimal operation, we don't have to keep making comparisons to the end of the array because after ith iteration the arr. length -i values will always be in their correct place. You can test this by logging the arr, j, j+1 after every iteration.
if value arr[j] > arr[j+1] swap the two values
repeat as long asi>0 and j<i-1

function bubbleSort(arr) {
for(let i= arr.length;i>0;i--){
    for (let j =0;j<i-1;j++){
        if(arr[j]>arr[j+1]){
            let temp = arr[j]
                arr[j]=arr[j+1]
                arr[j+1]=temp
             //console.log(arr,j,j+1)
        }
    }

}
return arr
}

The swap portion is simple, we first store arr[j] in temp then we overwrite the arr[j] with arr[j+1] then we simply overwrite arr[j+1] with arr[j] which we stored in temp.
Another method is by using the swap function below which does the same thing.

const swap =(arr,index1,index2)=>{
     [arr[index1],arr[index2]] =[arr[index2],arr[index1]]
}

Hence our Bubble function would now resemble the function below;

function bubbleSort(arr) {

const swap =(arr,index1,index2)=>{
     [arr[index1],arr[index2]] =[arr[index2],arr[index1]]
}
//first loop
for(let i= arr.length;i>0;i--){
//2nd loop
    for (let j =0;j<i-1;j++){
        if(arr[j]>arr[j+1]){
            //swap fn
           swap(arr,j,j+1)
        //console.log(arr,j,j+1)
        }
    }

}
return arr
}

You will note these are two loops or nested for loops hence the time complexity will be O(n^2). We can make a slight optimization though it will not change the Time complexity. That is if uncomment the console.log and run the functions you will note that if you have an array that is nearly sorted i.e [1,3,2,5] here only 2 needs to be moved to its correct position but 6 comparisons will still occur instead of 3.
Here is how you test initiate counter and add 1 to it every time comparison occurs.

function bubbleSort(arr) {
    let counter=0
for(let i= arr.length;i>0;i--){
    sorted =true
    for (let j =0;j<i-1;j++){
        if(arr[j]>arr[j+1]){
            let temp = arr[j]
                arr[j]=arr[j+1]
                arr[j+1]=temp
             //console.log(arr,j,j+1)
        }
        counter+=1

    }

}
console.log(counter)
return arr
}

console.log(bubbleSort([1,3,2,5]))

The counter will be 6 but if you initiate a value sorted and when the first loop is initiated set the sorted variable to true and set it to false after every swap. Then in the outside loop check if sorted is true and break if the condition is satisfied. This is because if a swap does not happen the array is already sorted and the sorted variable will always be true hence it's not necessary to make the extra comparisons. The Final code for bubble sort will be as follows.

function bubbleSort(arr) {
    let counter=0
    let sorted
for(let i= arr.length;i>0;i--){
  sorted =true
  counter=0
    for (let j =0;j<i-1;j++){
        if(arr[j]>arr[j+1]){
            let temp = arr[j]
                arr[j]=arr[j+1]
                arr[j+1]=temp
                sorted = false
             console.log(arr,j,j+1)
        }
        counter+=1
        if(sorted) break
    }

}
console.log(counter)
return arr
}

console.log(bubbleSort([1,3,2,5]))

The counter variable can be commented out after testing that the optimization worked.

2. Selection Sort

Selection sort algorithm on the other hand initiates a variable let's call it lowest then the first for i loop sets the value for lowest from the 1st value,2nd,3rd... until n.
after lowest is set a 2nd loop j inside the 1st loop is initiated also starting from i+1 inside this loop a comparison is made between jth iteration value and the current lowest value.
If the jth value is less than the lowest value, the lowest is set to jth and the loop continues until the end of the inner loop.
At this point, the inner loop ends
if the current lowest is not equal to the initial value set which is i. the swap occurs.

The code is as below:-

function selectionSort(arr){
    //swap function
    const swap = (arr,index1,index2)=>{
        [arr[index1],arr[index2]] = [arr[index2],arr[index1]]
    }
    let lowest ;
    //iterate seeting a value i to lowest variable
    //initiate an inner loop iterating thorugh checking if 
    for(var i=0;i<arr.length;i++){
         lowest =i
        for(var j=i+1;j<arr.length;j++){
            if(arr[j]<arr[lowest]){
                lowest=j


            }
        }

        if(i !== lowest){
            swap(arr,i,lowest)
         // console.log(arr,arr[i],arr[lowest])
        }
    }
return arr
}

selection conclusion

The code above is already optimized because of the check to see if the values i and lowest are still equal after the inner loop finishes running. The time complexity is still O(n^2) but if think about bubble performs slightly better because if no swap occurs it break from the loop since everything will be sorted but selection sort both loops have to run to the end, hence if your values are almost sorted this algorithm's performance will be poor.

3. Insertion sort

a current value variable is initiated in the function
a 1st loop is with i=1 initiated with the currentValue variable set to the ith value iteration.
The inner loop is initiated with j starting from i-1
The loop will run as long as j>=0 and arr[j]>currentValue with j-- This is because with insertion sort a value is set in its correct position from always, hence the name. Then the comparisons happen from the right to left since after every iteration j--j reduces by 1 each time while i goes up .the code is below. Uncomment the console. logs to see what is actually happening for a better understanding.

function insertion (arr){

    //intiatiate a loop
    //set the current value to the 2nd element
    // compare with the current value with the previous 
     element swap if necessary
    // continue with the next element checking against the 
     ////left side if all values are in the correct place

    let currentValue;
    for(let i=1;i<arr.length;i++){
        currentValue =arr[i]
        for(var j=i-1;j>=0 && arr[j]>currentValue;j--){
            arr[j+1] = arr[j]

        }
        arr[j+1] = currentValue
    }

    return arr
}

Insertion sort also has time complexity O(n^2). It generally performs better than selection sort and bubble sort.
The commented console.logs() lines just log the arr after each iteration with the two values that were compared. I would suggest you uncomment them and take a look at the values logged in the console.

conclusion

I would suggest you running these algorithms through the javascript call stack to see how they work exactly. The simplest way to install an extension called snippets to chrome and use the call stack there. Here is an article on how to use the call stack with snippets in Chrome. This website shows a visual of the performance of the different sorting algorithms. In the next post, I will go through quick sort, radix sort, and finally merge sort and why their performance is better than these first three. Hint: they take advantage of different properties of floats, integers, in general, to sort them.

JavaScript Higher Order Functions

Edwin — Mon, 16 Nov 2020 13:34:12 +0000

Coding in Javascript gets easier and easier every day once you learn more about the language. I personally have experienced this in my coding journey. I started with the normal for and while loops. That is until I came across the Javascript higher-order functions. Higher-order functions are functions that take other functions as arguments or return functions as their results. JavaScript's higher-order functions are actually quite easy to understand. They also provide a clean simple syntax to write your code, this will help you achieve more with much less code needed.

In this article, I will take you through some of the commonly used higher-order functions. I will try to show an implementation using for, while loops, and if statements and simplify the same with the higher-order functions.

const  footballers=[
{name:'Brian',position:'midfield',number:22},{name:'james',position:'midfield',number:44},{name:'Bruno',position:'keeper',number:1},{name:'Ramos',position:'defender',number:2},{name:'martinez',position:'forward',number:7},{name:'ozil',position:'midfield',number:10},{name:'emery',position:'striker',number:9},{name:'John',position:'defender',number:5},{name:'evra',position:'defender',number:3},{name:'sane',position:'forward',number:13},{name:'sandro',position:'midfield',number:14},{name:'Emerik',position:'keeper',number:100},{name:'brent',position:'midfield',number:22}
]

I have added some data above to play with. In the first example, let's try to output a list of all names and save them in a new array called names.

1. forEach

let names=[]

for (let i=0;i<footballers.length;i++){
names.push(footballers[i].name)
}
console.log(names)
//name array includes
//[
//     'Brian',    'james',
//     'Bruno',    'Ramos',
//     'martinez', 'ozil',
//     'emery',    'John',
//     'evra',     'sane',
//     'sandro',   'Emerik',
//     'brent'
//   ]

Above results, the same can be done using a forEach loop in one line as below as shown below.

let names=[]

 footballers.forEach(footballer => names.push(footballer.name))
//names array returned will have
//[
//     'Brian',    'james',
//     'Bruno',    'Ramos',
//     'martinez', 'ozil',
//     'emery',    'John',
//     'evra',     'sane',
//     'sandro',   'Emerik',
//     'brent'
//   ]

2. filter

Assume we have an array of ages and we want to filter and remain with ages from 13-20 included only:-

const ages =[20,15,14,12,8,9,3,21,40,51,35,17,19,17,12,18]
const teen =[]
for(let i=0;i<ages.length;i++){
    if(ages[i]> 13 && ages[i] <= 20){
        teen.push(ages[i])
    }

}
console.log(teen)
//teen array after loop
// [
//     20, 15, 14, 17,
//     19, 17, 18
//   ]

when using the filter function however the code is as follows:-

let teen = ages.filter(age =>{
    if(age >=13 && age<= 20 ){
        return true
    }
})
console.log(teen)
//teen constant
// [
//     20, 15, 14, 17,
//     19, 17, 18
//   ]

//another example("return forwards only")
let forwards =footballers.filter(footballer => footballer.position === 'forward')
// forwards
// [
//     { name: 'martinez', position: 'forward', number: 7 },
//     { name: 'sane', position: 'forward', number: 13 }
//   ]


//another example("return nonMidfielders only")

let nonMidfielder =footballers.filter(footballer => footballer.position !== 'midfield')

// [
//     { name: 'Bruno', position: 'keeper', number: 1 },
//     { name: 'Ramos', position: 'defender', number: 2 },
//     { name: 'martinez', position: 'forward', number: 7 },
//     { name: 'emery', position: 'forward', number: 9 },
//     { name: 'John', position: 'defender', number: 5 },
//     { name: 'evra', position: 'defender', number: 3 },
//     { name: 'sane', position: 'forward', number: 13 },
//     { name: 'Emerik', position: 'keeper', number: 100 }
//   ]

In the 2nd implementation with the filter function, there is no need for creating a new array and pushing onto it.

3. Map

Map function gives us a one-to-one relationship, we can use this relationship to mutate or manipulate the data in whichever method we want:-

//using a for loop
let positions =[]
for(let i = 0;i<footballers.length;i++){
    positions.push(footballers[i].position)


}


// positions array 
//[
//     'midfield', 'midfield',
//     'keeper',   'defender',
//     'forward',  'midfield',
//     'forward',  'defender',
//     'defender', 'forward',
//     'midfield', 'keeper',
//     'midfield'
//   ]

//using a map function
let positions = footballers.map(footballer => footballer.position)

// positions array 
//[
//     'midfield', 'midfield',
//     'keeper',   'defender',
//     'forward',  'midfield',
//     'forward',  'defender',
//     'defender', 'forward',
//     'midfield', 'keeper',
//     'midfield'
//   ]


console.log(positions)

Again when using a for a loop a positions array first needs to be created then inside the loop push into the array after every iteration. However, when using a Map function the results of the map function are set to the constant positions. Using map function enables you to get the same results with fewer lines of code and fewer steps i.e no creating a new array and pushing onto it. You can also pass an optional index argument as the 2nd argument to the map function.

let positions = footballers.map((footballer,index) => `${index}: ${footballer.position}`)

 // the following is logged on the console with the index on the left
//  [0: midfield
// 1: midfield
// 2: keeper
// 3: defender
// 4: forward
// 5: midfield
// 6: forward
// 7: defender
// 8: defender
// 9: forward
// 10: midfield
// 11: keeper
// 12: midfield]

4. sort

The sort function simply sorts the data from lowest to largest or largest to smallest. It takes two positional arguments that are moved up and down making comparisons in order to sort an array.


const sortedFootballers =footballers.sort((a,b) =>(a.number >b.number? 1 :-1))


// sorted by number from smallest to highest
//[
//     { name: 'Bruno', position: 'keeper', number: 1 },
//     { name: 'Ramos', position: 'defender', number: 2 },
//     { name: 'evra', position: 'defender', number: 3 },
//     { name: 'John', position: 'defender', number: 5 },
//     { name: 'martinez', position: 'forward', number: 7 },
//     { name: 'emery', position: 'forward', number: 9 },
//     { name: 'ozil', position: 'midfield', number: 10 },
//     { name: 'sane', position: 'forward', number: 13 },
//     { name: 'sandro', position: 'midfield', number: 14 },
//     { name: 'brent', position: 'midfield', number: 22 },
//     { name: 'Brian', position: 'midfield', number: 22 },
//     { name: 'james', position: 'midfield', number: 44 },
//     { name: 'Emerik', position: 'keeper', number: 100 }
//   ]


//other examples


let sortedAges =ages.sort((a,b)=> a-b)

//arranged from smallest to highest
// [
//     3,  8,  9, 12, 12, 14,
//    15, 17, 17, 18, 19, 20,
//    21, 35, 40, 51
//  ]

 sortedAges =ages.sort((a,b)=> b-a)

//arranged from highest to smallest
//  [
//     51, 40, 35, 21, 20, 19,
//     18, 17, 17, 15, 14, 12,
//     12,  9,  8,  3
//   ]


console.log(sortedAges)

5. reduce

The reduce function takes two positional arguments the 1st is an accumulator the other the iterated value and it returns the accumulated value.

// the total of all the ages array
//using a for loop 
let total = 0
for(let i=0;i<ages.length;i++){
    total+=ages[i]
}
console.log(total)
//total
// 311

//using reduce 
// last argument is zero ("the starting value of total")

let agesTotal = ages.reduce((total,age)=> total+age,0)

console.log(agesTotal)
// 311

let names = footballers.reduce((start,footballer) => start + " " + footballer.name ,"")

console.log(names)
// names combined , this is to show reduce can also be used on strings
// Bruno Ramos evra John martinez emery ozil sane sandro brent Brian james Emerik

conclusion
I hope I helped you gain insight into JavaScript Higher Order functions and their usage.