1605947220

In my last article, we built a Singly Linked List with JavaScript with push, pop, shift, and unshift functions. Check it out here if you are not familiar with it yet.

Continuing from that, in this article, we will be looking at how to reverse the list. I have decided to take on this function as a separate article itself, as I have heard that it is a common interview question. Let’s get right into it.

First off, you should have a class set up to create the list, a class to create a node, and a push method to add nodes to the list. It will look something like this.

```
class Node {
constructor(val) {
this.val = val;
this.next = null;
}
}
class SinglyLinkedList {
constructor() {
this.head = null;
this.tail = null;
this.length = 0;
}
push(val) {
let newNode = new Node(val);
if(!this.head) {
this.head = newNode;
this.tail = this.head;
} else {
this.tail.next = newNode;
this.tail = newNode;
}
this.length++;
return this;
}
```

#javascript #web-development #programming #developer

1605854137

When given a singly linked list how can we manage to reverse it? Like the following example, if the input linked list is 1->2->3->4->5->NULL, can we reverse it into the output as 5->4->3->2->1->NULL?

Example Input

Example Output

Each node of Linked list will have two attributes: value & next, and linked list will have head, tail and length attribute.

```
function ListNode(val, next) {
this.val = (val===undefined ? 0 : val)
this.next = (next===undefined ? null : next)
}
```

https://gist.github.com/GAierken/6e15c82f5e3457fa2d16e29400e130aa

There are two approaches to reverse a singly linked list: iterative and recursive.

#javascript #recursion #singly-linked-list #reverse-linked-list #iteration

1604028420

In the previous “Data Structures in JavaScript” discussion, we walked through the methodology used to construct a node class which represent each “link” in the “chain” that is a linked list. From there we discussed how to construct a singly linked list from a an array. Building on the previous discussion, we will now dive into editing that singly linked list. If you are not familiar with the code and terminology covered in the previous article it is recommended you review Building a Singly Linked List.

With a linked list there are three ways to edit the list: update a nodes data property, add a node to the list or delete a node from the list. In all these cases, we will want to access a specific place in the singly linked list. Depending on the situation, you might want to edit the nth node from the head of the list, the nth node from the end of the list, or a node of a particular data value. For this discussion, we will assume that we are interested in editing the nth Node from the head of the list. With this in mind, we can step through a singly linked list from the head to the nth a node using a simple for loop as shown in Figure 1.

#javascript #singly-linked-list #linked-lists #data-structures #algorithms

1595641189

In this article, we are going to cover the concept of linked lists, what linked lists are and how to implement one in your project. This article covers the basic way to implement a linked list in JavaScript.

In this article, i will assume that you already know or have a basic knowledge of javascript and general programming concepts like strings and arrays.

A linked list is just another data structure like arrays , stacks or queues. A linked list unlike an array contains nodes where each node has a data part which stores our data and a next part or a reference to the next node in the list.

The nodes are connected together through links. In a more simple term, a linked list is a collection of nodes which are connected to each other through links. These nodes have two parts. The first part stores our data while the second part stores the address or link to the next node in the list.

Consider the diagram below.

The first node in a list is usually called a head. The head links to the next node through the next link and it continues till the last node which is not pointing to any other node, so the next value of the last node becomes NULL.

Linked lists cannot be accessed randomly. I.e you cannot access data with it’s index (this can be manipulated but it’s not like we do with arrays). In linked lists, we refer to the memory location Address, not the index location.

Now that we have a better understanding of linked lists. Let’s go on and implement it using javascript.

The first thing we are going to do is to create a node constructor function or class. I will be using ES6 classes in the article.

```
class Node{
constructor(data, next = null){
this.data = data;
this.next = next;
}
```

#javascript-tips #programming #linked-lists #javascript #javascript-development

1624320600

A linked list is a basic data structure. It is a collection of nodes that connects each node to the next node with a pointer.

Each node consists of two items:

- Data (such as a number)
- Pointer to the next node

Here is an illustration of a linked list

A linked list forms a chain of nodes. Each node holds data and points to the next node. Image by the author.

#programming #coding #python #how to create a linked list in python #create a linked list #linked list

1623922260

In this blog, we will discuss basic operations and implementation of the singly linked list in JavaScript.

*This is a part of the blog DS with JS — Linked Lists. For getting started and the basics of Linked List check it out.*

This is a list of the most common operations performed on Singly Linked Lists. We will see the usage and their **time complexities**.

Let us get started with the node representation for the singly linked list. I will consider a list of some morning habits.

First Node in Singly Linked List | Morning Habits.

We know a node in the singly linked list consists of two elements — *value and a pointer* to the next node or `null`

. The first node is called the `head`

and the last node is called the `tail`

. To begin let us consider we have only one node in our singly linked list.

The node definition is as follows. The pointer is represented using `this.next`

for each node.

```
class Node {
constructor(value) {
this.value = value;
this.next = null;
}
}
```

#data-structures #javascript #linked-lists