From c492af046126b6c0abb06c400f61c751dff120df Mon Sep 17 00:00:00 2001 From: Revone Date: Sun, 29 Oct 2023 16:43:19 +0800 Subject: [PATCH] [linked-list] Standardize the method names of DoublyLinkedList and SinglyLinkedList. --- CHANGELOG.md | 2 +- package-lock.json | 50 +++---- package.json | 8 +- .../linked-list/doubly-linked-list.ts | 119 ++++++++-------- .../linked-list/singly-linked-list.ts | 130 ++++++++++++++++-- src/data-structures/queue/deque.ts | 44 +++--- src/data-structures/queue/queue.ts | 6 +- .../linked-list/doubly-linked-list.test.ts | 10 +- .../linked-list/linked-list.test.ts | 4 +- .../linked-list/singly-linked-list.test.ts | 4 +- test/unit/data-structures/queue/deque.test.ts | 86 ++++++------ test/unit/data-structures/queue/queue.test.ts | 14 +- 12 files changed, 291 insertions(+), 186 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 43c4c33..51e66a0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,7 +8,7 @@ All notable changes to this project will be documented in this file. - [Semantic Versioning](https://semver.org/spec/v2.0.0.html) - [`auto-changelog`](https://github.com/CookPete/auto-changelog) -## [v1.39.0](https://github.com/zrwusa/data-structure-typed/compare/v1.35.0...main) (upcoming) +## [v1.39.1](https://github.com/zrwusa/data-structure-typed/compare/v1.35.0...main) (upcoming) ### Changes diff --git a/package-lock.json b/package-lock.json index 036d8c4..79cc7ab 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "data-structure-typed", - "version": "1.39.0", + "version": "1.39.1", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "data-structure-typed", - "version": "1.39.0", + "version": "1.39.1", "license": "MIT", "devDependencies": { "@types/benchmark": "^2.1.3", @@ -15,17 +15,17 @@ "@typescript-eslint/eslint-plugin": "^6.7.4", "@typescript-eslint/parser": "^6.7.4", "auto-changelog": "^2.4.0", - "avl-tree-typed": "^1.38.9", + "avl-tree-typed": "^1.39.0", "benchmark": "^2.1.4", - "binary-tree-typed": "^1.38.9", - "bst-typed": "^1.38.9", + "binary-tree-typed": "^1.39.0", + "bst-typed": "^1.39.0", "dependency-cruiser": "^14.1.0", "eslint": "^8.50.0", "eslint-config-prettier": "^9.0.0", "eslint-import-resolver-alias": "^1.1.2", "eslint-import-resolver-typescript": "^3.6.1", "eslint-plugin-import": "^2.28.1", - "heap-typed": "^1.38.9", + "heap-typed": "^1.39.0", "istanbul-badges-readme": "^1.8.5", "jest": "^29.7.0", "prettier": "^3.0.3", @@ -2728,12 +2728,12 @@ } }, "node_modules/avl-tree-typed": { - "version": "1.38.9", - "resolved": "https://registry.npmjs.org/avl-tree-typed/-/avl-tree-typed-1.38.9.tgz", - "integrity": "sha512-1Qy7d5G8JXa5Z2KKmlZI1WOmJkIyW6l2zRGHCxXItEfIg+BirZm6BK4IOb03OJjA2qg2N5AxgZDKuMDAzbRXNw==", + "version": "1.39.0", + "resolved": "https://registry.npmjs.org/avl-tree-typed/-/avl-tree-typed-1.39.0.tgz", + "integrity": "sha512-YpYfpO0slt8R5lcy4wrz7inKFAG1NKUZk2FnJ2FEYIdBJaBIUvW0cflx6Cuuy1iRiXbazpTqGQgKC0nERWUiow==", "dev": true, "dependencies": { - "data-structure-typed": "^1.38.9" + "data-structure-typed": "^1.39.0" } }, "node_modules/babel-jest": { @@ -2927,12 +2927,12 @@ } }, "node_modules/binary-tree-typed": { - "version": "1.38.9", - "resolved": "https://registry.npmjs.org/binary-tree-typed/-/binary-tree-typed-1.38.9.tgz", - "integrity": "sha512-XGp+ADfVMhhpEqLV+Bi27FkJcT1P6ExPpGuhzhKzyfoWmsnjp94tuuvrUDCqPjYoioGwzbG7yUnC2Fbi4CbsAA==", + "version": "1.39.0", + "resolved": "https://registry.npmjs.org/binary-tree-typed/-/binary-tree-typed-1.39.0.tgz", + "integrity": "sha512-oJzCbrs+l4qacscxFvVB/ielr22KiO8z/bWSx/tJmafpinWmkAuQIBRGqo+frfFi8MKstNerHPEF+4yT8AakUA==", "dev": true, "dependencies": { - "data-structure-typed": "^1.38.9" + "data-structure-typed": "^1.39.0" } }, "node_modules/brace-expansion": { @@ -3011,12 +3011,12 @@ } }, "node_modules/bst-typed": { - "version": "1.38.9", - "resolved": "https://registry.npmjs.org/bst-typed/-/bst-typed-1.38.9.tgz", - "integrity": "sha512-jnHwqyTjRCDitmzXydhcP1YmRsCfBYxwhDXD8lm1pQPWOXkcAIU7HqTg7WCPrReo1GaWfQJeBhAIsguluEQ6Lw==", + "version": "1.39.0", + "resolved": "https://registry.npmjs.org/bst-typed/-/bst-typed-1.39.0.tgz", + "integrity": "sha512-AvitIe0j8jPrXyZkQI5zhTYIc4eS5rxvW59/0YHymg54BeMs+zm1WzouPhsh7qp9D+IcTpQmqDY0kjc07Tic3w==", "dev": true, "dependencies": { - "data-structure-typed": "^1.38.9" + "data-structure-typed": "^1.39.0" } }, "node_modules/buffer-from": { @@ -3413,9 +3413,9 @@ } }, "node_modules/data-structure-typed": { - "version": "1.38.9", - "resolved": "https://registry.npmjs.org/data-structure-typed/-/data-structure-typed-1.38.9.tgz", - "integrity": "sha512-iHOVtsBY7ZVI28I0ikedDFmBeu3rGu1gSnmemg11PT/KIuflNe9zdwlNm+yZ4M56LbQp0aqY09YoNnNX43UvRw==", + "version": "1.39.0", + "resolved": "https://registry.npmjs.org/data-structure-typed/-/data-structure-typed-1.39.0.tgz", + "integrity": "sha512-HESmI/a+uE3ELRDVKIBSmfgSMep4ETJco8jeZD2By5lNhMW9HDZE+SGNqlSeBJd3PdJyact9dWlXWwg7S3+ztQ==", "dev": true }, "node_modules/debug": { @@ -4771,12 +4771,12 @@ } }, "node_modules/heap-typed": { - "version": "1.38.9", - "resolved": "https://registry.npmjs.org/heap-typed/-/heap-typed-1.38.9.tgz", - "integrity": "sha512-50RxpJOqMDMbpGa3NZny3YO8NArmwVeIipNDHkOvHXH+P93BvbaFz06rOyuJ1cUxDwTPsv34VfJgrz576/BZtg==", + "version": "1.39.0", + "resolved": "https://registry.npmjs.org/heap-typed/-/heap-typed-1.39.0.tgz", + "integrity": "sha512-n9Qa+Ph6nnqRN6lz52R62CHrpgWixU/39P22WT9Epf+4dj+pDYPKEGekCCidjjxQXgoR56d6XjnZWFgiQYYN4Q==", "dev": true, "dependencies": { - "data-structure-typed": "^1.38.9" + "data-structure-typed": "^1.39.0" } }, "node_modules/html-escaper": { diff --git a/package.json b/package.json index 680b283..2fd7f9f 100644 --- a/package.json +++ b/package.json @@ -61,17 +61,17 @@ "@typescript-eslint/eslint-plugin": "^6.7.4", "@typescript-eslint/parser": "^6.7.4", "auto-changelog": "^2.4.0", - "avl-tree-typed": "^1.38.9", + "avl-tree-typed": "^1.39.0", "benchmark": "^2.1.4", - "binary-tree-typed": "^1.38.9", - "bst-typed": "^1.38.9", + "binary-tree-typed": "^1.39.0", + "bst-typed": "^1.39.0", "dependency-cruiser": "^14.1.0", "eslint": "^8.50.0", "eslint-config-prettier": "^9.0.0", "eslint-import-resolver-alias": "^1.1.2", "eslint-import-resolver-typescript": "^3.6.1", "eslint-plugin-import": "^2.28.1", - "heap-typed": "^1.38.9", + "heap-typed": "^1.39.0", "istanbul-badges-readme": "^1.8.5", "jest": "^29.7.0", "prettier": "^3.0.3", diff --git a/src/data-structures/linked-list/doubly-linked-list.ts b/src/data-structures/linked-list/doubly-linked-list.ts index ab9ddc5..ceacdb2 100644 --- a/src/data-structures/linked-list/doubly-linked-list.ts +++ b/src/data-structures/linked-list/doubly-linked-list.ts @@ -147,11 +147,11 @@ export class DoublyLinkedList { } /** - * The `pollLast()` function removes and returns the value of the last node in a doubly linked list. + * The `popLast()` function removes and returns the value of the last node in a doubly linked list. * @returns The method is returning the value of the removed node (removedNode.val) if the list is not empty. If the * list is empty, it returns null. */ - pollLast(): E | undefined { + popLast(): E | undefined { return this.pop(); } @@ -175,11 +175,11 @@ export class DoublyLinkedList { } /** - * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list. + * The `popFirst()` function removes and returns the value of the first node in a doubly linked list. * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked * list. */ - pollFirst(): E | undefined { + popFirst(): E | undefined { return this.shift(); } @@ -211,18 +211,18 @@ export class DoublyLinkedList { } /** - * The `peekFirst` function returns the first node in a doubly linked list, or null if the list is empty. - * @returns The method `peekFirst()` returns the first node of the doubly linked list, or `null` if the list is empty. + * The `getFirst` function returns the first node in a doubly linked list, or null if the list is empty. + * @returns The method `getFirst()` returns the first node of the doubly linked list, or `null` if the list is empty. */ - peekFirst(): E | undefined { + getFirst(): E | undefined { return this.head?.val; } /** - * The `peekLast` function returns the last node in a doubly linked list, or null if the list is empty. - * @returns The method `peekLast()` returns the last node of the doubly linked list, or `null` if the list is empty. + * The `getLast` function returns the last node in a doubly linked list, or null if the list is empty. + * @returns The method `getLast()` returns the last node of the doubly linked list, or `null` if the list is empty. */ - peekLast(): E | undefined { + getLast(): E | undefined { return this.tail?.val; } @@ -266,7 +266,7 @@ export class DoublyLinkedList { * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode` if a node with the specified value `val` * is found in the linked list. If no such node is found, it returns `null`. */ - findNode(val: E | null): DoublyLinkedListNode | null { + getNode(val: E | null): DoublyLinkedListNode | null { let current = this.head; while (current) { @@ -310,6 +310,43 @@ export class DoublyLinkedList { return true; } + /** + * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list. + * @param {E | DoublyLinkedListNode} existingValueOrNode - The existing value or node in the doubly linked list + * before which the new value will be inserted. It can be either the value of the existing node or the existing node + * itself. + * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked + * list. + * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the + * insertion fails. + */ + insertBefore(existingValueOrNode: E | DoublyLinkedListNode, newValue: E): boolean { + let existingNode; + + if (existingValueOrNode instanceof DoublyLinkedListNode) { + existingNode = existingValueOrNode; + } else { + existingNode = this.getNode(existingValueOrNode); + } + + if (existingNode) { + const newNode = new DoublyLinkedListNode(newValue); + newNode.prev = existingNode.prev; + if (existingNode.prev) { + existingNode.prev.next = newNode; + } + newNode.next = existingNode; + existingNode.prev = newNode; + if (existingNode === this.head) { + this.head = newNode; + } + this._length++; + return true; + } + + return false; + } + /** * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element. * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the @@ -331,9 +368,6 @@ export class DoublyLinkedList { return removedNode!.val; } - delete(valOrNode: E): boolean; - delete(valOrNode: DoublyLinkedListNode): boolean; - /** * The `delete` function removes a node from a doubly linked list based on either the node itself or its value. * @param {E | DoublyLinkedListNode} valOrNode - The `valOrNode` parameter can accept either a value of type `E` or @@ -347,7 +381,7 @@ export class DoublyLinkedList { if (valOrNode instanceof DoublyLinkedListNode) { node = valOrNode; } else { - node = this.findNode(valOrNode); + node = this.getNode(valOrNode); } if (node) { @@ -437,14 +471,14 @@ export class DoublyLinkedList { } /** - * The `findLast` function iterates through a linked list from the last node to the first node and returns the last + * The `findBackward` function iterates through a linked list from the last node to the first node and returns the last * value that satisfies the given callback function, or null if no value satisfies the callback. * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This * function is used to determine whether a given value satisfies a certain condition. - * @returns The method `findLast` returns the last value in the linked list that satisfies the condition specified by + * @returns The method `findBackward` returns the last value in the linked list that satisfies the condition specified by * the callback function. If no value satisfies the condition, it returns `null`. */ - findLast(callback: (val: E) => boolean): E | null { + findBackward(callback: (val: E) => boolean): E | null { let current = this.tail; while (current) { if (callback(current.val)) { @@ -456,10 +490,10 @@ export class DoublyLinkedList { } /** - * The `toArrayReverse` function converts a doubly linked list into an array in reverse order. - * @returns The `toArrayReverse()` function returns an array of type `E[]`. + * The `toArrayBackward` function converts a doubly linked list into an array in reverse order. + * @returns The `toArrayBackward()` function returns an array of type `E[]`. */ - toArrayReverse(): E[] { + toArrayBackward(): E[] { const array: E[] = []; let current = this.tail; while (current) { @@ -555,9 +589,6 @@ export class DoublyLinkedList { return accumulator; } - insertAfter(existingValueOrNode: E, newValue: E): boolean; - insertAfter(existingValueOrNode: DoublyLinkedListNode, newValue: E): boolean; - /** * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list. * @param {E | DoublyLinkedListNode} existingValueOrNode - The existing value or node in the doubly linked list @@ -573,7 +604,7 @@ export class DoublyLinkedList { if (existingValueOrNode instanceof DoublyLinkedListNode) { existingNode = existingValueOrNode; } else { - existingNode = this.findNode(existingValueOrNode); + existingNode = this.getNode(existingValueOrNode); } if (existingNode) { @@ -594,40 +625,12 @@ export class DoublyLinkedList { return false; } - /** - * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list. - * @param {E | DoublyLinkedListNode} existingValueOrNode - The existing value or node in the doubly linked list - * before which the new value will be inserted. It can be either the value of the existing node or the existing node - * itself. - * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked - * list. - * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the - * insertion fails. - */ - insertBefore(existingValueOrNode: E | DoublyLinkedListNode, newValue: E): boolean { - let existingNode; + * [Symbol.iterator]() { + let current = this.head; - if (existingValueOrNode instanceof DoublyLinkedListNode) { - existingNode = existingValueOrNode; - } else { - existingNode = this.findNode(existingValueOrNode); + while (current) { + yield current.val; + current = current.next; } - - if (existingNode) { - const newNode = new DoublyLinkedListNode(newValue); - newNode.prev = existingNode.prev; - if (existingNode.prev) { - existingNode.prev.next = newNode; - } - newNode.next = existingNode; - existingNode.prev = newNode; - if (existingNode === this.head) { - this.head = newNode; - } - this._length++; - return true; - } - - return false; } } diff --git a/src/data-structures/linked-list/singly-linked-list.ts b/src/data-structures/linked-list/singly-linked-list.ts index c4e1da9..48e41c4 100644 --- a/src/data-structures/linked-list/singly-linked-list.ts +++ b/src/data-structures/linked-list/singly-linked-list.ts @@ -87,17 +87,13 @@ export class SinglyLinkedList { return singlyLinkedList; } - getLength(): number { - return this._length; - } - /** - * The `push` function adds a new node with the given data to the end of a singly linked list. - * @param {E} data - The "data" parameter represents the value that you want to add to the linked list. It can be of + * The `push` function adds a new node with the given val to the end of a singly linked list. + * @param {E} val - The "val" parameter represents the value that you want to add to the linked list. It can be of * any type (E) as specified in the generic type declaration of the class or function. */ - push(data: E): void { - const newNode = new SinglyLinkedListNode(data); + push(val: E): void { + const newNode = new SinglyLinkedListNode(val); if (!this.head) { this.head = newNode; this.tail = newNode; @@ -108,6 +104,15 @@ export class SinglyLinkedList { this._length++; } + /** + * The `push` function adds a new node with the given val to the end of a singly linked list. + * @param {E} val - The "val" parameter represents the value that you want to add to the linked list. It can be of + * any type (E) as specified in the generic type declaration of the class or function. + */ + addLast(val: E): void { + this.push(val); + } + /** * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail * pointers accordingly. @@ -135,6 +140,16 @@ export class SinglyLinkedList { return val; } + /** + * The `popLast()` function removes and returns the value of the last element in a linked list, updating the head and tail + * pointers accordingly. + * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If + * the linked list is empty, it returns `null`. + */ + popLast(): E | undefined { + return this.pop(); + } + /** * The `shift()` function removes and returns the value of the first node in a linked list. * @returns The value of the node that is being removed from the beginning of the linked list. @@ -147,6 +162,14 @@ export class SinglyLinkedList { return removedNode.val; } + /** + * The `popFirst()` function removes and returns the value of the first node in a linked list. + * @returns The value of the node that is being removed from the beginning of the linked list. + */ + popFirst(): E | undefined { + return this.shift(); + } + /** * The unshift function adds a new node with the given value to the beginning of a singly linked list. * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the @@ -164,6 +187,15 @@ export class SinglyLinkedList { this._length++; } + /** + * The addFirst function adds a new node with the given value to the beginning of a singly linked list. + * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the + * linked list. + */ + addFirst(val: E): void { + this.unshift(val); + } + /** * The function `getAt` returns the value at a specified index in a linked list, or null if the index is out of range. * @param {number} index - The index parameter is a number that represents the position of the element we want to @@ -382,7 +414,7 @@ export class SinglyLinkedList { * @returns a `SinglyLinkedListNode` if a node with the specified value is found in the linked list. If no node with * the specified value is found, the function returns `null`. */ - findNode(value: E): SinglyLinkedListNode | null { + getNode(value: E): SinglyLinkedListNode | null { let current = this.head; while (current) { @@ -432,9 +464,6 @@ export class SinglyLinkedList { return false; } - insertAfter(existingValueOrNode: E, newValue: E): boolean; - insertAfter(existingValueOrNode: SinglyLinkedListNode, newValue: E): boolean; - /** * The `insertAfter` function inserts a new node with a given value after an existing node in a singly linked list. * @param {E | SinglyLinkedListNode} existingValueOrNode - The existing value or node in the linked list after which @@ -449,7 +478,7 @@ export class SinglyLinkedList { if (existingValueOrNode instanceof SinglyLinkedListNode) { existingNode = existingValueOrNode; } else { - existingNode = this.findNode(existingValueOrNode); + existingNode = this.getNode(existingValueOrNode); } if (existingNode) { @@ -485,7 +514,80 @@ export class SinglyLinkedList { return count; } - *[Symbol.iterator]() { + /** + * The `forEach` function iterates over each element in a linked list and applies a callback function to each element. + * @param callback - The callback parameter is a function that takes two arguments: val and index. The val argument + * represents the value of the current node in the linked list, and the index argument represents the index of the + * current node in the linked list. + */ + forEach(callback: (val: E, index: number) => void): void { + let current = this.head; + let index = 0; + while (current) { + callback(current.val, index); + current = current.next; + index++; + } + } + + /** + * The `map` function takes a callback function and applies it to each element in the SinglyLinkedList, returning a new + * SinglyLinkedList with the transformed values. + * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in + * the original SinglyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped + * SinglyLinkedList). + * @returns The `map` function is returning a new instance of `SinglyLinkedList` that contains the mapped values. + */ + map(callback: (val: E) => U): SinglyLinkedList { + const mappedList = new SinglyLinkedList(); + let current = this.head; + while (current) { + mappedList.push(callback(current.val)); + current = current.next; + } + return mappedList; + } + + /** + * The `filter` function iterates through a SinglyLinkedList and returns a new SinglyLinkedList containing only the + * elements that satisfy the given callback function. + * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value. + * It is used to determine whether a value should be included in the filtered list or not. + * @returns The filtered list, which is an instance of the SinglyLinkedList class. + */ + filter(callback: (val: E) => boolean): SinglyLinkedList { + const filteredList = new SinglyLinkedList(); + let current = this.head; + while (current) { + if (callback(current.val)) { + filteredList.push(current.val); + } + current = current.next; + } + return filteredList; + } + + /** + * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a + * single value. + * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `val`. It is + * used to perform a specific operation on each element of the linked list. + * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting + * point for the reduction operation. + * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the + * elements in the linked list. + */ + reduce(callback: (accumulator: U, val: E) => U, initialValue: U): U { + let accumulator = initialValue; + let current = this.head; + while (current) { + accumulator = callback(accumulator, current.val); + current = current.next; + } + return accumulator; + } + + * [Symbol.iterator]() { let current = this.head; while (current) { diff --git a/src/data-structures/queue/deque.ts b/src/data-structures/queue/deque.ts index 3290ab1..8d6490a 100644 --- a/src/data-structures/queue/deque.ts +++ b/src/data-structures/queue/deque.ts @@ -95,12 +95,12 @@ export class ObjectDeque { } /** - * The function `pollFirst()` removes and returns the first element in a data structure. + * The function `popFirst()` removes and returns the first element in a data structure. * @returns The value of the first element in the data structure. */ - pollFirst() { + popFirst() { if (!this._size) return; - const value = this.peekFirst(); + const value = this.getFirst(); delete this._nodes[this._first]; this._first++; this._size--; @@ -108,20 +108,20 @@ export class ObjectDeque { } /** - * The `peekFirst` function returns the first element in an array-like data structure if it exists. + * The `getFirst` function returns the first element in an array-like data structure if it exists. * @returns The element at the first position of the `_nodes` array. */ - peekFirst() { + getFirst() { if (this._size) return this._nodes[this._first]; } /** - * The `pollLast()` function removes and returns the last element in a data structure. + * The `popLast()` function removes and returns the last element in a data structure. * @returns The value that was removed from the data structure. */ - pollLast() { + popLast() { if (!this._size) return; - const value = this.peekLast(); + const value = this.getLast(); delete this._nodes[this._last]; this._last--; this._size--; @@ -130,10 +130,10 @@ export class ObjectDeque { } /** - * The `peekLast()` function returns the last element in an array-like data structure. + * The `getLast()` function returns the last element in an array-like data structure. * @returns The last element in the array "_nodes" is being returned. */ - peekLast() { + getLast() { if (this._size) return this._nodes[this._last]; } @@ -188,19 +188,19 @@ export class ArrayDeque { } /** - * The function "pollLast" returns and removes the last element from an array, or returns null if the array is empty. - * @returns The method `pollLast()` returns the last element of the `_nodes` array, or `null` if the array is empty. + * The function "popLast" returns and removes the last element from an array, or returns null if the array is empty. + * @returns The method `popLast()` returns the last element of the `_nodes` array, or `null` if the array is empty. */ - pollLast(): E | null { + popLast(): E | null { return this._nodes.pop() ?? null; } /** - * The `pollFirst` function removes and returns the first element from an array, or returns null if the array is empty. - * @returns The `pollFirst()` function returns the first element of the `_nodes` array, or `null` if the array is + * The `popFirst` function removes and returns the first element from an array, or returns null if the array is empty. + * @returns The `popFirst()` function returns the first element of the `_nodes` array, or `null` if the array is * empty. */ - pollFirst(): E | null { + popFirst(): E | null { return this._nodes.shift() ?? null; } @@ -219,19 +219,19 @@ export class ArrayDeque { } /** - * The `peekFirst` function returns the first element of an array or null if the array is empty. - * @returns The function `peekFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is + * The `getFirst` function returns the first element of an array or null if the array is empty. + * @returns The function `getFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is * empty, it will return `null`. */ - peekFirst(): E | null { + getFirst(): E | null { return this._nodes[0] ?? null; } /** - * The `peekLast` function returns the last element of an array or null if the array is empty. - * @returns The method `peekLast()` returns the last element of the `_nodes` array, or `null` if the array is empty. + * The `getLast` function returns the last element of an array or null if the array is empty. + * @returns The method `getLast()` returns the last element of the `_nodes` array, or `null` if the array is empty. */ - peekLast(): E | null { + getLast(): E | null { return this._nodes[this._nodes.length - 1] ?? null; } diff --git a/src/data-structures/queue/queue.ts b/src/data-structures/queue/queue.ts index 4549b31..0f9e1a2 100644 --- a/src/data-structures/queue/queue.ts +++ b/src/data-structures/queue/queue.ts @@ -123,11 +123,11 @@ export class Queue { } /** - * The `peekLast` function returns the last element in an array-like data structure, or null if the structure is empty. - * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the + * The `getLast` function returns the last element in an array-like data structure, or null if the structure is empty. + * @returns The method `getLast()` returns the last element of the `_nodes` array if the array is not empty. If the * array is empty, it returns `null`. */ - peekLast(): E | undefined { + getLast(): E | undefined { return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined; } diff --git a/test/unit/data-structures/linked-list/doubly-linked-list.test.ts b/test/unit/data-structures/linked-list/doubly-linked-list.test.ts index eab2ad5..c20880a 100644 --- a/test/unit/data-structures/linked-list/doubly-linked-list.test.ts +++ b/test/unit/data-structures/linked-list/doubly-linked-list.test.ts @@ -109,7 +109,7 @@ describe('DoublyLinkedList Operation Test', () => { list.reverse(); expect(list.toArray()).toEqual([3, 2, 1]); - expect(list.toArrayReverse()).toEqual([1, 2, 3]); + expect(list.toArrayBackward()).toEqual([1, 2, 3]); }); it('should map elements using a callback function', () => { @@ -189,7 +189,7 @@ describe('DoublyLinkedList Operation Test', () => { list.push(3); list.push(4); - const lastEven = list.findLast(val => val % 2 === 0); + const lastEven = list.findBackward(val => val % 2 === 0); expect(lastEven).toBe(4); }); @@ -211,7 +211,7 @@ describe('DoublyLinkedList Operation Test', () => { list.push(2); list.push(3); - const reversedArray = list.toArrayReverse(); + const reversedArray = list.toArrayBackward(); expect(reversedArray).toEqual([3, 2, 1]); }); @@ -327,8 +327,8 @@ describe('DoublyLinkedList Operation Test', () => { const insertSuccess = objectList.insertBefore(obj2, newObj); expect(insertSuccess).toBe(true); - const findNode = objectList.findNode(newObj); // Use newObj instead of obj2 - expect(findNode?.val).toEqual(newObj); + const getNode = objectList.getNode(newObj); // Use newObj instead of obj2 + expect(getNode?.val).toEqual(newObj); const deleted = objectList.delete(newObj); // Use newObj instead of obj2 expect(deleted).toBe(true); diff --git a/test/unit/data-structures/linked-list/linked-list.test.ts b/test/unit/data-structures/linked-list/linked-list.test.ts index d7178f1..91b27fc 100644 --- a/test/unit/data-structures/linked-list/linked-list.test.ts +++ b/test/unit/data-structures/linked-list/linked-list.test.ts @@ -11,7 +11,7 @@ describe('LinkedList Performance Test', () => { for (let i = 0; i < magnitude.SQUARED; i++) { doublyList.push(i); if (i === midIndex) { - midNode = doublyList.findNode(i); + midNode = doublyList.getNode(i); } else if (i > midIndex && midNode) { doublyList.insertBefore(midNode, i); } @@ -24,7 +24,7 @@ describe('LinkedList Performance Test', () => { for (let i = 0; i < magnitude.SQUARED; i++) { singlyList.push(i); if (i === midIndex) { - midSinglyNode = singlyList.findNode(i); + midSinglyNode = singlyList.getNode(i); } else if (i > midIndex && midSinglyNode) { singlyList.insertBefore(midSinglyNode.val, i); } diff --git a/test/unit/data-structures/linked-list/singly-linked-list.test.ts b/test/unit/data-structures/linked-list/singly-linked-list.test.ts index 108f9ec..2c4cbe3 100644 --- a/test/unit/data-structures/linked-list/singly-linked-list.test.ts +++ b/test/unit/data-structures/linked-list/singly-linked-list.test.ts @@ -362,8 +362,8 @@ describe('SinglyLinkedList Operation Test', () => { const insertSuccess = objectList.insertBefore(obj2, newObj); expect(insertSuccess).toBe(true); - const findNode = objectList.findNode(newObj); // Use newObj instead of obj2 - expect(findNode?.val).toEqual(newObj); + const getNode = objectList.getNode(newObj); // Use newObj instead of obj2 + expect(getNode?.val).toEqual(newObj); const deleted = objectList.delete(newObj); // Use newObj instead of obj2 expect(deleted).toBe(true); diff --git a/test/unit/data-structures/queue/deque.test.ts b/test/unit/data-structures/queue/deque.test.ts index bc89ebf..e8cd139 100644 --- a/test/unit/data-structures/queue/deque.test.ts +++ b/test/unit/data-structures/queue/deque.test.ts @@ -15,20 +15,20 @@ describe('Deque Tests', () => { it('should add elements at the beginning and end', () => { deque.addFirst(1); deque.addLast(2); - expect(deque.peekFirst()).toBe(1); - expect(deque.peekLast()).toBe(2); + expect(deque.getFirst()).toBe(1); + expect(deque.getLast()).toBe(2); }); it('should delete elements from the beginning and end', () => { deque.addFirst(1); deque.addLast(2); - deque.pollFirst(); - deque.pollLast(); + deque.popFirst(); + deque.popLast(); expect(deque.isEmpty()).toBe(true); }); it('should handle edge case when removing from an empty deque', () => { - const result = deque.pollFirst(); + const result = deque.popFirst(); expect(result).toBeUndefined(); }); @@ -40,18 +40,18 @@ describe('Deque Tests', () => { it('should handle adding and removing elements alternately', () => { deque.addFirst(1); - expect(deque.pollFirst()).toBe(1); + expect(deque.popFirst()).toBe(1); deque.addLast(2); - expect(deque.pollLast()).toBe(2); + expect(deque.popLast()).toBe(2); expect(deque.isEmpty()).toBe(true); }); it('should handle adding and removing elements in a cyclic manner', () => { deque.addFirst(1); deque.addLast(2); - expect(deque.pollFirst()).toBe(1); + expect(deque.popFirst()).toBe(1); deque.addFirst(3); - expect(deque.pollLast()).toBe(2); + expect(deque.popLast()).toBe(2); expect(deque.size).toBe(1); }); // Add more test cases as needed @@ -68,20 +68,20 @@ describe('Deque Tests', () => { it('should add elements at the beginning and end', () => { objectDeque.addFirst('one'); objectDeque.addLast('two'); - expect(objectDeque.peekFirst()).toBe('one'); - expect(objectDeque.peekLast()).toBe('two'); + expect(objectDeque.getFirst()).toBe('one'); + expect(objectDeque.getLast()).toBe('two'); }); it('should delete elements from the beginning and end', () => { objectDeque.addFirst('one'); objectDeque.addLast('two'); - objectDeque.pollFirst(); - objectDeque.pollLast(); + objectDeque.popFirst(); + objectDeque.popLast(); expect(objectDeque.isEmpty()).toBe(true); }); it('should handle edge case when removing from an empty deque', () => { - const result = objectDeque.pollFirst(); + const result = objectDeque.popFirst(); expect(result).toBeUndefined(); }); @@ -105,20 +105,20 @@ describe('Deque Tests', () => { it('should add elements at the beginning and end', () => { arrayDeque.addFirst(1); arrayDeque.addLast(2); - expect(arrayDeque.peekFirst()).toBe(1); - expect(arrayDeque.peekLast()).toBe(2); + expect(arrayDeque.getFirst()).toBe(1); + expect(arrayDeque.getLast()).toBe(2); }); it('should delete elements from the beginning and end', () => { arrayDeque.addFirst(1); arrayDeque.addLast(2); - arrayDeque.pollFirst(); - arrayDeque.pollLast(); + arrayDeque.popFirst(); + arrayDeque.popLast(); expect(arrayDeque.isEmpty()).toBe(true); }); it('should handle edge case when removing from an empty deque', () => { - const result = arrayDeque.pollFirst(); + const result = arrayDeque.popFirst(); expect(result).toBeNull(); }); @@ -165,16 +165,16 @@ describe('Deque', () => { deque.addLast(2); expect(deque.size).toBe(2); - expect(deque.peekFirst()).toBe(1); - expect(deque.peekLast()).toBe(2); + expect(deque.getFirst()).toBe(1); + expect(deque.getLast()).toBe(2); }); test('should remove elements from the front and back', () => { deque.addFirst(1); deque.addLast(2); - const firstElement = deque.pollFirst(); - const lastElement = deque.pollLast(); + const firstElement = deque.popFirst(); + const lastElement = deque.popLast(); expect(deque.size).toBe(0); expect(firstElement).toBe(1); @@ -203,7 +203,7 @@ describe('Deque', () => { deque.addLast(1); expect(deque.isEmpty()).toBe(false); - deque.pollFirst(); + deque.popFirst(); expect(deque.isEmpty()).toBe(true); }); }); @@ -225,16 +225,16 @@ describe('ArrayDeque', () => { deque.addLast(2); expect(deque.size).toBe(2); - expect(deque.peekFirst()).toBe(1); - expect(deque.peekLast()).toBe(2); + expect(deque.getFirst()).toBe(1); + expect(deque.getLast()).toBe(2); }); test('should remove elements from the front and back', () => { deque.addFirst(1); deque.addLast(2); - const firstElement = deque.pollFirst(); - const lastElement = deque.pollLast(); + const firstElement = deque.popFirst(); + const lastElement = deque.popLast(); expect(deque.size).toBe(0); expect(firstElement).toBe(1); @@ -263,7 +263,7 @@ describe('ArrayDeque', () => { deque.addLast(1); expect(deque.isEmpty()).toBe(false); - deque.pollFirst(); + deque.popFirst(); expect(deque.isEmpty()).toBe(true); }); @@ -319,8 +319,8 @@ describe('ObjectDeque', () => { deque.addFirst(2); expect(deque.size).toBe(2); - expect(deque.peekFirst()).toBe(2); - expect(deque.peekLast()).toBe(1); + expect(deque.getFirst()).toBe(2); + expect(deque.getLast()).toBe(1); }); test('should add elements to the end of the deque', () => { @@ -328,37 +328,37 @@ describe('ObjectDeque', () => { deque.addLast(2); expect(deque.size).toBe(2); - expect(deque.peekFirst()).toBe(1); - expect(deque.peekLast()).toBe(2); + expect(deque.getFirst()).toBe(1); + expect(deque.getLast()).toBe(2); }); test('should remove elements from the front of the deque', () => { deque.addLast(1); deque.addLast(2); - const removedElement = deque.pollFirst(); + const removedElement = deque.popFirst(); expect(deque.size).toBe(1); expect(removedElement).toBe(1); - expect(deque.peekFirst()).toBe(2); + expect(deque.getFirst()).toBe(2); }); test('should remove elements from the end of the deque', () => { deque.addLast(1); deque.addLast(2); - const removedElement = deque.pollFirst(); + const removedElement = deque.popFirst(); expect(deque.size).toBe(1); expect(removedElement).toBe(1); - expect(deque.peekLast()).toBe(2); + expect(deque.getLast()).toBe(2); }); test('should return the element at the front of the deque without removing it', () => { deque.addFirst(1); deque.addFirst(2); - expect(deque.peekFirst()).toBe(2); + expect(deque.getFirst()).toBe(2); expect(deque.size).toBe(2); }); @@ -366,7 +366,7 @@ describe('ObjectDeque', () => { deque.addLast(1); deque.addLast(2); - expect(deque.peekLast()).toBe(2); + expect(deque.getLast()).toBe(2); expect(deque.size).toBe(2); }); @@ -391,9 +391,9 @@ describe('ObjectDeque', () => { deque.addLast(2); deque.addLast(3); - expect(deque.peekFirst()).toBe(1); + expect(deque.getFirst()).toBe(1); expect(deque.get(1)).toBe(2); - expect(deque.peekLast()).toBe(3); + expect(deque.getLast()).toBe(3); }); test('should insert elements at a specific index', () => { @@ -402,9 +402,9 @@ describe('ObjectDeque', () => { deque.addLast(3); expect(deque.size).toBe(3); - expect(deque.peekFirst()).toBe(1); + expect(deque.getFirst()).toBe(1); expect(deque.get(1)).toBe(2); expect(deque.get(2)).toBe(3); - expect(deque.peekLast()).toBe(3); + expect(deque.getLast()).toBe(3); }); }); diff --git a/test/unit/data-structures/queue/queue.test.ts b/test/unit/data-structures/queue/queue.test.ts index a32e811..9e2a263 100644 --- a/test/unit/data-structures/queue/queue.test.ts +++ b/test/unit/data-structures/queue/queue.test.ts @@ -86,7 +86,7 @@ describe('Queue', () => { queue.push(2); expect(queue.size).toBe(2); expect(queue.peek()).toBe(1); - expect(queue.peekLast()).toBe(2); + expect(queue.getLast()).toBe(2); }); it('should shift elements from the front of the queue', () => { @@ -96,7 +96,7 @@ describe('Queue', () => { expect(shifted).toBe(1); expect(queue.size).toBe(1); expect(queue.peek()).toBe(2); - expect(queue.peekLast()).toBe(2); + expect(queue.getLast()).toBe(2); }); it('should handle shifting when queue reaches half size', () => { @@ -117,7 +117,7 @@ describe('Queue', () => { queue.push(1); queue.push(2); expect(queue.peek()).toBe(1); - expect(queue.peekLast()).toBe(2); + expect(queue.getLast()).toBe(2); }); it('should handle shifting when the queue is empty', () => { @@ -129,7 +129,7 @@ describe('Queue', () => { it('should handle peeking when the queue is empty', () => { expect(queue.peek()).toBeUndefined(); - expect(queue.peekLast()).toBeUndefined(); + expect(queue.getLast()).toBeUndefined(); }); it('should handle clearing the queue', () => { @@ -139,7 +139,7 @@ describe('Queue', () => { queue.clear(); expect(queue.size).toBe(0); expect(queue.peek()).toBeUndefined(); - expect(queue.peekLast()).toBeUndefined(); + expect(queue.getLast()).toBeUndefined(); }); it('should clone the queue', () => { @@ -149,7 +149,7 @@ describe('Queue', () => { const clonedQueue = queue.clone(); expect(clonedQueue.size).toBe(3); expect(clonedQueue.peek()).toBe(1); - expect(clonedQueue.peekLast()).toBe(3); + expect(clonedQueue.getLast()).toBe(3); }); it('should handle creating a queue from an array', () => { @@ -157,7 +157,7 @@ describe('Queue', () => { const newQueue = Queue.fromArray(elements); expect(newQueue.size).toBe(5); expect(newQueue.peek()).toBe(1); - expect(newQueue.peekLast()).toBe(5); + expect(newQueue.getLast()).toBe(5); }); it('should iterate through the queue', () => {