An easier way to deal with linked lists. This package is meant to stop the repetitiveness of functions used on linked lists. The linked lists class used for this package is:
class NodeObject {
value: any;
next: NodeObject | null;
constructor(x: any) {
this.value = x;
this.next = null;
}
}
Any other syntax for a linked list will not work with this package.
Any additions needed or suggestions can be left at the repository here: GitHub
First start by installing it using the command listed. After you can import it where it is needed by doing:
const { LinkedList } = require("linked-list-operations");
The following functions are supported in thie package:
Provide any value and it will return a starter node with the given value.
LinkedList.createHead(1)
Output:
{
value: 1,
next: null
}
Provide an array with any values and it will return a series of nodes in a linked list.
LinkedList.createFromArray([1, 2, 3])
Output:
{
value: 1,
next: {
value: 2,
next: { value: 3, next: null }
}
}
Provide an array of any values and it will return a circular series of nodes in a looped linked list.
LinkedList.createCircularFromArray([1, 2])
Output:
{
value: 1,
next: {
value: 2,
next: // this points back to the first node value: 1
}
}
Provide a linked list of NodeObjects, circular or not, and it'll return an array.
LinkedList.convertToArray({
value: 1,
next: {
value: 2,
next: { value: 3, next: null }
}
})
Output: [1,2,3]
Provide a linked list of NodeObjects, circular or not, and it'll return an object with the spot in the list as the key and the value is the value of the NodeObject.
LinkedList.convertToObject({
value: 1,
next: {
value: 2,
next: { value: 4, next: null }
}
})
Output: {
1: 1,
2: 2,
3: 4
}
Provide a linked list, circular or not, and it'll copy and send back a clone or deep copy of that linked list. Used to not alter an existing linked list.
LinkedList.clone({
value: 1,
next: {
value: 2,
next: { value: 3, next: null }
}
})
Output: {
value: 1,
next: {
value: 2,
next: { value: 3, next: null }
}
}
Provide a linked list, circular or not, and it'll search to see if the provided value is included in the linked list returning a boolean. You can also pass in a searchFunction if you are looking for a nested value or values that need to be computed, defaults to (value) => value.
const list = {
value: 1,
next: {
value: 2,
next: { value: 3, next: null }
}
}
LinkedList.search(list, 1)
Output: true
const nestedValueList = {
value: { this: 1, that: 1 },
next: {
value: { this: 2, that: 2 },
next: { value: { this: 3, that: 3 }, next: null }
}
}
LinkedList.search(list, 2, (val) => val.this)
Output: true
Provide a linked list, circular or not, and it'll find the provided value and return that Node, or if it cannot find the value it will return null. You can also pass in a searchFunction if you are looking for a nested value or values that need to be computed, defaults to (value) => value.
const list = {
value: 1,
next: {
value: 2,
next: { value: 3, next: null }
}
}
LinkedList.find(list, 2)
Output: {
value: 2,
next: {
value: 3,
next: null
}
}
const nestedValueList = {
value: { this: 1, that: 1 },
next: {
value: { this: 2, that: 2 },
next: { value: { this: 3, that: 3 }, next: null }
}
}
LinkedList.find(list, 2, (val) => val.this)
Output: {
value: { this: 2, that: 2 },
next: {
value: { this: 3, that: 3 },
next: null
}
}
Provide a linked list, circular or not, and it'll find the length of the list.
const list = {
value: 1,
next: {
value: 2,
next: { value: 3, next: null }
}
}
LinkedList.findLength(list)
Output: 3
Provide a noncircular linked list and it'll return the nth node or null if the list is not long enough.
const list = {
value: 1,
next: {
value: 2,
next: { value: 3, next: null }
}
}
LinkedList.findNthNode(list, 3)
Output: {
value: 3,
next: null
}
Provide a noncircular linked list and it'll return the middle node or null if the list is circular or nonexistent.
const list = {
value: 1,
next: {
value: 2,
next: { value: 3, next: null }
}
}
LinkedList.findMiddle(list)
Output: {
value: 3,
next: {
value: 3
next: null
}
}
Provide a noncircular linked list and it'll return the nth node from the end of the list or null if the list is not long enough.
const list = {
value: 1,
next: {
value: 2,
next: { value: 3, next: null }
}
}
LinkedList.findNthNodeFromEnd(list, 1)
Output: {
value: 3,
next: null
}
Provide a noncircular linked list and it'll return the same list with the new value added onto the end.
const list = {
value: 1,
next: {
value: 2,
next: null
}
}
LinkedList.add(list, 3)
Output: {
value: 1,
next: {
value: 2,
next: { value: 3, next null }
}
}
Provide a noncircular linked list and it'll return the same list with the new value replacing the value of the index provided.
const list = {
value: 1,
next: {
value: 2,
next: null
}
}
LinkedList.replace(list, 2, 3)
Output: {
value: 1,
next: {
value: 3,
next: null
}
}
Provide a linked list, circular or not, and it'll return the same list with the specific node being replaced by the new node.
const list = {
value: 1,
next: {
value: 2,
next: null
}
}
const oldNode = list.next
LinkedList.replaceNode(list, oldNode, { value: 3, next: { value: 4, next: null } })
Output: {
value: 1,
next: {
value: 3,
next: { value: 4, next null }
}
}
Provide a noncircular linked list and it'll return the same list with the new value added at the provided index.
const list = {
value: 1,
next: {
value: 3,
next: null
}
}
LinkedList.insert(list, 1, 2)
Output: {
value: 1,
next: {
value: 2,
next: { value: 3, next null }
}
}
Provide a noncircular linked list and it'll return the same list with the index provided removed from the list.
const list = {
value: 1,
next: {
value: 2,
next: { value: 3, next: null }
}
}
LinkedList.removeIndex(list, 2)
Output: {
value: 1,
next: {
value: 2,
next: null
}
}
Provide a circular linked list and it'll return the same list with the specified node removed.
const list = {
value: 1,
next: {
value: 2,
next: {
value: 3,
next: // this points back at the first node, value 1
}
}
}
LinkedList.removeNodeCircular(list, { value: 2, next: ... })
Output: {
value: 1,
next: {
value: 3,
next: // this points back at first node, value 1
}
}
Provide a noncircular linked list and it'll return the same list with the specified node removed.
const list = {
value: 1,
next: {
value: 2,
next: null
}
}
LinkedList.removeNode(list, { value: 2, next: null })
Output: {
value: 1,
next: null
}
Provide a linked list, circular or not, and it'll return the same list up until the index where everything after is removed. NOTE: this does break circular linked lists and makes then noncircular.
const list = {
value: 1,
next: {
value: 2,
next: null
}
}
LinkedList.removeAfterIndex(list, 0)
Output: {
value: 1,
next: null
}
Provide a noncircular linked list and it'll return the same list with all the values that equal the provided value. You can also provide a search function for nested values or values that need to be computed, defaults to (value) => value.
const list = {
value: 1,
next: {
value: 2,
next: null
}
}
LinkedList.removeValue(list, 1)
Output: {
value: 2,
next: null
}
Provide a linked list, circular or not, and it'll return the list reversed.
const list = {
value: 1,
next: {
value: 2,
next: null
}
}
LinkedList.reverse(list)
Output: {
value: 2,
next: {
value: 1,
next: null
}
}
Provide a noncircular linked list and it'll return a new sorted list. Defaults to ascending order. You can also provide a compare function that returns a boolean if the data to sort is nested in an object or needs to be computed, defaults to (val1, val2) => val1 < val2.
const list = {
value: 2,
next: {
value: 1,
next: null
}
}
LinkedList.mergeSort(list, 1)
Output: {
value: 1,
next: {
value: 2,
next: null
}
}
Provide two noncircular linked lists and it'll return a new linked list starting at head1 and adding head2 to the end.
const list1 = {
value: 2,
next: {
value: 1,
next: null
}
}
const list2 = {
value: 3,
next: null
}
LinkedList.combine(list1, list2)
Output: {
value: 1,
next: {
value: 2,
next: { value: 3, next: null }
}
}
Provide a linked list and it'll return a true/false value if the list is circular or not.
const list = {
value: 2,
next: {
value: 1,
next: null
}
}
LinkedList.detectCycle(list)
Output: false
Provide a linked list, with a cycle inside it, and it'll return the cycle.
const list = {
value: 1,
next: {
value: 2,
next: { value: 3, next: // points to node with value 2 }
}
}
LinkedList.findCycle(list)
Output: {
value: 2,
next: {
value: 3,
next: // points to node with value 2
}
}
Provide a linked list, with a cycle inside it, and it'll return a list with the cycle removed.
const list = {
value: 1,
next: {
value: 2,
next: { value: 3, next: // points to node with value 2 }
}
}
LinkedList.removeCycle(list)
Output: {
value: 1,
next: null
}
mergeTwoSorted(head1: NodeObject | null, head2: NodeObject | null, compare?: (value1: any, value2: any) => boolean): NodeObject | null
Provide two sorted linked lists and it'll return one list that is also sorted. Also can add an optional compare function for nested values or values that need to be computed, defaults to (value1, value2) => value1 < value2.
const list1 = {
value: 1,
next: {
value: 2,
next: { value: 3, next: null }
}
}
const list2 = {
value: 1,
next: {
value: 4,
next: null
}
}
LinkedList.mergeTwoSorted(list1, list2)
Output: {
value: 1,
next: {
value: 2,
next: {
value: 3,
next: { value: 4, next: null }
}
}
}
Provide two noncircular linked lists and it'll return one list that is alternating vlaues from each list. Circular linked lists will cause it to return null.
const list1 = {
value: 1,
next: {
value: 2,
next: null
}
}
const list2 = {
value: 1,
next: {
value: 4,
next: null
}
}
LinkedList.merge(list1, list2)
Output: {
value: 1,
next: {
value: 1,
next: {
value: 2,
next: { value: 4, next: null }
}
}
}
Provide a noncirculer linked list and it'll return the same list but rotated however many rotations that is provided, causing it to have a new head unless it has a full rotation. Circular linked lists will cause it to return null.
const list = {
value: 1,
next: {
value: 2,
next: { value: 3, next: null }
}
}
LinkedList.rotate(list, 1)
Output: {
value: 2,
next: {
value: 3,
next: {
value: 1,
next: null
}
}
}