Javascript Data Structure - Doubly Linked list
Tags: javascript, beginners, tutorial, datastructure
Published: 2021-10-13 16:17:46

## Definition 
Doubly linked list is a type of _linked list_ in which each node apart from storing its data has two pointers. The first pointer points to the previous node in the list and the second pointer points to the next node in the list. The head node its previous value points to NULL and similar to the tail node its next value points to null.

![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xw4avvk6lcw9m7p3ubpy.png)

and saving a second reference to nodes requires more space in memory.

let's recap the main properties of the linked list:

The main properties of the linked list are:
- length: The number of nodes in the linked list 
- Head: The first node
- Tail: The last node

See more in my last post [Javascript Data structure - Linked list](https://dev.to/riviergrullon/javascript-datastructure-linked-list-2ocn)

in this case the nodes will be contain the next properties:

- next: pointer to the next node
- value: actual value of the node
- prev: pointer to the previous node 

and the main operations here are:
- **append**: Add a node to the end in the linked list

- **prepend**: Add a node to the beggining the linked list

- **removeFirst**: remove the first node (head) 

- **removeLast**: remove the last node(tail)

- **search**: find a node by his value and returned

- **remove**: remove a node by its value from the linked list

## Implemetation

```Javascript
class LinkedList {
	constructor() {
		this.head = null;
		this.tail = null;
		this.length = 0;
	}

	//** add at the end of the linked list */
	append(value) {
		// if empty
		if (!this.tail) {
			this.tail = { value };
			this.head = this.tail;
		} else {
			let oldTail = this.tail;
			this.tail = { value };
			oldTail.next = this.tail;
			this.tail.prev = oldTail;
		}
		this.length++;
	}

	//** add to the beggining  */
	prepend(value) {
		if (!this.head) {
			this.tail = { value };
			this.head = this.tail;
		} else {
			let oldHead = this.head;
			this.head = { value };
			oldHead.prev = this.head;
			this.head.next = oldHead;
		}
		this.length++;
	}
	removeFirst() {
		if (!this.head) {
			throw new Error("The list is empty");
		} else {
			let tempHead = this.head;
			// ** when theres only one node
			if (this.head === this.tail) {
				this.head = null;
				this.tail = null;
			} else {
				this.head = this.head.next;
				this.head.prev = null;
			}
			this.length--;
			return tempHead.value;
		}
	}
	removeLast() {
		if (!this.tail) {
			return null;
		} else {
			let tempTail = this.tail;
			if (this.tail === this.head) {
				this.tail = null;
				this.head = null;
				this.length--;
			} else {
				this.tail = this.tail.prev;
				this.tail.next = null;
				this.length--;
				return tempTail.value;
			}
		}
	}
	search(value) {
		let currentNode = this.head;
		while (currentNode) {
			if (currentNode.value === value) {
				return currentNode;
			}
			currentNode = currentNode.next;
		}
		return null;
	}
	remove(value) {
		let tempNode = this.search(value);

		if (tempNode === this.tail) {
			this.removeLast();
			return;
		} else if (tempNode === this.head) {
			this.removeFirst();
			return;
		} else {
			tempNode.prev.next = tempNode.next;
			tempNode.next.prev = tempNode.prev;
		}
		this.length--;
	}
}
```


- Create a class with a constructor that initializes the head, tail and length of the linked list.
- Define a method _search()_ that iterate through the list to find a specific node.

- Define two convenience methods, _append()_ and _prepend()_ that use to insert a new element at the start or end of the nodes respectively and increase the length.

Define a method _remove()_ that uses the _search_ to find the node and replacing its value to delete it.
- Define two convenients methods _removeFirst()_ and _removeLast()_ to remove the head or the tail.

```Javascript
let list = new LinkedList();

list.append(1);
list.append(2);
list.append(23);
list.append(3);
list.prepend(55);
list.append(2);
list.append(22);

list.remove(22);

console.log(list);

```

In my last post of linked list I made a mistake writting the linked list, the point of the linked list is to avoid arrays, so in this post I want to make up for my mistake :) this series is for learning and thank u all for the feedbacks.