Added CircularDoublyLinkedList.js alongwith it's test code #1414

Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,140 @@
	// Explanation:- https://www.javatpoint.com/circular-doubly-linked-list

	class Node {
	/**
	* Creates a new Node with the given element.
	* @param {*} element - The element to be stored in the node.
	*/
	constructor(element) {
	this.element = element;
	this.next = null;
	this.prev = null;
	}
	}

	class CircularDoublyLinkedList {
	/**
	* Creates an empty Circular Doubly Linked List.
	*/
	constructor() {
	this.length = 0;
	this.head = null;
	this.tail = null;
	}

	/**
	* Inserts an element at the specified position in the list.
	* @param {number} position - The position at which to insert the element.
	* @param {*} element - The element to be inserted.
	* @returns {boolean} - True if the insertion was successful, false otherwise.
	*/
	insertAt(position, element) {
	if (position >= 0 && position <= this.length) {
	const node = new Node(element);
	let current = this.head;
	let previous = null;
	let index = 0;

	if (position === 0) {
	if (!this.head) {
	this.head = node;
	this.tail = node;
	node.next = node; // Circular reference
	node.prev = node; // Circular reference
	} else {
	node.next = current;
	node.prev = this.tail;
	this.head = node;
	current.prev = node;
	this.tail.next = node;
	}
	} else {
	while (index++ < position) {
	previous = current;
	current = current.next;
	}
	node.next = current;
	node.prev = previous;
	previous.next = node;
	current.prev = node;

	if (position === this.length) {
	this.tail = node;
	}
	}

	this.length++;
	return true;
	} else {
	return false;
	}
	}

	/**
	* Appends an element to the end of the list.
	* @param {*} element - The element to be appended.
	*/
	append(element) {
	return this.insertAt(this.length, element);
	}

	/**
	* Removes and returns the element at the specified position.
	* @param {number} position - The position of the element to be removed.
	* @returns {*} - The removed element, or null if the position is invalid.
	*/
	removeAt(position) {
	if (position >= 0 && position < this.length) {
	let current = this.head;
	let previous = null;
	let index = 0;

	if (position === 0) {
	this.head = current.next;
	this.head.prev = this.tail;
	this.tail.next = this.head;
	if (this.length === 1) {
	this.tail = null;
	}
	} else {
	while (index++ < position) {
	previous = current;
	current = current.next;
	}
	previous.next = current.next;
	current.next.prev = previous;

	if (position === this.length - 1) {
	this.tail = previous;
	}
	}

	this.length--;
	return current.element;
	} else {
	return null;
	}
	}

	/**
	* Iterator over the elements in the list.
	*/
	*elements() {
	let currentNode = this.head;
	if (!currentNode) return;
	do {
	yield currentNode.element;
	currentNode = currentNode.next;
	} while (currentNode !== this.head);
	}

	/**
	* Checks if the list is empty.
	* @returns {boolean} - True if the list is empty, false otherwise.
	*/
	isEmpty() {
	return this.length === 0;
	}
	}

	export { CircularDoublyLinkedList };

58 changes: 58 additions & 0 deletions Data-Structures/Linked-List/test/CircularDoublyLinkedList.test.js

Show comments View file Open in desktop

Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,58 @@
	import { CircularDoublyLinkedList } from '../CircularDoublyLinkedList';

	describe('CircularDoublyLinkedList', () => {
	/**
	* Creates a new CircularDoublyLinkedList and appends elements to it.
	* @param {Array} elements - The elements to append.
	* @returns {CircularDoublyLinkedList} - The created list.
	*/
	function createAndAppend(elements) {
	const list = new CircularDoublyLinkedList();
	elements.forEach((element) => list.append(element));
	return list;
	}

	const expectList = (list, expected) => expect([...list.elements()]).toEqual(expected);

	it('append', () => {
	const list = createAndAppend([1]);

	expectList(list, [1]);

	list.append(2);
	expectList(list, [1, 2]);
	});

	it('insertAt', () => {
	const list = createAndAppend([1]);

	list.insertAt(0, 20);
	expectList(list, [20, 1]);

	list.insertAt(1, 30);
	expectList(list, [20, 30, 1]);
	});

	it('removeAt', () => {
	const list = createAndAppend([10, 40, 30]);

	list.removeAt(0);
	expectList(list, [40, 30]);

	list.removeAt(1);
	expectList(list, [40]);
	});

	it('elements', () => {
	const list = createAndAppend([10, 20, 30]);
	expect([...list.elements()]).toEqual([10, 20, 30]);
	});

	it('isEmpty', () => {
	const emptyList = new CircularDoublyLinkedList();
	expect(emptyList.isEmpty()).toEqual(true);

	const nonEmptyList = createAndAppend(['Hello']);
	expect(nonEmptyList.isEmpty()).toEqual(false);
	});
	});

Navigation Menu

Search code, repositories, users, issues, pull requests...

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

Added CircularDoublyLinkedList.js alongwith it's test code #1414

Are you sure you want to change the base?

Uh oh!

Added CircularDoublyLinkedList.js alongwith it's test code #1414

Filter by extension

Uh oh!

Uh oh!

Diff view

Diff view

There are no files selected for viewing