├── .gitignore ├── .vscode ├── launch.json └── settings.json ├── LICENSE ├── README.md ├── blockChain ├── blockChain.bundle.js ├── blockChain.ts ├── blockNode.ts ├── generators.ts ├── helper.d.ts ├── readme.md └── test.ts ├── deploy.sh ├── hashTable ├── generators.ts ├── hashFunction.ts ├── hashNode.ts ├── hashTable.bundle.js ├── hashTable.ts ├── helper.d.ts ├── readme.md └── test.ts ├── linkedList ├── doubly │ ├── doublyLinkedList.bundle.js │ ├── doublyLinkedList.ts │ ├── doublyNode.ts │ ├── generators.ts │ ├── helper.d.ts │ ├── readme.md │ └── test.ts └── singly │ ├── generators.ts │ ├── helper.d.ts │ ├── readme.md │ ├── singlyLinkedList.bundle.js │ ├── singlyLinkedList.ts │ ├── singlyNode.ts │ └── test.ts ├── mod.js ├── mod.ts ├── queue ├── generators.ts ├── helper.d.ts ├── queue.bundle.js ├── queue.ts ├── queueNode.ts ├── readme.md └── test.ts └── stack ├── generators.ts ├── helper.d.ts ├── readme.md ├── stack.bundle.js ├── stack.ts ├── stackNode.ts └── test.ts /.gitignore: -------------------------------------------------------------------------------- 1 | # Logs 2 | logs 3 | *.log 4 | npm-debug.log* 5 | yarn-debug.log* 6 | yarn-error.log* 7 | lerna-debug.log* 8 | 9 | # Diagnostic reports (https://nodejs.org/api/report.html) 10 | report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json 11 | 12 | # Runtime data 13 | pids 14 | *.pid 15 | *.seed 16 | *.pid.lock 17 | 18 | # Directory for instrumented libs generated by jscoverage/JSCover 19 | lib-cov 20 | 21 | # Coverage directory used by tools like istanbul 22 | coverage 23 | *.lcov 24 | 25 | # nyc test coverage 26 | .nyc_output 27 | 28 | # Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files) 29 | .grunt 30 | 31 | # Bower dependency directory (https://bower.io/) 32 | bower_components 33 | 34 | # node-waf configuration 35 | .lock-wscript 36 | 37 | # Compiled binary addons (https://nodejs.org/api/addons.html) 38 | build/Release 39 | 40 | # Dependency directories 41 | node_modules/ 42 | jspm_packages/ 43 | 44 | # TypeScript v1 declaration files 45 | typings/ 46 | 47 | # TypeScript cache 48 | *.tsbuildinfo 49 | 50 | # Optional npm cache directory 51 | .npm 52 | 53 | # Optional eslint cache 54 | .eslintcache 55 | 56 | # Microbundle cache 57 | .rpt2_cache/ 58 | .rts2_cache_cjs/ 59 | .rts2_cache_es/ 60 | .rts2_cache_umd/ 61 | 62 | # Optional REPL history 63 | .node_repl_history 64 | 65 | # Output of 'npm pack' 66 | *.tgz 67 | 68 | # Yarn Integrity file 69 | .yarn-integrity 70 | 71 | # dotenv environment variables file 72 | .env 73 | .env.test 74 | 75 | # parcel-bundler cache (https://parceljs.org/) 76 | .cache 77 | 78 | # Next.js build output 79 | .next 80 | 81 | # Nuxt.js build / generate output 82 | .nuxt 83 | dist 84 | 85 | # Gatsby files 86 | .cache/ 87 | # Comment in the public line in if your project uses Gatsby and *not* Next.js 88 | # https://nextjs.org/blog/next-9-1#public-directory-support 89 | # public 90 | 91 | # vuepress build output 92 | .vuepress/dist 93 | 94 | # Serverless directories 95 | .serverless/ 96 | 97 | # FuseBox cache 98 | .fusebox/ 99 | 100 | # DynamoDB Local files 101 | .dynamodb/ 102 | 103 | # TernJS port file 104 | .tern-port 105 | -------------------------------------------------------------------------------- /.vscode/launch.json: -------------------------------------------------------------------------------- 1 | { 2 | // Use IntelliSense to learn about possible attributes. 3 | // Hover to view descriptions of existing attributes. 4 | // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 5 | "version": "0.2.0", 6 | "configurations": [ 7 | { 8 | "name": "Data Structure Test", 9 | "type": "pwa-node", 10 | "request": "launch", 11 | // "program": "${workspaceFolder}/linkedList/dubbly/test.ts", 12 | "cwd": "${workspaceFolder}", 13 | "runtimeExecutable": "deno", 14 | "runtimeArgs": [ "run", "--inspect-brk", "-A", "${file}" ], 15 | "attachSimplePort": 9229 16 | } 17 | ] 18 | } -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "deno.enable": true 3 | } -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 Keramot UL Islam 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Data Structure 2 | 3 | Different Data Structures implementation API provided by this module. 4 | API available in TypeScript & JavaScript[ES6]. 5 |
6 | This library is also available as **[Deno Third party Module](https://deno.land/x/datastructure)** 7 |

8 | If you're already using this module in your Deno project, 9 | then run deno run -r projectName/fileName.ts for latest version. 10 |

11 | 12 |
13 | 14 | ## List of Data Structures: 15 | 16 | * Block Chain -- **[Documentation](https://deno.land/x/datastructure/blockChain#blockChain-api)** 17 | * Hash Table -- **[Documentation](https://deno.land/x/datastructure/hashTable#hash-table-api)** 18 | * Singly Linked List -- **[Documentation](https://deno.land/x/datastructure/linkedList/singly#singly-linked-list-api)** 19 | * Doubly Linked List -- **[Documentation](https://deno.land/x/datastructure/linkedList/doubly#doubly-linked-list-api)** 20 | * Stack -- **[Documentation](https://deno.land/x/datastructure/stack#stack-api)** 21 | * Queue -- **[Documentation](https://deno.land/x/datastructure/queue#queue-api)** 22 | 23 |
24 |
25 | . -------------------------------------------------------------------------------- /blockChain/blockChain.ts: -------------------------------------------------------------------------------- 1 | import { BlockChainApi, BlockType, DataType } from "./helper.d.ts"; 2 | import { searchGenerator, iteratorGenerator } from "./generators.ts" 3 | import { Block } from "./blockNode.ts"; 4 | 5 | export class BlockChain implements BlockChainApi { 6 | #chain: Array 7 | length: number 8 | 9 | constructor() { 10 | this.#chain = new Array() 11 | this.length = this.#chain.length 12 | } 13 | 14 | static createBlockChain() { 15 | return new this(); 16 | } 17 | 18 | createBlock(data: DataType) { 19 | const newBlock = new Block(data, this.#chain.length + 1) 20 | 21 | if (this.#chain.length === 0) { 22 | this.#chain.push(newBlock) 23 | this.length++ 24 | 25 | return true 26 | } 27 | 28 | if (this.#chain.length > 0) { 29 | const prevBlock = this.latestBlock() 30 | newBlock.prevHash = prevBlock!.hash 31 | this.#chain.push(newBlock) 32 | this.length++ 33 | 34 | return true 35 | } 36 | 37 | return false 38 | } 39 | 40 | search(key: null|string, index: null|number = null) { 41 | if (this.#chain.length === 0) { 42 | return false 43 | } 44 | 45 | if (key) { 46 | const iterator = searchGenerator(key, this.#chain) 47 | let iteratorNext = iterator.next() 48 | if (iteratorNext.value) { 49 | return iteratorNext.value 50 | } 51 | } 52 | 53 | if (index) { 54 | return this.#chain[index - 1] 55 | } 56 | 57 | return false; 58 | } 59 | 60 | latestBlock() { 61 | if (this.#chain.length <= 0) return false 62 | return this.#chain[this.#chain.length - 1] 63 | } 64 | 65 | iterator() { 66 | return iteratorGenerator(this.#chain) 67 | } 68 | 69 | checkValidation() { 70 | const iterator = this.iterator() 71 | let iteratNext = iterator.next() 72 | let prevHash: null|string = null 73 | let prevBlock: null|BlockType = null 74 | 75 | while (iteratNext.value) { 76 | const block = iteratNext.value 77 | const regeneratedHash = block.regenerateHash() 78 | if (block.hash !== regeneratedHash) { 79 | console.error(`index: ${block.index}, block is corrupted`) 80 | return false 81 | } 82 | if (prevBlock != null && block.prevHash !== prevHash) { 83 | console.error(`index: ${prevBlock!.index}, block is corrupted`) 84 | return false 85 | } 86 | 87 | prevHash = block.regenerateHash() 88 | prevBlock = block 89 | iteratNext = iterator.next() 90 | } 91 | 92 | console.log('The Chain is valid.') 93 | return true 94 | } 95 | 96 | log(key: null|string = null, index: null|number = null) { 97 | if (key) { 98 | return console.log(this.search(key)) 99 | } 100 | 101 | if (index) { 102 | return console.log(this.#chain[index - 1]) 103 | } 104 | 105 | console.log(this.#chain) 106 | } 107 | 108 | } 109 | -------------------------------------------------------------------------------- /blockChain/blockNode.ts: -------------------------------------------------------------------------------- 1 | import { DataType, BlockType } from "./helper.d.ts"; 2 | import { createHash } from "https://deno.land/std/hash/mod.ts"; 3 | 4 | function blockHash(index: number, data: DataType, time: Date) { 5 | let hash = createHash("sha256") 6 | hash = hash.update(JSON.stringify(data) + index + time) 7 | 8 | return hash.toString(); 9 | } 10 | 11 | export class Block { 12 | index: number 13 | data: DataType 14 | hash: string 15 | prevHash: string|null 16 | time: Date 17 | 18 | constructor(data: DataType, index: number) { 19 | this.index = index 20 | this.data = data 21 | this.time = new Date() 22 | this.hash = blockHash(index, data, this.time) 23 | this.prevHash = null; 24 | } 25 | 26 | regenerateHash() { 27 | const data: DataType|any = this.data 28 | const hash = blockHash(this.index, data, this.time) 29 | 30 | return hash.toString(); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /blockChain/generators.ts: -------------------------------------------------------------------------------- 1 | export function *searchGenerator(key: string, chain: Array) { 2 | for (let block in chain) { 3 | if (chain[block].data.key === key) { 4 | yield chain[block] 5 | } 6 | } 7 | return false 8 | } 9 | 10 | export function *iteratorGenerator(chain: Array) { 11 | for (let block in chain) { 12 | yield chain[block] 13 | } 14 | return false 15 | } 16 | -------------------------------------------------------------------------------- /blockChain/helper.d.ts: -------------------------------------------------------------------------------- 1 | 2 | export type DataType = { 3 | key: string 4 | value: T 5 | } 6 | 7 | // BlockChain type of each block 8 | export type BlockType = { 9 | index: number 10 | data: DataType 11 | time: Date 12 | hash: string 13 | prevHash: null|string 14 | } 15 | 16 | // Block chain interface 17 | export interface BlockChainApi { 18 | length: number 19 | createBlock(data: DataType): boolean 20 | search(key: null|string, index: null|number): boolean|BlockType 21 | latestBlock(): boolean|BlockType 22 | log(key: null|string, index: null|number): void; 23 | iterator(): Generator 24 | checkValidation(): boolean 25 | } 26 | -------------------------------------------------------------------------------- /blockChain/readme.md: -------------------------------------------------------------------------------- 1 | ## BlockChain Api 2 |

sha256 has been used for creating Hashes.

3 | 4 | ```ts 5 | // Each block type 6 | type BlockType = { 7 | index: number 8 | data: DataType 9 | time: Date 10 | hash: string 11 | prevHash: null|string 12 | } 13 | 14 | // data type 15 | DataType = { 16 | key: string 17 | value: T 18 | } 19 | 20 | // static method that creates a instance of `BlockChain` class. 21 | BlockChain.createBlockChain() 22 | 23 | // Time Complexity: O(1) 24 | length: number; 25 | 26 | // *generator function, it returens an iterator. 27 | // loop through all blocks in the chain 28 | iterator(): Generator 29 | 30 | // Time Complexity: O(n) 31 | // check for "the blockChain is corrupted/manipulated or valid". 32 | checkValidation(): boolean 33 | 34 | // Time Complexity: O(1) 35 | createBlock(data: DataType): boolean 36 | 37 | // Time Complexity: O(1) 38 | latestBlock(): boolean|BlockType 39 | 40 | // Time Complexity: 41 | // log all: O(n) 42 | // log by key: O(n) 43 | // log by index: O(1) 44 | log(key: null|string = null, index: null|number = null): void; 45 | 46 | // Time Complexity: 47 | // search by key: O(n) 48 | // search by index: O(1) 49 | search(key: null|string, index: null|number = null): boolean|BlockType 50 | 51 | ``` 52 | 53 |
54 |
55 | 56 | ## Examples 57 | ```ts 58 | import { BlockChain } from "https://deno.land/x/datastructure/mod.ts"; 59 | 60 | const blockChain = BlockChain.createBlockChain() 61 | 62 | // iterator method returns a *generator function 63 | const iterator = blockChain.iterator() 64 | let iteratorNext = iterator.next() 65 | // console.log(iteratorNext.next(), iteratorNext.next()); 66 | while (iteratorNext.done === false) { 67 | console.log(iteratorNext.value); 68 | iteratorNext = iterator.next() 69 | } 70 | 71 | // length or count of total blocks. 72 | blockChain.length 73 | 74 | // create a new block in the blockChain. 75 | blockChain.createBlock({key: 'sourav', value: {name: "Sourav"}}) 76 | blockChain.createBlock({key: 'abm', value: "AbmSourav"}) 77 | blockChain.createBlock({key: 'JS', value: ['JS', 'TS']}) 78 | 79 | // get latest created block 80 | blockChain.latestBlock() 81 | 82 | // console all values 83 | blockChain.log() 84 | // console the block that has key: 'abm' 85 | blockChain.log('abm') 86 | // console then block which is index: 3 87 | blockChain.log(null, 3) 88 | 89 | // searching block by key 90 | blockChain.search('JS') 91 | // searching block by index 92 | blockChain.search(null, 2) 93 | 94 | ``` 95 | -------------------------------------------------------------------------------- /blockChain/test.ts: -------------------------------------------------------------------------------- 1 | import { BlockChain } from "./blockChain.ts"; 2 | // import { BlockChain } from "https://deno.land/x/datastructure/mod.ts"; 3 | 4 | const blockChain = BlockChain.createBlockChain() 5 | 6 | blockChain.createBlock({key: 'sourav', value: "Sourav"}) 7 | blockChain.createBlock({key: 'abm', value: "AbmSourav"}) 8 | blockChain.createBlock({key: 'apple', value: "Apple Inc."}) 9 | 10 | // const iterator = blockChain.iterator() 11 | // let iteratorNext = iterator.next() 12 | // console.log(iterator.next(), iterator.next()); 13 | // while (iteratorNext.done === false) { 14 | // console.log(iteratorNext.value); 15 | // iteratorNext = iterator.next() 16 | // } 17 | 18 | // console.log(blockChain.latestBlock()); 19 | 20 | // blockChain.latestBlock().data.key = '1' 21 | // console.log(blockChain.checkValidation()); 22 | 23 | blockChain.log(null, 3) 24 | // console.log(blockChain.search('sourav')) 25 | // console.log(blockChain.length) 26 | -------------------------------------------------------------------------------- /deploy.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | echo "Press 'Y' to start deployment" 4 | read confirmation 5 | 6 | if [ $confirmation != 'Y' ]; then 7 | echo "Exiting..." 8 | exit; 9 | fi 10 | 11 | echo "Deleting hidden settings..." 12 | vscode=".vscode" 13 | if [ -d $vscode ]; then 14 | rm -R $vscode; 15 | git add -A 16 | git commit -m "workspace settings removed" 17 | fi 18 | 19 | echo "Release Version: " 20 | read version 21 | 22 | echo "Release comments: " 23 | read comments 24 | echo "" 25 | 26 | echo "Creating git tag..." 27 | git tag $version -m "$comments" 28 | 29 | 30 | echo "Press Y to push new release" 31 | read pushNow 32 | if [ $pushNow == 'Y' ]; then 33 | git push origin $version 34 | exit; 35 | fi 36 | -------------------------------------------------------------------------------- /hashTable/generators.ts: -------------------------------------------------------------------------------- 1 | import { NodeType } from "./helper.d.ts"; 2 | 3 | export function *addGenerator(currentNode: NodeType, newNode: NodeType) { 4 | while (currentNode !== null) { 5 | if (currentNode.next === null) { 6 | currentNode.next = newNode 7 | yield true 8 | } 9 | 10 | currentNode = currentNode.next 11 | } 12 | return false 13 | } 14 | 15 | export function *removeGenerator(key: string, currentNode: NodeType) { 16 | let prevNode: NodeType = null 17 | while (currentNode !== null) { 18 | if (currentNode.data.key === key) { 19 | prevNode!.next = currentNode.next 20 | yield true 21 | } 22 | 23 | prevNode = currentNode 24 | currentNode = currentNode.next 25 | } 26 | return false 27 | } 28 | 29 | export function *iteratorGenerator(table: Array) { 30 | for (let key in table) { 31 | yield table[key] 32 | } 33 | return false 34 | } 35 | 36 | export function *updateGenerator(key: string, newValue: any, currentNode: NodeType) { 37 | while (currentNode !== null) { 38 | if (currentNode.data.key === key) { 39 | currentNode.data.value = newValue 40 | yield true 41 | } 42 | 43 | currentNode = currentNode.next 44 | } 45 | return false 46 | } 47 | 48 | export function *getGenerator(key: string, currentNode: NodeType) { 49 | while (currentNode !== null) { 50 | if (currentNode.data.key === key) { 51 | yield currentNode.data 52 | } 53 | 54 | currentNode = currentNode.next 55 | } 56 | return false 57 | } 58 | -------------------------------------------------------------------------------- /hashTable/hashFunction.ts: -------------------------------------------------------------------------------- 1 | export function hashFunction(str: string) { 2 | let hash = 17 3 | 4 | for (let i = 0; i < str.length; i++) { 5 | let newStr = str.charCodeAt(i) / 31 6 | hash = (13.11 * hash * newStr) / str.length 7 | } 8 | 9 | // weak hash function for testing 10 | // for (let i = 0; i < str.length; i++) { 11 | // // let newStr = str.charCodeAt(i) / 31 12 | // hash = (2 * hash) % str.length 13 | // } 14 | // console.log(hash); 15 | 16 | return hash; 17 | } 18 | -------------------------------------------------------------------------------- /hashTable/hashNode.ts: -------------------------------------------------------------------------------- 1 | import { NodeType, DataType } from "./helper.d.ts"; 2 | 3 | export class HashNode { 4 | public data: DataType 5 | public next: NodeType|null 6 | 7 | constructor(data: DataType) { 8 | this.data = data; 9 | this.next = null; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /hashTable/hashTable.bundle.js: -------------------------------------------------------------------------------- 1 | function hashFunction(str) { 2 | let hash = 17; 3 | for(let i = 0; i < str.length; i++){ 4 | let newStr = str.charCodeAt(i) / 31; 5 | hash = 13.11 * hash * newStr / str.length; 6 | } 7 | return hash; 8 | } 9 | class HashNode { 10 | data; 11 | next; 12 | constructor(data1){ 13 | this.data = data1; 14 | this.next = null; 15 | } 16 | } 17 | function* addGenerator(currentNode, newNode) { 18 | while(currentNode !== null){ 19 | if (currentNode.next === null) { 20 | currentNode.next = newNode; 21 | yield true; 22 | } 23 | currentNode = currentNode.next; 24 | } 25 | return false; 26 | } 27 | function* removeGenerator(key, currentNode) { 28 | let prevNode = null; 29 | while(currentNode !== null){ 30 | if (currentNode.data.key === key) { 31 | prevNode.next = currentNode.next; 32 | yield true; 33 | } 34 | prevNode = currentNode; 35 | currentNode = currentNode.next; 36 | } 37 | return false; 38 | } 39 | function* iteratorGenerator(table) { 40 | for(let key in table){ 41 | yield table[key]; 42 | } 43 | return false; 44 | } 45 | function* updateGenerator(key, newValue, currentNode) { 46 | while(currentNode !== null){ 47 | if (currentNode.data.key === key) { 48 | currentNode.data.value = newValue; 49 | yield true; 50 | } 51 | currentNode = currentNode.next; 52 | } 53 | return false; 54 | } 55 | function* getGenerator(key, currentNode) { 56 | while(currentNode !== null){ 57 | if (currentNode.data.key === key) { 58 | yield currentNode.data; 59 | } 60 | currentNode = currentNode.next; 61 | } 62 | return false; 63 | } 64 | class HashTable1 { 65 | #table; 66 | length; 67 | constructor(){ 68 | this.#table = new Array(); 69 | this.length = 0; 70 | } 71 | static createHT() { 72 | return new this(); 73 | } 74 | add(data) { 75 | const index = hashFunction(data.key); 76 | const node = new HashNode(data); 77 | if (this.#table[index] === undefined) { 78 | this.#table[index] = node; 79 | this.length++; 80 | return true; 81 | } 82 | if (this.#table[index].next === null) { 83 | this.#table[index].next = node; 84 | return true; 85 | } 86 | let currentNode = this.#table[index].next; 87 | const iterator = addGenerator(currentNode, node); 88 | const iteratorNext = iterator.next(); 89 | if (iteratorNext.value) { 90 | return true; 91 | } 92 | return false; 93 | } 94 | remove(key) { 95 | let index = hashFunction(key); 96 | if (this.#table[index] === undefined) return false; 97 | if (this.#table[index].data.key === key) { 98 | delete this.#table[index]; 99 | this.length--; 100 | return true; 101 | } 102 | if (this.#table[index].next !== null) { 103 | let currentNode = this.#table[index]; 104 | const iterator = removeGenerator(key, currentNode); 105 | const iteratorNext = iterator.next(); 106 | if (iteratorNext.value) { 107 | return true; 108 | } 109 | } 110 | return false; 111 | } 112 | update(key, newValue) { 113 | let index = hashFunction(key); 114 | if (this.#table[index] === undefined) return false; 115 | if (this.#table[index].data.key === key) { 116 | this.#table[index].data.value = newValue; 117 | return this.#table[index].data.value; 118 | } 119 | if (this.#table[index].next !== null) { 120 | let currentNode = this.#table[index]; 121 | const iterator = updateGenerator(key, newValue, currentNode); 122 | const iteratorNext = iterator.next(); 123 | if (iteratorNext.value) { 124 | return true; 125 | } 126 | } 127 | return false; 128 | } 129 | get(key) { 130 | let index = hashFunction(key); 131 | if (this.#table[index] === undefined) return false; 132 | if (this.#table[index].data.key === key) { 133 | return this.#table[index].data; 134 | } 135 | if (this.#table[index].next !== null) { 136 | let currentNode = this.#table[index]; 137 | const iterator = getGenerator(key, currentNode); 138 | const iteratorNext = iterator.next(); 139 | if (iteratorNext.value) { 140 | return iteratorNext.value; 141 | } 142 | } 143 | return false; 144 | } 145 | log(key) { 146 | if (this.length <= 0) return false; 147 | if (key) { 148 | let index = hashFunction(key); 149 | if (this.#table[index].data.key === key) { 150 | return console.log(this.#table[index]); 151 | } 152 | if (this.#table[index] && this.#table[index].next) { 153 | let currentNode = this.#table[index].next; 154 | while(currentNode){ 155 | if (currentNode.data.key === key) { 156 | return console.log(currentNode); 157 | } 158 | currentNode = currentNode.next; 159 | } 160 | } 161 | } 162 | for(let cell in this.#table){ 163 | console.log(this.#table[cell]); 164 | } 165 | } 166 | iterator() { 167 | const iterator = iteratorGenerator(this.#table); 168 | return iterator; 169 | } 170 | } 171 | export { HashTable1 as HashTable }; 172 | -------------------------------------------------------------------------------- /hashTable/hashTable.ts: -------------------------------------------------------------------------------- 1 | import { HashTableApi, DataType } from "./helper.d.ts"; 2 | import { hashFunction } from "./hashFunction.ts"; 3 | import { HashNode } from "./hashNode.ts"; 4 | import { 5 | addGenerator, 6 | removeGenerator, 7 | updateGenerator, 8 | getGenerator, 9 | iteratorGenerator 10 | } from "./generators.ts"; 11 | 12 | 13 | export class HashTable implements HashTableApi { 14 | #table: Array 15 | public length: number 16 | 17 | constructor() { 18 | this.#table = new Array() 19 | this.length = 0 20 | } 21 | 22 | static createHT() { 23 | return new this(); 24 | } 25 | 26 | add(data: DataType) { 27 | const index = hashFunction(data.key) 28 | const node = new HashNode(data) 29 | 30 | if (this.#table[index] === undefined) { 31 | this.#table[index] = node 32 | this.length++ 33 | return true 34 | } 35 | if (this.#table[index].next === null) { 36 | this.#table[index].next = node 37 | return true 38 | } 39 | 40 | let currentNode = this.#table[index].next 41 | // generator function that returns an iterator 42 | const iterator = addGenerator(currentNode, node) 43 | const iteratorNext = iterator.next() 44 | if (iteratorNext.value) { 45 | return true 46 | } 47 | 48 | return false; 49 | } 50 | 51 | remove(key: string) { 52 | let index = hashFunction(key) 53 | if (this.#table[index] === undefined) return false 54 | 55 | if (this.#table[index].data.key === key) { 56 | delete this.#table[index] 57 | this.length-- 58 | return true; 59 | } 60 | 61 | if (this.#table[index].next !== null) { 62 | let currentNode = this.#table[index] 63 | // generator function that returns an iterator 64 | const iterator = removeGenerator(key, currentNode) 65 | const iteratorNext = iterator.next() 66 | if (iteratorNext.value) { 67 | return true 68 | } 69 | } 70 | 71 | return false 72 | } 73 | 74 | update(key: string, newValue: any) { 75 | let index = hashFunction(key) 76 | if (this.#table[index] === undefined) return false 77 | 78 | if (this.#table[index].data.key === key) { 79 | this.#table[index].data.value = newValue 80 | return this.#table[index].data.value; 81 | } 82 | 83 | if (this.#table[index].next !== null) { 84 | let currentNode = this.#table[index] 85 | // generator function that returns an iterator 86 | const iterator = updateGenerator(key, newValue, currentNode) 87 | const iteratorNext = iterator.next() 88 | if (iteratorNext.value) { 89 | return true 90 | } 91 | } 92 | 93 | return false 94 | } 95 | 96 | get(key: string) { 97 | let index = hashFunction(key) 98 | if (this.#table[index] === undefined) return false 99 | 100 | if (this.#table[index].data.key === key) { 101 | return this.#table[index].data; 102 | } 103 | 104 | if (this.#table[index].next !== null) { 105 | let currentNode = this.#table[index] 106 | // generator function that returns an iterator 107 | const iterator = getGenerator(key, currentNode) 108 | const iteratorNext = iterator.next() 109 | if (iteratorNext.value) { 110 | return iteratorNext.value 111 | } 112 | } 113 | 114 | return false 115 | } 116 | 117 | log(key?: string) { 118 | if (this.length <= 0) return false 119 | 120 | if (key) { 121 | let index = hashFunction(key) 122 | if (this.#table[index].data.key === key) { 123 | return console.log(this.#table[index]) 124 | } 125 | if (this.#table[index] && this.#table[index].next) { 126 | let currentNode = this.#table[index].next 127 | while (currentNode) { 128 | if (currentNode.data.key === key) { 129 | return console.log(currentNode) 130 | } 131 | 132 | currentNode = currentNode.next 133 | } 134 | } 135 | } 136 | 137 | for (let cell in this.#table) { 138 | console.log(this.#table[cell]) 139 | } 140 | } 141 | 142 | iterator() { 143 | // generator function that returns an iterator 144 | const iterator = iteratorGenerator(this.#table) 145 | return iterator 146 | } 147 | } 148 | -------------------------------------------------------------------------------- /hashTable/helper.d.ts: -------------------------------------------------------------------------------- 1 | 2 | // data type 3 | export type DataType = { 4 | key: string 5 | value: T 6 | } 7 | 8 | export type NodeType = { 9 | data: DataType 10 | next: null|NodeType 11 | }|null 12 | 13 | export interface HashTableApi { 14 | length: number 15 | add(data: DataType): boolean 16 | remove(key: string): boolean|any[] 17 | update(key: string, newValue: DataType): boolean|DataType 18 | get(key: string): boolean|DataType 19 | log(key?: string): void, 20 | iterator(): Generator 21 | } 22 | -------------------------------------------------------------------------------- /hashTable/readme.md: -------------------------------------------------------------------------------- 1 | ## Hash Table Api 2 | 3 | ```ts 4 | // data type 5 | DataType = { 6 | key: string 7 | value: T 8 | } 9 | 10 | // static method that creates a instance of `HashTable` class. 11 | HashTable.createHT() 12 | 13 | // Time Complexity: O(1) 14 | length: number 15 | 16 | // *generator function, it returens an iterator. 17 | iterator(): Generator 18 | 19 | // Time Complexity: 20 | // average cases: O(1) 21 | // worst case: O(n) 22 | add(data: DataType): boolean 23 | 24 | // Time Complexity: 25 | // average cases: O(1) 26 | // worst case: O(n) 27 | remove(key: string): boolean|any[] 28 | 29 | // Time Complexity: 30 | // average cases: O(1) 31 | // worst case: O(n) 32 | update(key: string, newValue: DataType): boolean|DataType 33 | 34 | // Time Complexity: 35 | // average cases: O(1) 36 | // worst case: O(n) 37 | get(key: string): boolean|DataType 38 | 39 | // Time Complexity: 40 | // log all items: O(n) 41 | // log by key: avg. O(1), worst: O(n) 42 | log(key?: string): void, 43 | ``` 44 | 45 |
46 |
47 | 48 | ## Example 49 | ```ts 50 | import { HashTable } from "https://deno.land/x/datastructure/mod.ts"; 51 | 52 | const hashTable = HashTable.createHT() 53 | 54 | // add element in the hash table 55 | // if hash keys are same, then it will create chaining with LinkedList 56 | hashTable.add({key: "abm", value: "Sourav"}) 57 | hashTable.add({key: "apple", value: {company: "Apple Inc"}}) 58 | hashTable.add({key: "arr", value: [1, 2, 3]}) 59 | 60 | // remove element from hastabel 61 | hashTable.remove("arr"); 62 | 63 | const iterator = hashTable.iterator() 64 | let iteratorNext = iterator.next() 65 | // console.log(iteratorNext.next(), iteratorNext.next()); 66 | while (iteratorNext.done === false) { 67 | console.log(iteratorNext.value); 68 | iteratorNext = iterator.next() 69 | } 70 | 71 | // get element from hash table 72 | hashTable.get('abm') 73 | 74 | // update element's data using the key 75 | hashTable.update('abm', {name: 'AbmSourav'}) 76 | 77 | // console all elements 78 | hashTable.log() 79 | // console element by key 80 | hashTable.log('abm') 81 | ``` 82 | -------------------------------------------------------------------------------- /hashTable/test.ts: -------------------------------------------------------------------------------- 1 | import { HashTable } from "./hashTable.ts" 2 | import { assert, assertEquals } from "https://deno.land/std/testing/asserts.ts"; 3 | 4 | const hashTable = HashTable.createHT() 5 | 6 | hashTable.add({key: "abm", value: "Sourav"}) 7 | hashTable.add({key: "bma", value: {company: "Apple LLC"}}) 8 | hashTable.add({key: "appl", value: {product: "iPhone"}}) 9 | hashTable.add({key: "microsoft", value: "MicroSoft"}) 10 | // hashTable.add({key: "Linux", value: "Ubuntu"}) 11 | // hashTable.add({key: "ChromeOS", value: "Google"}) 12 | // console.log(hashTable.remove("microsoft")); 13 | 14 | // const it = hashTable.iterator() 15 | // console.log(it.next(), it.next(), it.next(), it.next()); 16 | 17 | // console.log(hashTable.update('bma', {name: 'Apple'})); 18 | // console.log(hashTable) 19 | 20 | hashTable.log() 21 | 22 | // Deno.test("Add", function() { 23 | // assertEquals(hashTable.add({key: "abm", value: "Sourav"}), true) 24 | // }) 25 | 26 | // Deno.test("remove", function() { 27 | // assertEquals(hashTable.remove("microsoft"), false); 28 | // }) 29 | -------------------------------------------------------------------------------- /linkedList/doubly/doublyLinkedList.bundle.js: -------------------------------------------------------------------------------- 1 | class DoublyNode { 2 | data; 3 | next; 4 | prev; 5 | constructor(data1){ 6 | this.data = data1; 7 | this.next = null; 8 | this.prev = null; 9 | } 10 | } 11 | function* addGenerator(currentNode, data1, position) { 12 | let count = 0; 13 | let prevNode = null; 14 | while(currentNode !== null){ 15 | if (count === position) { 16 | prevNode.next = new DoublyNode(data1); 17 | prevNode.next.next = currentNode; 18 | yield true; 19 | } 20 | prevNode = currentNode; 21 | currentNode = currentNode.next; 22 | count++; 23 | } 24 | return false; 25 | } 26 | function* updateGenerator(key, currentNode, newValue) { 27 | while(currentNode !== null){ 28 | if (currentNode.data.key === key) { 29 | currentNode.data.value = newValue; 30 | yield currentNode.data; 31 | } 32 | currentNode = currentNode.next; 33 | } 34 | return false; 35 | } 36 | function* searchGenerator(key, currentNode) { 37 | while(currentNode !== null){ 38 | if (currentNode.data.key === key) { 39 | yield currentNode.data; 40 | } 41 | currentNode = currentNode.next; 42 | } 43 | return false; 44 | } 45 | function* iteratorGenerator(currentNode) { 46 | while(currentNode !== null){ 47 | yield currentNode.data; 48 | currentNode = currentNode.next; 49 | } 50 | return false; 51 | } 52 | class DoublyLinkedList1 { 53 | #head; 54 | #tail; 55 | size; 56 | constructor(){ 57 | this.#head = null; 58 | this.#tail = null; 59 | this.size = 0; 60 | } 61 | static createDL() { 62 | return new this(); 63 | } 64 | prepend(data) { 65 | const newNode = new DoublyNode(data); 66 | if (this.#head === null) { 67 | this.#head = newNode; 68 | this.#tail = newNode; 69 | return true; 70 | } 71 | const currentNode = this.#head; 72 | this.#head = newNode; 73 | this.#head.next = currentNode; 74 | currentNode.prev = newNode; 75 | this.size++; 76 | return true; 77 | } 78 | append(data) { 79 | const newNode = new DoublyNode(data); 80 | if (this.#head === null) { 81 | this.#head = newNode; 82 | this.#tail = newNode; 83 | return true; 84 | } 85 | const currentNode = this.#tail; 86 | this.#tail.next = newNode; 87 | this.#tail = newNode; 88 | this.#tail.prev = currentNode; 89 | this.size++; 90 | return false; 91 | } 92 | add(data, position) { 93 | if (position === 0) { 94 | console.error("Use `prepend()` method to insert data at Head."); 95 | return false; 96 | } else if (position === this.size) { 97 | console.error("Use `append()` method to insert data at Tail."); 98 | return false; 99 | } else if (position > this.size && position != this.size + 1) { 100 | console.error(`Out of range. Size of the linkedList is ${this.size}`); 101 | return false; 102 | } 103 | const iterator = addGenerator(this.#head, data, position); 104 | const iteratorNext = iterator.next(); 105 | if (iteratorNext.value) { 106 | this.size++; 107 | return true; 108 | } 109 | return false; 110 | } 111 | getFromHead() { 112 | if (this.#head === null) { 113 | return false; 114 | } 115 | return this.#head.data; 116 | } 117 | getFromTail() { 118 | if (this.#tail === null) { 119 | return false; 120 | } 121 | return this.#tail.data; 122 | } 123 | log() { 124 | let currentNode = this.#head; 125 | while(currentNode !== null){ 126 | console.log(currentNode.data); 127 | currentNode = currentNode.next; 128 | } 129 | } 130 | remove(key) { 131 | if (this.#head === null) { 132 | return false; 133 | } 134 | if (this.#head.data.key === key) { 135 | const prevHeadData = this.#head.data; 136 | this.#head = this.#head.next; 137 | if (this.#head === null) this.#tail = this.#head; 138 | this.size--; 139 | if (this.#head === null) this.size = 0; 140 | return prevHeadData; 141 | } 142 | if (this.#tail.data.key === key) { 143 | const prevTailData = this.#tail.data; 144 | this.#tail = this.#tail.prev; 145 | this.#tail.next = null; 146 | return prevTailData; 147 | } 148 | let previousNode = null; 149 | let currentNode = this.#head; 150 | while(currentNode !== null){ 151 | if (key === currentNode.data.key) { 152 | const temp = currentNode.data; 153 | previousNode.next = currentNode.next; 154 | currentNode.next.prev = previousNode; 155 | if (currentNode.next === null) this.#tail = previousNode; 156 | this.size--; 157 | return temp; 158 | } 159 | previousNode = currentNode; 160 | currentNode = currentNode.next; 161 | } 162 | return false; 163 | } 164 | update(key, newValue) { 165 | if (this.#head === null) { 166 | return false; 167 | } 168 | if (this.#head.data.key === key) { 169 | this.#head.data.value = newValue; 170 | return this.#head.data; 171 | } 172 | if (this.#tail.data.key === key) { 173 | this.#tail.data.value = newValue; 174 | return this.#tail.data; 175 | } 176 | const iterator = updateGenerator(key, this.#head, newValue); 177 | const iteratorNext = iterator.next(); 178 | if (iteratorNext.value) { 179 | this.size++; 180 | return iteratorNext.value; 181 | } 182 | return false; 183 | } 184 | search(key) { 185 | if (this.#head === null) { 186 | return false; 187 | } 188 | if (this.#head.data.key === key) { 189 | return this.#head.data; 190 | } 191 | if (this.#tail.data.key === key) { 192 | return this.#tail.data; 193 | } 194 | const iterator = searchGenerator(key, this.#head); 195 | const iteratorNext = iterator.next(); 196 | if (iteratorNext.value) { 197 | this.size++; 198 | return iteratorNext.value; 199 | } 200 | return false; 201 | } 202 | iterator() { 203 | const iterator = iteratorGenerator(this.#head); 204 | return iterator; 205 | } 206 | } 207 | export { DoublyLinkedList1 as DoublyLinkedList }; 208 | -------------------------------------------------------------------------------- /linkedList/doubly/doublyLinkedList.ts: -------------------------------------------------------------------------------- 1 | import { LinkedListApi, NodeType, DataType } from "./helper.d.ts"; 2 | import { DoublyNode } from "./doublyNode.ts"; 3 | import { 4 | addGenerator, 5 | updateGenerator, 6 | searchGenerator, 7 | iteratorGenerator 8 | } from "./generators.ts" 9 | 10 | 11 | export class DoublyLinkedList implements LinkedListApi { 12 | #head: null|NodeType 13 | #tail: null|NodeType 14 | public size: number 15 | 16 | constructor() { 17 | this.#head = null 18 | this.#tail = null 19 | this.size = 0 20 | } 21 | 22 | static createDL() { 23 | return new this(); 24 | } 25 | 26 | // insert in the head 27 | prepend(data: DataType) { 28 | const newNode = new DoublyNode(data); 29 | if (this.#head === null) { 30 | this.#head = newNode 31 | this.#tail = newNode 32 | return true; 33 | } 34 | 35 | const currentNode = this.#head 36 | this.#head = newNode 37 | this.#head.next = currentNode 38 | currentNode.prev = newNode 39 | 40 | this.size++ 41 | return true; 42 | } 43 | 44 | // inset in the tail 45 | append(data: DataType) { 46 | const newNode = new DoublyNode(data); 47 | if (this.#head === null) { 48 | this.#head = newNode 49 | this.#tail = newNode 50 | return true; 51 | } 52 | 53 | const currentNode = this.#tail 54 | this.#tail!.next = newNode 55 | this.#tail = newNode 56 | this.#tail.prev = currentNode 57 | this.size++ 58 | 59 | return false; 60 | } 61 | 62 | // // add anywhere of the linked list except head & tail 63 | add(data: DataType, position: number) { 64 | if (position === 0) { 65 | console.error("Use `prepend()` method to insert data at Head."); 66 | return false; 67 | } else if (position === this.size) { 68 | console.error("Use `append()` method to insert data at Tail."); 69 | return false; 70 | } else if (position > this.size && position != this.size + 1) { 71 | console.error(`Out of range. Size of the linkedList is ${this.size}`); 72 | return false; 73 | } 74 | 75 | // generator function that returns an iterator 76 | const iterator = addGenerator(this.#head, data, position) 77 | const iteratorNext = iterator.next() 78 | if (iteratorNext.value) { 79 | this.size++ 80 | return true 81 | } 82 | 83 | return false; 84 | } 85 | 86 | getFromHead() { 87 | if (this.#head === null) { 88 | return false 89 | } 90 | 91 | return this.#head.data; 92 | } 93 | 94 | getFromTail() { 95 | if (this.#tail === null) { 96 | return false 97 | } 98 | 99 | return this.#tail.data 100 | } 101 | 102 | log() { 103 | let currentNode = this.#head 104 | while (currentNode !== null) { 105 | console.log(currentNode.data); 106 | currentNode = currentNode.next 107 | } 108 | } 109 | 110 | remove(key: string|number) { 111 | if (this.#head === null) { 112 | return false; 113 | } 114 | if (this.#head.data.key === key) { 115 | const prevHeadData = this.#head.data 116 | this.#head = this.#head.next 117 | if (this.#head === null) this.#tail = this.#head 118 | 119 | this.size-- 120 | if (this.#head === null) this.size = 0 121 | return prevHeadData; 122 | } 123 | if (this.#tail!.data.key === key) { 124 | const prevTailData = this.#tail!.data 125 | 126 | this.#tail = this.#tail!.prev 127 | this.#tail!.next = null 128 | return prevTailData; 129 | } 130 | 131 | // two pointer approach 132 | let previousNode: NodeType = null; 133 | let currentNode: NodeType = this.#head 134 | while (currentNode !== null) { 135 | if (key === currentNode.data.key) { 136 | const temp = currentNode.data 137 | previousNode!.next = currentNode.next 138 | currentNode.next!.prev = previousNode 139 | if (currentNode!.next === null) this.#tail = previousNode 140 | 141 | this.size-- 142 | return temp; 143 | } 144 | 145 | previousNode = currentNode 146 | currentNode = currentNode.next 147 | } 148 | 149 | return false; 150 | } 151 | 152 | update(key: string|number, newValue: any) { 153 | if (this.#head === null) { 154 | return false; 155 | } 156 | 157 | if (this.#head.data.key === key) { 158 | this.#head.data.value = newValue 159 | return this.#head.data; 160 | } 161 | if (this.#tail!.data.key === key) { 162 | this.#tail!.data.value = newValue 163 | return this.#tail!.data; 164 | } 165 | 166 | // generator function that returns an iterator 167 | const iterator = updateGenerator(key, this.#head, newValue) 168 | const iteratorNext = iterator.next() 169 | if (iteratorNext.value) { 170 | this.size++ 171 | return iteratorNext.value 172 | } 173 | 174 | return false; 175 | } 176 | 177 | search(key: string|number) { 178 | if (this.#head === null) { 179 | return false; 180 | } 181 | 182 | if (this.#head.data.key === key) { 183 | return this.#head.data; 184 | } 185 | if (this.#tail!.data.key === key) { 186 | return this.#tail!.data 187 | } 188 | 189 | // generator function that returns an iterator 190 | const iterator = searchGenerator(key, this.#head) 191 | const iteratorNext = iterator.next() 192 | if (iteratorNext.value) { 193 | this.size++ 194 | return iteratorNext.value 195 | } 196 | 197 | return false; 198 | } 199 | 200 | iterator() { 201 | // generator function that returns an iterator 202 | const iterator = iteratorGenerator(this.#head) 203 | return iterator 204 | } 205 | } 206 | -------------------------------------------------------------------------------- /linkedList/doubly/doublyNode.ts: -------------------------------------------------------------------------------- 1 | import { DataType, NodeType } from "./helper.d.ts"; 2 | 3 | export class DoublyNode { 4 | public data: DataType 5 | public next: NodeType|null 6 | public prev: NodeType|null 7 | 8 | constructor(data: DataType) { 9 | this.data = data; 10 | this.next = null; 11 | this.prev = null; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /linkedList/doubly/generators.ts: -------------------------------------------------------------------------------- 1 | import { NodeType, DataType } from "./helper.d.ts"; 2 | import { DoublyNode } from "./doublyNode.ts"; 3 | 4 | export function *addGenerator(currentNode: NodeType, data: DataType, position: number) { 5 | let count = 0 6 | let prevNode: NodeType = null; 7 | 8 | while (currentNode !== null) { 9 | if (count === position) { 10 | prevNode!.next = new DoublyNode(data) 11 | prevNode!.next.next = currentNode 12 | yield true 13 | } 14 | 15 | prevNode = currentNode 16 | currentNode = currentNode.next 17 | count++ 18 | } 19 | return false 20 | } 21 | 22 | export function *updateGenerator(key: string|number, currentNode: NodeType, newValue: any) { 23 | while (currentNode !== null) { 24 | if (currentNode.data.key === key) { 25 | currentNode.data.value = newValue 26 | yield currentNode.data; 27 | } 28 | 29 | currentNode = currentNode.next 30 | } 31 | return false 32 | } 33 | 34 | export function *searchGenerator(key: string|number, currentNode: NodeType) { 35 | while (currentNode !== null) { 36 | if (currentNode.data.key === key) { 37 | yield currentNode.data; 38 | } 39 | 40 | currentNode = currentNode.next 41 | } 42 | return false 43 | } 44 | 45 | export function *iteratorGenerator(currentNode: NodeType) { 46 | while (currentNode !== null) { 47 | yield currentNode.data; 48 | 49 | currentNode = currentNode.next 50 | } 51 | return false 52 | } 53 | -------------------------------------------------------------------------------- /linkedList/doubly/helper.d.ts: -------------------------------------------------------------------------------- 1 | 2 | // data type 3 | export type DataType = { 4 | key: string|number 5 | value: T 6 | } 7 | 8 | // singly linked list node class 9 | export type NodeType = { 10 | data: DataType 11 | next: null|NodeType 12 | prev: null|NodeType 13 | }|null 14 | 15 | // singly linked list interface 16 | export interface LinkedListApi { 17 | size: number; 18 | prepend(data: DataType): boolean; 19 | append(data: DataType): boolean; 20 | add(data: DataType, position: number): boolean; 21 | getFromHead(): object|false; 22 | getFromTail(): object|false; 23 | log(): void; 24 | remove(key: string|number): object|boolean; 25 | update(key: string|number, newValue: any): object|boolean; 26 | search(key: string|number): object|boolean 27 | iterator(): Generator 28 | } 29 | -------------------------------------------------------------------------------- /linkedList/doubly/readme.md: -------------------------------------------------------------------------------- 1 | ## Doubly Linked List Api 2 | 3 | ```ts 4 | DataType = { 5 | key: string|number 6 | value: T 7 | } 8 | 9 | // static method that creates a instance of `DoublyLinkedList` class. 10 | DoublyLinkedList.createDL() 11 | 12 | // Time Complexity: O(1) 13 | size: number; 14 | 15 | // *generator function, it returens an iterator. 16 | iterator(): Generator 17 | 18 | // Time Complexity: O(1) 19 | prepend(data: DataType): boolean; 20 | append(data: DataType): boolean; 21 | 22 | // Time Complexity: O(n) 23 | add(data: DataType, position: number): boolean; 24 | 25 | // Time Complexity: O(1) 26 | getFromHead(): object|false; 27 | 28 | // Time Complexity: O(1) 29 | getFromTail(): object|false; 30 | 31 | // Time Complexity: O(n) 32 | log(): void; 33 | 34 | // Time Complexity: 35 | // head node: O(1), other nodes: O(n) 36 | remove(key: string|number): object|boolean; 37 | 38 | // Time Complexity: 39 | // head node & tail: O(1), other nodes: O(n) 40 | update(key: string|number, newValue: any): object|boolean; 41 | 42 | // Time Complexity: 43 | // head node & tail node: O(1), other nodes: O(n) 44 | search(key: string|number): object|null 45 | ``` 46 | 47 |
48 |
49 | 50 | ## Examples 51 | ```ts 52 | import { DoublyLinkedList } from "https://deno.land/x/datastructure/mod.ts"; 53 | 54 | const doublyLinkedList = DoublyLinkedList.createDL() 55 | 56 | // iterator method returns a *generator function 57 | const iterator = doublyLinkedList.iterator() 58 | let iteratorNext = iterator.next() 59 | // console.log(iteratorNext.next(), iteratorNext.next()); 60 | while (iteratorNext.done === false) { 61 | console.log(iteratorNext.value); 62 | iteratorNext = iterator.next() 63 | } 64 | 65 | // get the size of the linked list 66 | doublyLinkedList.size 67 | 68 | // insert in the head 69 | doublyLinkedList.prepend({key: 'a', value: 'apple'}) 70 | doublyLinkedList.prepend({key: 'b', value: [1, 2, 3]}) 71 | doublyLinkedList.prepend({key: 11, value: {name: 'Sourav'}}) 72 | 73 | // insert in the tail 74 | doublyLinkedList.append({key: 'c', value: 'add to last'}) 75 | 76 | // insert anywhere except head & tail 77 | doublyLinkedList.add({key: 'x', value: 'X'}, 1) 78 | 79 | // get data from head or tail of linked list 80 | doublyLinkedList.getFromHead() 81 | doublyLinkedList.getFromTail() 82 | 83 | // console all values 84 | doublyLinkedList.log() 85 | 86 | // remove or delete data from linked list 87 | doublyLinkedList.remove('a') 88 | 89 | // update data in linked list 90 | doublyLinkedList.update('a', [1, 4, 8]) 91 | 92 | // search data in the linked list 93 | doublyLinkedList.search('Sourav') 94 | 95 | ``` 96 | -------------------------------------------------------------------------------- /linkedList/doubly/test.ts: -------------------------------------------------------------------------------- 1 | import { DoublyLinkedList } from "./doublyLinkedList.ts"; 2 | // import { DoublyLinkedList } from "https://deno.land/x/datastructure/mod.ts" 3 | 4 | const doublyLinkedList = DoublyLinkedList.createDL() 5 | 6 | doublyLinkedList.prepend({key: 'a', value: 'apple'}) 7 | doublyLinkedList.prepend({key: 'b', value: [1, 2, 3]}) 8 | // doublyLinkedList.prepend({key: 11, value: {val: 'add to head'}}) 9 | // doublyLinkedList.append({key: 'c', value: 'add before last'}) 10 | doublyLinkedList.append({key: 'd', value: 'add to last'}) 11 | // doublyLinkedList.add({key: 'x', value: 'X'}, 1) 12 | 13 | // console.log(doublyLinkedList.getFromHead()); 14 | // console.log(doublyLinkedList.getFromTail()); 15 | // console.log(doublyLinkedList.remove('c')); 16 | 17 | // console.log(doublyLinkedList.update('b', 'bbbb')); 18 | console.log(doublyLinkedList.search('b')); 19 | console.log(''); 20 | // console.log(doublyLinkedList) 21 | doublyLinkedList.log() 22 | 23 | // const it = doublyLinkedList.iterator() 24 | // let itNext = it.next() 25 | // console.log(it.next(), it.next(), it.next()); 26 | // while (itNext.done === false) { 27 | // console.log(itNext.value); 28 | // itNext = it.next() 29 | // } 30 | -------------------------------------------------------------------------------- /linkedList/singly/generators.ts: -------------------------------------------------------------------------------- 1 | import { NodeType, DataType } from "./helper.d.ts"; 2 | import { SinglyNode } from "./singlyNode.ts"; 3 | 4 | export function *addGenerator(currentNode: NodeType, data: DataType, position: number) { 5 | let count = 0 6 | let prevNode: NodeType = null; 7 | 8 | while (currentNode !== null) { 9 | if (count === position) { 10 | prevNode!.next = new SinglyNode(data) 11 | prevNode!.next.next = currentNode 12 | yield true 13 | } 14 | 15 | prevNode = currentNode 16 | currentNode = currentNode.next 17 | count++ 18 | } 19 | return false 20 | } 21 | 22 | export function *updateGenerator(key: string|number, currentNode: NodeType, newValue: any) { 23 | while (currentNode !== null) { 24 | if (currentNode.data.key === key) { 25 | currentNode.data.value = newValue 26 | yield currentNode.data; 27 | } 28 | 29 | currentNode = currentNode.next 30 | } 31 | return false 32 | } 33 | 34 | export function *searchGenerator(key: string|number, currentNode: NodeType) { 35 | while (currentNode !== null) { 36 | if (currentNode.data.key === key) { 37 | yield currentNode.data; 38 | } 39 | 40 | currentNode = currentNode.next 41 | } 42 | return false 43 | } 44 | 45 | export function *iteratorGenerator(currentNode: NodeType) { 46 | while (currentNode !== null) { 47 | yield currentNode.data; 48 | 49 | currentNode = currentNode.next 50 | } 51 | return false 52 | } 53 | -------------------------------------------------------------------------------- /linkedList/singly/helper.d.ts: -------------------------------------------------------------------------------- 1 | 2 | // data type 3 | export type DataType = { 4 | key: string|number 5 | value: T 6 | } 7 | 8 | // singly linked list node class 9 | export type NodeType = { 10 | data: DataType 11 | next: null|NodeType 12 | }|null 13 | 14 | // singly linked list interface 15 | export interface LinkedListApi { 16 | size: number; 17 | prepend(data: DataType): boolean; 18 | append(data: DataType): boolean; 19 | add(data: DataType, position: number): boolean; 20 | getFromHead(): object|false; 21 | getFromTail(): object|false; 22 | log(): void; 23 | remove(key: string|number): boolean; 24 | update(key: string|number, newValue: any): object|boolean; 25 | search(key: string|number): object|boolean 26 | iterator(): Generator 27 | } 28 | -------------------------------------------------------------------------------- /linkedList/singly/readme.md: -------------------------------------------------------------------------------- 1 | ## Singly Linked List Api 2 | 3 | ```ts 4 | DataType = { 5 | key: string|number 6 | value: T 7 | } 8 | 9 | // static method that creates a instance of `SinglyLinkedList` class. 10 | SinglyLinkedList.createSL() 11 | 12 | // Time Complexity: O(1) 13 | size: number; 14 | 15 | // *generator function, it returens an iterator. 16 | iterator(): Generator 17 | 18 | // Time Complexity: O(1) 19 | prepend(data: DataType): boolean; 20 | append(data: DataType): boolean; 21 | 22 | // Time Complexity: O(n) 23 | add(data: DataType, position: number): boolean; 24 | 25 | // Time Complexity: O(1) 26 | getFromHead(): object|false; 27 | 28 | // Time Complexity: O(1) 29 | getFromTail(): object|false; 30 | 31 | // Time Complexity: O(n) 32 | log(): void; 33 | 34 | // Time Complexity: 35 | // head node: O(1), other nodes: O(n) 36 | remove(key: string|number): object|boolean; 37 | 38 | // Time Complexity: 39 | // head & tail node: O(1), other nodes: O(n) 40 | update(key: string|number, newValue: any): object|boolean; 41 | 42 | // Time Complexity: 43 | // head node & tail node: O(1), other nodes: O(n) 44 | search(key: string|number): object|boolean 45 | ``` 46 | 47 |
48 |
49 | 50 | ## Examples 51 | ```ts 52 | import { SinglyLinkedList } from "https://deno.land/x/datastructure/mod.ts"; 53 | 54 | const singlyLinkedList = SinglyLinkedList.createSL() 55 | 56 | // iterator method returns a *generator function 57 | const iterator = singlyLinkedList.iterator() 58 | let iteratorNext = iterator.next() 59 | // console.log(iteratorNext.next(), iteratorNext.next()); 60 | while (iteratorNext.done === false) { 61 | console.log(iteratorNext.value); 62 | iteratorNext = iterator.next() 63 | } 64 | 65 | // linked list size 66 | singlyLinkedList.size 67 | 68 | // adding data at the head of linked list 69 | singlyLinkedList.prepend({key: 'a', value: 'apple'}) 70 | singlyLinkedList.prepend({key: 'b', value: [1, 2, 3]}) 71 | singlyLinkedList.prepend({key: 11, value: 'add to head'}) 72 | 73 | // adding data at the tail of linked list 74 | singlyLinkedList.append({key: 'c', value: 'add to last'}) 75 | 76 | // insert anywhere except head & tail 77 | singlyLinkedList.add({key: 'x', value: 'X'}, 1) 78 | 79 | // get data from head or tail 80 | singlyLinkedList.getFromHead() 81 | singlyLinkedList.getFromTail() 82 | 83 | // console all values 84 | singlyLinkedList.log() 85 | 86 | // remove or delete data from linked list 87 | singlyLinkedList.remove('a') 88 | 89 | // update data in linked list 90 | singlyLinkedList.update('a', [1, 4, 8]) 91 | 92 | // searching data in linked list 93 | singlyLinkedList.search('Sourav') 94 | 95 | ``` 96 | -------------------------------------------------------------------------------- /linkedList/singly/singlyLinkedList.bundle.js: -------------------------------------------------------------------------------- 1 | class SinglyNode { 2 | data; 3 | next; 4 | constructor(data1){ 5 | this.data = data1; 6 | this.next = null; 7 | } 8 | } 9 | function* addGenerator(currentNode, data1, position) { 10 | let count = 0; 11 | let prevNode = null; 12 | while(currentNode !== null){ 13 | if (count === position) { 14 | prevNode.next = new SinglyNode(data1); 15 | prevNode.next.next = currentNode; 16 | yield true; 17 | } 18 | prevNode = currentNode; 19 | currentNode = currentNode.next; 20 | count++; 21 | } 22 | return false; 23 | } 24 | function* updateGenerator(key, currentNode, newValue) { 25 | while(currentNode !== null){ 26 | if (currentNode.data.key === key) { 27 | currentNode.data.value = newValue; 28 | yield currentNode.data; 29 | } 30 | currentNode = currentNode.next; 31 | } 32 | return false; 33 | } 34 | function* searchGenerator(key, currentNode) { 35 | while(currentNode !== null){ 36 | if (currentNode.data.key === key) { 37 | yield currentNode.data; 38 | } 39 | currentNode = currentNode.next; 40 | } 41 | return false; 42 | } 43 | function* iteratorGenerator(currentNode) { 44 | while(currentNode !== null){ 45 | yield currentNode.data; 46 | currentNode = currentNode.next; 47 | } 48 | return false; 49 | } 50 | class SinglyLinkedList1 { 51 | #head; 52 | #tail; 53 | size; 54 | constructor(){ 55 | this.#head = null; 56 | this.#tail = null; 57 | this.size = 0; 58 | } 59 | static createSL() { 60 | return new this(); 61 | } 62 | prepend(data) { 63 | if (this.#head === null) { 64 | const newNode = new SinglyNode(data); 65 | this.#head = newNode; 66 | this.#tail = newNode; 67 | return true; 68 | } 69 | const currentNode = this.#head; 70 | this.#head = new SinglyNode(data); 71 | this.#head.next = currentNode; 72 | if (currentNode.next === null) { 73 | this.#tail = currentNode; 74 | } 75 | this.size++; 76 | return true; 77 | } 78 | append(data) { 79 | const newNode = new SinglyNode(data); 80 | if (this.#head === null) { 81 | this.#head = newNode; 82 | this.#tail = newNode; 83 | return true; 84 | } 85 | this.#tail.next = newNode; 86 | this.#tail = newNode; 87 | this.size++; 88 | return false; 89 | } 90 | add(data, position) { 91 | if (position === 0) { 92 | console.error("Use `prepend()` method to insert data at Head."); 93 | return false; 94 | } else if (position === this.size) { 95 | console.error("Use `append()` method to insert data at Tail."); 96 | return false; 97 | } else if (position > this.size && position != this.size + 1) { 98 | console.error(`Out of range. Size of the linkedList is ${this.size}`); 99 | return false; 100 | } 101 | let currentNode = this.#head; 102 | const iterator = addGenerator(currentNode, data, position); 103 | const iteratorNext = iterator.next(); 104 | if (iteratorNext.value) { 105 | this.size++; 106 | return true; 107 | } 108 | return false; 109 | } 110 | getFromHead() { 111 | if (this.#head === null) { 112 | return false; 113 | } 114 | return this.#head.data; 115 | } 116 | getFromTail() { 117 | if (this.#tail === null) { 118 | return false; 119 | } 120 | return this.#tail.data; 121 | } 122 | log() { 123 | let currentNode = this.#head; 124 | while(currentNode !== null){ 125 | console.log(currentNode.data); 126 | currentNode = currentNode.next; 127 | } 128 | } 129 | remove(key) { 130 | if (this.#head === null) { 131 | return false; 132 | } else if (this.#head.next === null) { 133 | this.#tail = null; 134 | } 135 | if (this.#head.data.key === key) { 136 | const prevHeadData = this.#head.data; 137 | this.#head = this.#head.next; 138 | if (this.#head.next === null) this.#tail = this.#head; 139 | this.size--; 140 | if (this.#head === null) this.size = 0; 141 | return true; 142 | } 143 | let previousNode = null; 144 | let currentNode = this.#head; 145 | while(currentNode !== null){ 146 | if (key === currentNode.data.key) { 147 | const temp = currentNode.data; 148 | previousNode.next = currentNode.next; 149 | if (currentNode.next === null) this.#tail = previousNode; 150 | this.size--; 151 | return true; 152 | } 153 | previousNode = currentNode; 154 | currentNode = currentNode.next; 155 | } 156 | return false; 157 | } 158 | update(key, newValue) { 159 | if (this.#head === null) { 160 | return false; 161 | } 162 | if (this.#head.data.key === key) { 163 | this.#head.data.value = newValue; 164 | return this.#head.data; 165 | } 166 | if (this.#tail.data.key === key) { 167 | this.#tail.data.value = newValue; 168 | return this.#tail.data; 169 | } 170 | let currentNode = this.#head.next; 171 | const iterator = updateGenerator(key, currentNode, newValue); 172 | const iteratorNext = iterator.next(); 173 | if (iteratorNext.value) { 174 | return iteratorNext.value; 175 | } 176 | return false; 177 | } 178 | search(key) { 179 | if (this.#head === null) { 180 | return false; 181 | } 182 | if (this.#head.data.key === key) { 183 | return this.#head.data; 184 | } 185 | if (this.#tail.data.key === key) { 186 | return this.#tail.data; 187 | } 188 | let currentNode = this.#head.next; 189 | const iterator = searchGenerator(key, currentNode); 190 | const iteratorNext = iterator.next(); 191 | if (iteratorNext.value) { 192 | return iteratorNext.value; 193 | } 194 | return false; 195 | } 196 | iterator() { 197 | const currentNode = this.#head; 198 | const iterator = iteratorGenerator(currentNode); 199 | return iterator; 200 | } 201 | } 202 | export { SinglyLinkedList1 as SinglyLinkedList }; 203 | -------------------------------------------------------------------------------- /linkedList/singly/singlyLinkedList.ts: -------------------------------------------------------------------------------- 1 | import { LinkedListApi, NodeType, DataType } from "./helper.d.ts"; 2 | import { SinglyNode } from "./singlyNode.ts"; 3 | import { 4 | addGenerator, 5 | updateGenerator, 6 | searchGenerator, 7 | iteratorGenerator 8 | } from "./generators.ts" 9 | 10 | export class SinglyLinkedList implements LinkedListApi { 11 | #head: null|NodeType 12 | #tail: null|NodeType 13 | public size: number 14 | 15 | constructor() { 16 | this.#head = null 17 | this.#tail = null 18 | this.size = 0 19 | } 20 | 21 | static createSL() { 22 | return new this(); 23 | } 24 | 25 | // insert in the head 26 | prepend(data: DataType) { 27 | if (this.#head === null) { 28 | const newNode = new SinglyNode(data); 29 | this.#head = newNode 30 | this.#tail = newNode 31 | return true; 32 | } 33 | 34 | const currentNode = this.#head 35 | this.#head = new SinglyNode(data) 36 | this.#head.next = currentNode 37 | if (currentNode.next === null) { 38 | this.#tail = currentNode 39 | } 40 | this.size++ 41 | 42 | return true; 43 | } 44 | 45 | // inset in the tail 46 | append(data: DataType) { 47 | const newNode = new SinglyNode(data); 48 | if (this.#head === null) { 49 | this.#head = newNode 50 | this.#tail = newNode 51 | return true; 52 | } 53 | 54 | this.#tail!.next = newNode 55 | this.#tail = newNode 56 | this.size++ 57 | 58 | return false; 59 | } 60 | 61 | // // add anywhere of the linked list except head & tail 62 | add(data: DataType, position: number) { 63 | if (position === 0) { 64 | console.error("Use `prepend()` method to insert data at Head."); 65 | return false; 66 | } else if (position === this.size) { 67 | console.error("Use `append()` method to insert data at Tail."); 68 | return false; 69 | } else if (position > this.size && position != this.size + 1) { 70 | console.error(`Out of range. Size of the linkedList is ${this.size}`); 71 | return false; 72 | } 73 | 74 | let currentNode = this.#head 75 | // generator function that returns an iterator 76 | const iterator = addGenerator(currentNode, data, position) 77 | const iteratorNext = iterator.next() 78 | if (iteratorNext.value) { 79 | this.size++ 80 | return true 81 | } 82 | 83 | return false; 84 | } 85 | 86 | getFromHead() { 87 | if (this.#head === null) { 88 | return false 89 | } 90 | 91 | return this.#head.data; 92 | } 93 | 94 | getFromTail() { 95 | if (this.#tail === null) { 96 | return false 97 | } 98 | 99 | return this.#tail.data 100 | } 101 | 102 | log() { 103 | let currentNode = this.#head 104 | while (currentNode !== null) { 105 | console.log(currentNode.data); 106 | currentNode = currentNode.next 107 | } 108 | } 109 | 110 | remove(key: string|number) { 111 | if (this.#head === null) { 112 | return false; 113 | } else if (this.#head!.next === null) { 114 | this.#tail = null 115 | } 116 | if (this.#head.data.key === key) { 117 | const prevHeadData = this.#head.data 118 | this.#head = this.#head.next 119 | if (this.#head!.next === null) this.#tail = this.#head 120 | 121 | this.size-- 122 | if (this.#head === null) this.size = 0 123 | return true; 124 | } 125 | 126 | // two pointer approach 127 | let previousNode: NodeType = null; 128 | let currentNode: NodeType = this.#head 129 | while (currentNode !== null) { 130 | if (key === currentNode.data.key) { 131 | const temp = currentNode.data 132 | previousNode!.next = currentNode.next 133 | if (currentNode!.next === null) this.#tail = previousNode 134 | 135 | this.size-- 136 | return true; 137 | } 138 | 139 | previousNode = currentNode 140 | currentNode = currentNode.next 141 | } 142 | 143 | return false; 144 | } 145 | 146 | update(key: string|number, newValue: any) { 147 | if (this.#head === null) { 148 | return false; 149 | } 150 | 151 | if (this.#head.data.key === key) { 152 | this.#head.data.value = newValue 153 | return this.#head.data; 154 | } 155 | if (this.#tail!.data.key === key) { 156 | this.#tail!.data.value = newValue 157 | return this.#tail!.data; 158 | } 159 | 160 | let currentNode = this.#head.next 161 | // generator function that returns an iterator 162 | const iterator = updateGenerator(key, currentNode, newValue) 163 | const iteratorNext = iterator.next() 164 | if (iteratorNext.value) { 165 | return iteratorNext.value 166 | } 167 | 168 | return false; 169 | } 170 | 171 | search(key: string|number) { 172 | if (this.#head === null) { 173 | return false; 174 | } 175 | 176 | if (this.#head.data.key === key) { 177 | return this.#head.data; 178 | } 179 | if (this.#tail!.data.key === key) { 180 | return this.#tail!.data 181 | } 182 | 183 | let currentNode = this.#head.next 184 | // generator function that returns an iterator 185 | const iterator = searchGenerator(key, currentNode) 186 | const iteratorNext = iterator.next() 187 | if (iteratorNext.value) { 188 | return iteratorNext.value 189 | } 190 | 191 | return false; 192 | } 193 | 194 | iterator() { 195 | const currentNode = this.#head 196 | // generator function that returns an iterator 197 | const iterator = iteratorGenerator(currentNode) 198 | return iterator 199 | } 200 | } 201 | -------------------------------------------------------------------------------- /linkedList/singly/singlyNode.ts: -------------------------------------------------------------------------------- 1 | import { NodeType, DataType } from "./helper.d.ts"; 2 | 3 | export class SinglyNode { 4 | public data: DataType 5 | public next: NodeType|null 6 | 7 | constructor(data: DataType) { 8 | this.data = data; 9 | this.next = null; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /linkedList/singly/test.ts: -------------------------------------------------------------------------------- 1 | import { SinglyLinkedList } from "./singlyLinkedList.ts"; 2 | // import { SinglyLinkedList } from "https://deno.land/x/datastructure/mod.ts" 3 | 4 | const singlyLinkedList = SinglyLinkedList.createSL() 5 | 6 | singlyLinkedList.prepend({key: 'a', value: 'apple'}) 7 | singlyLinkedList.prepend({key: 'b', value: [1, 2, 3]}) 8 | singlyLinkedList.prepend({key: 11, value: 'add to head'}) 9 | // singlyLinkedList.append({key: 'c', value: 'add to last'}) 10 | // singlyLinkedList.add({key: 'x', value: 'X'}, 1) 11 | // singlyLinkedList.add({key: 'x', value: 'X'}, 1) 12 | 13 | // console.log(singlyLinkedList.getFromHead()); 14 | // console.log(singlyLinkedList.getFromTail()); 15 | // console.log(singlyLinkedList.remove('c')); 16 | 17 | // console.log(singlyLinkedList.update('b', 'after head')); 18 | // console.log(singlyLinkedList.search('a')); 19 | 20 | // const it = singlyLinkedList.iterator() 21 | // let itNext = it.next() 22 | // console.log(it.next(), it.next(), it.next()); 23 | // while (itNext.done === false) { 24 | // console.log(itNext.value); 25 | // itNext = it.next() 26 | // } 27 | 28 | // console.log(singlyLinkedList); 29 | singlyLinkedList.log() 30 | -------------------------------------------------------------------------------- /mod.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Data Structure 3 | * 4 | * Different Data Structures implementation API provided by this module. 5 | * API available in TypeScript & JavaScript. 6 | * 7 | * @package dataStructure 8 | * @author Keramot UL Islam [Abm Sourav] 9 | * @email 10 | * @authorUrl https://abmsourav.com 11 | * @sourceCode https://github.com/AbmSourav/dataStructure 12 | * @version 1.2.1 13 | * 14 | * Copyright (c) 2021 Keramot UL Islam 15 | */ 16 | 17 | export { BlockChain } from "./blockChain/blockChain.bundle.js"; 18 | export { HashTable } from "./hashTable/hashTable.bundle.js"; 19 | export { SinglyLinkedList } from "./linkedList/singly/singlyLinkedList.bundle.js"; 20 | export { DoublyLinkedList } from "./linkedList/doubly/doublyLinkedList.bundle.js"; 21 | export { Stack } from "./stack/stack.bundle.js" 22 | export { Queue } from "./queue/queue.bundle.js" 23 | -------------------------------------------------------------------------------- /mod.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * Data Structure 3 | * 4 | * Different Data Structures implementation API provided by this module. 5 | * API available in TypeScript & JavaScript. 6 | * 7 | * @package dataStructure 8 | * @author Keramot UL Islam [Abm Sourav] 9 | * @email 10 | * @authorUrl https://abmsourav.com 11 | * @sourceCode https://github.com/AbmSourav/dataStructure 12 | * @version 1.2.1 13 | * 14 | * Copyright (c) 2021 Keramot UL Islam 15 | */ 16 | 17 | export { BlockChain } from "./blockChain/blockChain.ts"; 18 | export { HashTable } from "./hashTable/hashTable.ts"; 19 | export { SinglyLinkedList } from "./linkedList/singly/singlyLinkedList.ts"; 20 | export { DoublyLinkedList } from "./linkedList/doubly/doublyLinkedList.ts"; 21 | export { Stack } from "./stack/stack.ts" 22 | export { Queue } from "./queue/queue.ts" 23 | -------------------------------------------------------------------------------- /queue/generators.ts: -------------------------------------------------------------------------------- 1 | import { QueueType } from "./helper.d.ts"; 2 | 3 | export function *searchGenerator(key: string|number, currentNode: QueueType) { 4 | while (currentNode !== null) { 5 | if (key === currentNode.data.key) { 6 | return currentNode.data 7 | } 8 | currentNode = currentNode.next 9 | } 10 | return false 11 | } 12 | 13 | export function *updateGenerator(key: string|number, currentNode: QueueType, newValue: any) { 14 | while (currentNode !== null) { 15 | if (key === currentNode.data.key) { 16 | currentNode.data.value = newValue 17 | return currentNode.data 18 | } 19 | 20 | currentNode = currentNode.next 21 | } 22 | return false 23 | } 24 | 25 | export function *iteratorGenerator(currentNode: QueueType) { 26 | while (currentNode !== null) { 27 | yield currentNode.data; 28 | 29 | currentNode = currentNode.next 30 | } 31 | return false 32 | } 33 | -------------------------------------------------------------------------------- /queue/helper.d.ts: -------------------------------------------------------------------------------- 1 | // data type 2 | export type DataType = { 3 | key: string|number 4 | value: T 5 | } 6 | 7 | export type QueueType = { 8 | data: DataType 9 | next: null|QueueType 10 | }|null 11 | 12 | // Stack interface 13 | export interface QueueApi { 14 | size: number; 15 | getFront(): null|DataType 16 | getBack(): null|DataType 17 | enqueue(data: DataType): boolean 18 | dequeue(): boolean|DataType 19 | search(key: string|number): boolean|DataType 20 | update(key: string|number, newValue: any): boolean|DataType 21 | log(): void 22 | } 23 | -------------------------------------------------------------------------------- /queue/queue.bundle.js: -------------------------------------------------------------------------------- 1 | class QueueNode { 2 | data; 3 | next = null; 4 | constructor(data1){ 5 | this.data = data1; 6 | this.next = null; 7 | } 8 | } 9 | function* searchGenerator(key, currentNode) { 10 | while(currentNode !== null){ 11 | if (key === currentNode.data.key) { 12 | return currentNode.data; 13 | } 14 | currentNode = currentNode.next; 15 | } 16 | return false; 17 | } 18 | function* updateGenerator(key, currentNode, newValue) { 19 | while(currentNode !== null){ 20 | if (key === currentNode.data.key) { 21 | currentNode.data.value = newValue; 22 | return currentNode.data; 23 | } 24 | currentNode = currentNode.next; 25 | } 26 | return false; 27 | } 28 | function* iteratorGenerator(currentNode) { 29 | while(currentNode !== null){ 30 | yield currentNode.data; 31 | currentNode = currentNode.next; 32 | } 33 | return false; 34 | } 35 | class Queue1 { 36 | #frontNode; 37 | #backNode; 38 | size; 39 | constructor(){ 40 | this.#frontNode = null; 41 | this.#backNode = null; 42 | this.size = 0; 43 | } 44 | static createQueue() { 45 | return new this(); 46 | } 47 | getFront() { 48 | if (this.#frontNode === null) return null; 49 | return this.#frontNode.data; 50 | } 51 | getBack() { 52 | if (this.#frontNode === null) return null; 53 | return this.#backNode.data; 54 | } 55 | enqueue(data) { 56 | const newNode = new QueueNode(data); 57 | if (this.#frontNode === null) { 58 | this.#frontNode = newNode; 59 | this.#backNode = newNode; 60 | return true; 61 | } 62 | this.#backNode.next = newNode; 63 | this.#backNode = newNode; 64 | this.size++; 65 | return true; 66 | } 67 | dequeue() { 68 | if (this.#frontNode === null) { 69 | return false; 70 | } else if (this.#frontNode.next === null) { 71 | this.#backNode = null; 72 | } 73 | const node = this.#frontNode; 74 | this.#frontNode = node.next; 75 | this.size--; 76 | if (this.#frontNode === null) this.size = 0; 77 | return node.data; 78 | } 79 | search(key) { 80 | if (this.#frontNode === null) { 81 | return false; 82 | } 83 | if (key === this.#frontNode.data.key) { 84 | return this.#frontNode.data; 85 | } 86 | if (key === this.#backNode.data.key) { 87 | return this.#backNode.data; 88 | } 89 | const iterator = searchGenerator(key, this.#frontNode); 90 | const iteratorNext = iterator.next(); 91 | if (iteratorNext.value) { 92 | return iteratorNext.value; 93 | } 94 | return false; 95 | } 96 | update(key, newValue) { 97 | if (this.#frontNode === null) { 98 | return false; 99 | } 100 | if (key === this.#frontNode.data.key) { 101 | this.#frontNode.data.value = newValue; 102 | return this.#frontNode.data; 103 | } 104 | if (key === this.#backNode.data.key) { 105 | this.#backNode.data.value = newValue; 106 | return this.#backNode.data; 107 | } 108 | const iterator = updateGenerator(key, this.#frontNode, newValue); 109 | const iteratorNext = iterator.next(); 110 | if (iteratorNext.value) { 111 | return iteratorNext.value; 112 | } 113 | return false; 114 | } 115 | log() { 116 | const iterator = this.iterator(); 117 | let iteratorNext = iterator.next(); 118 | while(iteratorNext.done === false){ 119 | console.log(iteratorNext.value); 120 | iteratorNext = iterator.next(); 121 | } 122 | } 123 | iterator() { 124 | const iterator = iteratorGenerator(this.#frontNode); 125 | return iterator; 126 | } 127 | } 128 | export { Queue1 as Queue }; 129 | -------------------------------------------------------------------------------- /queue/queue.ts: -------------------------------------------------------------------------------- 1 | import { QueueType, DataType, QueueApi } from "./helper.d.ts" 2 | import { QueueNode } from "./queueNode.ts" 3 | import { 4 | searchGenerator, 5 | updateGenerator, 6 | iteratorGenerator 7 | } from "./generators.ts" 8 | 9 | 10 | export class Queue implements QueueApi { 11 | #frontNode: QueueType 12 | #backNode: QueueType 13 | public size: number 14 | 15 | constructor() { 16 | this.#frontNode = null 17 | this.#backNode = null 18 | this.size = 0 19 | } 20 | 21 | static createQueue() { 22 | return new this(); 23 | } 24 | 25 | getFront() { 26 | if (this.#frontNode === null) return null 27 | return this.#frontNode!.data 28 | } 29 | 30 | getBack() { 31 | if (this.#frontNode === null) return null 32 | return this.#backNode!.data 33 | } 34 | 35 | enqueue(data: DataType) { 36 | const newNode = new QueueNode(data) 37 | if (this.#frontNode === null) { 38 | // adding same pointer for frontNode & backNode 39 | this.#frontNode = newNode 40 | this.#backNode = newNode 41 | return true; 42 | } 43 | 44 | // pointer and it's greatness 45 | this.#backNode!.next = newNode 46 | this.#backNode = newNode 47 | this.size++ 48 | 49 | return true; 50 | } 51 | 52 | dequeue() { 53 | if (this.#frontNode === null) { 54 | return false; 55 | } else if (this.#frontNode!.next === null) { 56 | this.#backNode = null 57 | } 58 | 59 | const node = this.#frontNode 60 | this.#frontNode = node!.next 61 | this.size-- 62 | if (this.#frontNode === null) this.size = 0 63 | 64 | return node!.data; 65 | } 66 | 67 | search(key: string|number) { 68 | if (this.#frontNode === null) { 69 | return false 70 | } 71 | 72 | if (key === this.#frontNode!.data.key) { 73 | return this.#frontNode!.data 74 | } 75 | if (key === this.#backNode!.data.key) { 76 | return this.#backNode!.data 77 | } 78 | 79 | // generator function that returns an iterator 80 | const iterator = searchGenerator(key, this.#frontNode) 81 | const iteratorNext = iterator.next() 82 | if (iteratorNext.value) { 83 | return iteratorNext.value 84 | } 85 | 86 | return false 87 | } 88 | 89 | update(key: string|number, newValue: any) { 90 | if (this.#frontNode === null) { 91 | return false 92 | } 93 | 94 | if (key === this.#frontNode!.data.key) { 95 | this.#frontNode!.data.value = newValue 96 | return this.#frontNode!.data 97 | } 98 | if (key === this.#backNode!.data.key) { 99 | this.#backNode!.data.value = newValue 100 | return this.#backNode!.data 101 | } 102 | 103 | // generator function that returns an iterator 104 | const iterator = updateGenerator(key, this.#frontNode, newValue) 105 | const iteratorNext = iterator.next() 106 | if (iteratorNext.value) { 107 | return iteratorNext.value 108 | } 109 | 110 | return false 111 | } 112 | 113 | log() { 114 | const iterator = this.iterator() 115 | let iteratorNext = iterator.next() 116 | 117 | while (iteratorNext.done === false) { 118 | console.log(iteratorNext.value); 119 | iteratorNext = iterator.next() 120 | } 121 | } 122 | 123 | iterator() { 124 | // generator function that returns an iterator 125 | const iterator = iteratorGenerator(this.#frontNode) 126 | return iterator 127 | } 128 | } 129 | -------------------------------------------------------------------------------- /queue/queueNode.ts: -------------------------------------------------------------------------------- 1 | import { DataType, QueueType } from "./helper.d.ts" 2 | 3 | export class QueueNode { 4 | public data: DataType 5 | public next: QueueType|null = null 6 | 7 | constructor(data: DataType) { 8 | this.data = data; 9 | this.next = null; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /queue/readme.md: -------------------------------------------------------------------------------- 1 | ## Queue Api 2 | 3 | ```ts 4 | DataType = { 5 | key: string|number 6 | value: T 7 | } 8 | 9 | // static method that creates a instance of Queue class. 10 | Queue.createQueue() 11 | 12 | // Time Complexity: O(1) 13 | size: number; 14 | 15 | // *generator function, it returens an iterator. 16 | iterator(): Generator 17 | 18 | // Time Complexity: O(1) 19 | getFront(): number|DataType 20 | 21 | // Time Complexity: O(1) 22 | getBack(): number|DataType 23 | 24 | // Time Complexity: O(1) 25 | enqueue(data: DataType): boolean 26 | 27 | // Time Complexity: O(1) 28 | dequeue(): boolean|DataType 29 | 30 | // Time Complexity: 31 | // Front Node & Back Node: O(1), other Nodes: O(n) 32 | search(key: string|number): null|DataType 33 | 34 | // Time Complexity: 35 | // Front Node & Back Node: O(1), other Nodes: O(n) 36 | update(key: string|number, newValue: any): boolean|DataType 37 | 38 | // Time Complexity: O(n) 39 | log(): void; 40 | ``` 41 | 42 |
43 |
44 | 45 | ## Example 46 | ```ts 47 | import { Queue } from "https://deno.land/x/datastructure/mod.ts"; 48 | 49 | const queue = Queue.createQueue() 50 | 51 | // add data in the Queue in a FIFO way 52 | queue.enqueue({key: 'a', value: [1, 2, 5]}) 53 | queue.enqueue({key: 'sourav', value: {name: "Sourav"}}) 54 | 55 | // get and remove first added data from the Queue 56 | queue.dequeue() 57 | 58 | // get the item which added at first 59 | queue.getFront() 60 | 61 | // get the item which added at last 62 | queue.getBack() 63 | 64 | // search item data in the Queue 65 | queue.search('sourav') 66 | 67 | // update item data 68 | queue.update('sourav', 'Abm Sourav') 69 | 70 | // iterator method returns a *generator function 71 | const iterator = queue.iterator() 72 | let iteratorNext = iterator.next() 73 | // console.log(iteratorNext.next(), iteratorNext.next()); 74 | while (iteratorNext.done === false) { 75 | console.log(iteratorNext.value); 76 | iteratorNext = iterator.next() 77 | } 78 | 79 | // console all values 80 | queue.log() 81 | 82 | ``` 83 | -------------------------------------------------------------------------------- /queue/test.ts: -------------------------------------------------------------------------------- 1 | // import { Queue } from "https://deno.land/x/datastructure/mod.ts"; 2 | import { Queue } from "./queue.ts"; 3 | 4 | const queue = Queue.createQueue() 5 | queue.enqueue({key: 'a', value: 'aa'}); 6 | queue.enqueue({key: 'b', value: [1, 2, 5]}) 7 | queue.enqueue({key: 'sourav', value: {name: "Sourav"}}) 8 | 9 | // console.log(queue.getFront(), queue.getBack()); 10 | 11 | // queue.dequeue() 12 | // console.log(queue.update('sourav', 'Abm')); 13 | // console.log(queue.search('b')); 14 | 15 | // const iterator = queue.iterator() 16 | // let iteratorNext = iterator.next() 17 | // console.log(iterator.next(), iterator.next(), iterator.next()); 18 | // while (iteratorNext.done === false) { 19 | // console.log(iteratorNext.value); 20 | // iteratorNext = iterator.next() 21 | // } 22 | 23 | // console.log(queue); 24 | queue.log() 25 | -------------------------------------------------------------------------------- /stack/generators.ts: -------------------------------------------------------------------------------- 1 | import { StackType } from "./helper.d.ts"; 2 | 3 | export function *searchGenerator(key: string|number, currentNode: StackType) { 4 | while (currentNode !== null) { 5 | if (key === currentNode.data.key) { 6 | return currentNode.data 7 | } 8 | currentNode = currentNode.next 9 | } 10 | return false 11 | } 12 | 13 | export function *updateGenerator(key: string|number, currentNode: StackType, newValue: any) { 14 | while (currentNode !== null) { 15 | if (key === currentNode.data.key) { 16 | currentNode.data.value = newValue 17 | return currentNode.data 18 | } 19 | 20 | currentNode = currentNode.next 21 | } 22 | return false 23 | } 24 | 25 | export function *iteratorGenerator(currentNode: StackType) { 26 | while (currentNode !== null) { 27 | yield currentNode.data; 28 | 29 | currentNode = currentNode.next 30 | } 31 | return false 32 | } 33 | -------------------------------------------------------------------------------- /stack/helper.d.ts: -------------------------------------------------------------------------------- 1 | // data type 2 | export type DataType = { 3 | key: string|number 4 | value: T 5 | } 6 | 7 | export type StackType = { 8 | data: DataType 9 | next: null|StackType 10 | }|null 11 | 12 | // Stack interface 13 | export interface StackApi { 14 | size: number; 15 | getTop(): null|DataType 16 | getBottom(): null|DataType 17 | push(data: DataType): boolean 18 | pop(): boolean|DataType 19 | search(key: string|number): boolean|DataType 20 | update(key: string|number, newValue: any): boolean|DataType 21 | log(): void 22 | iterator(): Generator 23 | } 24 | -------------------------------------------------------------------------------- /stack/readme.md: -------------------------------------------------------------------------------- 1 | ## Stack Api 2 | 3 | ```ts 4 | DataType = { 5 | key: string|number 6 | value: T 7 | } 8 | 9 | // static method that creates a instance of `Stack` class. 10 | Stack.createStack() 11 | 12 | // Time Complexity: O(1) 13 | size: number; 14 | 15 | // *generator function, it returens an iterator. 16 | iterator(): Generator 17 | 18 | // Time Complexity: O(1) 19 | getTop(): null|DataType 20 | 21 | // Time Complexity: O(1) 22 | getBottom(): null|DataType 23 | 24 | // Time Complexity: O(1) 25 | push(data: DataType): boolean 26 | 27 | // Time Complexity: O(1) 28 | pop(): boolean|DataType 29 | 30 | // Time Complexity: 31 | // Top Node & Bottom Node: O(1), other Nodes: O(n) 32 | search(key: string|number): null|DataType 33 | 34 | // Time Complexity: 35 | // Top Node & Bottom Node: O(1), other Nodes: O(n) 36 | update(key: string|number, newValue: any): boolean|DataType 37 | 38 | // Time Complexity: O(n) 39 | log(): void; 40 | ``` 41 | 42 |
43 |
44 | 45 | ## Example 46 | ```ts 47 | import { Stack } from "https://deno.land/x/datastructure/mod.ts"; 48 | 49 | const stack = Stack.createStack() 50 | 51 | // stack length/size 52 | stack.size 53 | 54 | // iterator method returns a *generator function 55 | const iterator = stack.iterator() 56 | let iteratorNext = iterator.next() 57 | // console.log(iteratorNext.next(), iteratorNext.next()); 58 | while (iteratorNext.done === false) { 59 | console.log(iteratorNext.value); 60 | iteratorNext = iterator.next() 61 | } 62 | 63 | // add data in the stack in a LIFO way 64 | stack.push({key: 'a', value: 'apple'}) 65 | stack.push({key: 'b', value: [1, 2, 4]}) 66 | stack.push({key: 'b', value: {name: 'AbmSourav'}}) 67 | 68 | // get data from stack (LIFO) 69 | stack.pop() 70 | 71 | // searching data in the stack 72 | stack.search('a'); 73 | 74 | // get the last added item of the stack 75 | stack.getTop() 76 | 77 | // get the item that added at fast 78 | stack.getBottom() 79 | 80 | // update stack item data 81 | stack.update('a', {name: 'Abm Sourav'}) 82 | 83 | // console all values 84 | stack.log() 85 | ``` 86 | -------------------------------------------------------------------------------- /stack/stack.bundle.js: -------------------------------------------------------------------------------- 1 | class StackNode { 2 | data; 3 | next = null; 4 | constructor(data1){ 5 | this.data = data1; 6 | this.next = null; 7 | } 8 | } 9 | function* searchGenerator(key, currentNode) { 10 | while(currentNode !== null){ 11 | if (key === currentNode.data.key) { 12 | return currentNode.data; 13 | } 14 | currentNode = currentNode.next; 15 | } 16 | return false; 17 | } 18 | function* updateGenerator(key, currentNode, newValue) { 19 | while(currentNode !== null){ 20 | if (key === currentNode.data.key) { 21 | currentNode.data.value = newValue; 22 | return currentNode.data; 23 | } 24 | currentNode = currentNode.next; 25 | } 26 | return false; 27 | } 28 | function* iteratorGenerator(currentNode) { 29 | while(currentNode !== null){ 30 | yield currentNode.data; 31 | currentNode = currentNode.next; 32 | } 33 | return false; 34 | } 35 | class Stack1 { 36 | #topNode; 37 | #bottomNode; 38 | size; 39 | constructor(){ 40 | this.#topNode = null; 41 | this.#bottomNode = null; 42 | this.size = 0; 43 | } 44 | static createStack() { 45 | return new this(); 46 | } 47 | getTop() { 48 | if (this.#topNode === null) return null; 49 | return this.#topNode.data; 50 | } 51 | getBottom() { 52 | if (this.#topNode === null) return null; 53 | return this.#bottomNode.data; 54 | } 55 | push(data) { 56 | const newNode = new StackNode(data); 57 | if (this.#topNode === null) { 58 | this.#topNode = newNode; 59 | this.#bottomNode = newNode; 60 | return true; 61 | } 62 | newNode.next = this.#topNode; 63 | if (newNode.next === null) { 64 | this.#bottomNode = newNode.next; 65 | } 66 | this.#topNode = newNode; 67 | this.size++; 68 | return true; 69 | } 70 | pop() { 71 | if (this.#topNode === null) { 72 | return false; 73 | } else if (this.#topNode.next === null) { 74 | this.#bottomNode = null; 75 | } 76 | const node = this.#topNode; 77 | this.#topNode = node.next; 78 | this.size--; 79 | if (this.#topNode === null) this.size = 0; 80 | return node.data; 81 | } 82 | search(key) { 83 | if (this.#topNode === null) { 84 | return false; 85 | } 86 | if (key === this.#topNode.data.key) { 87 | return this.#topNode.data; 88 | } 89 | if (key === this.#bottomNode.data.key) { 90 | return this.#bottomNode.data; 91 | } 92 | const iterator = searchGenerator(key, this.#topNode); 93 | const iteratorNext = iterator.next(); 94 | if (iteratorNext.value) { 95 | return iteratorNext.value; 96 | } 97 | return false; 98 | } 99 | update(key, newValue) { 100 | if (this.#topNode === null) { 101 | return false; 102 | } 103 | if (key === this.#topNode.data.key) { 104 | this.#topNode.data.value = newValue; 105 | return this.#topNode.data; 106 | } 107 | if (key === this.#bottomNode.data.key) { 108 | this.#bottomNode.data.value = newValue; 109 | return this.#bottomNode.data; 110 | } 111 | const iterator = updateGenerator(key, this.#topNode, newValue); 112 | const iteratorNext = iterator.next(); 113 | if (iteratorNext.value) { 114 | return iteratorNext.value; 115 | } 116 | return false; 117 | } 118 | log() { 119 | let currentNode = this.#topNode; 120 | while(currentNode !== null){ 121 | console.log(currentNode.data); 122 | currentNode = currentNode.next; 123 | } 124 | } 125 | iterator() { 126 | const iterator = iteratorGenerator(this.#topNode); 127 | return iterator; 128 | } 129 | } 130 | export { Stack1 as Stack }; 131 | -------------------------------------------------------------------------------- /stack/stack.ts: -------------------------------------------------------------------------------- 1 | import { StackType, DataType, StackApi } from "./helper.d.ts" 2 | import { StackNode } from "./stackNode.ts" 3 | import { 4 | searchGenerator, 5 | updateGenerator, 6 | iteratorGenerator 7 | } from "./generators.ts" 8 | 9 | 10 | export class Stack implements StackApi { 11 | #topNode: StackType 12 | #bottomNode: StackType 13 | public size: number 14 | 15 | constructor() { 16 | this.#topNode = null 17 | this.#bottomNode = null 18 | this.size = 0 19 | } 20 | 21 | static createStack() { 22 | return new this(); 23 | } 24 | 25 | getTop() { 26 | if (this.#topNode === null) return null; 27 | return this.#topNode!.data 28 | } 29 | 30 | getBottom() { 31 | if (this.#topNode === null) return null; 32 | return this.#bottomNode!.data 33 | } 34 | 35 | push(data: DataType) { 36 | const newNode = new StackNode(data) 37 | if (this.#topNode === null) { 38 | this.#topNode = newNode 39 | this.#bottomNode = newNode 40 | return true; 41 | } 42 | 43 | newNode.next = this.#topNode 44 | if (newNode.next === null) { 45 | this.#bottomNode = newNode.next 46 | } 47 | this.#topNode = newNode 48 | this.size++ 49 | 50 | return true; 51 | } 52 | 53 | pop() { 54 | if (this.#topNode === null) { 55 | return false; 56 | } else if (this.#topNode!.next === null) { 57 | this.#bottomNode = null 58 | } 59 | 60 | const node = this.#topNode 61 | this.#topNode = node!.next 62 | this.size-- 63 | if (this.#topNode === null) this.size = 0 64 | 65 | return node!.data; 66 | } 67 | 68 | search(key: string|number) { 69 | if (this.#topNode === null) { 70 | return false 71 | } 72 | 73 | if (key === this.#topNode!.data.key) { 74 | return this.#topNode!.data 75 | } 76 | if (key === this.#bottomNode!.data.key) { 77 | return this.#bottomNode!.data 78 | } 79 | 80 | // generator function that returns an iterator 81 | const iterator = searchGenerator(key, this.#topNode) 82 | const iteratorNext = iterator.next() 83 | if (iteratorNext.value) { 84 | return iteratorNext.value 85 | } 86 | 87 | return false 88 | } 89 | 90 | update(key: string|number, newValue: any) { 91 | if (this.#topNode === null) { 92 | return false 93 | } 94 | 95 | if (key === this.#topNode!.data.key) { 96 | this.#topNode!.data.value = newValue 97 | return this.#topNode!.data 98 | } 99 | if (key === this.#bottomNode!.data.key) { 100 | this.#bottomNode!.data.value = newValue 101 | return this.#bottomNode!.data 102 | } 103 | 104 | // generator function that returns an iterator 105 | const iterator = updateGenerator(key, this.#topNode, newValue) 106 | const iteratorNext = iterator.next() 107 | if (iteratorNext.value) { 108 | return iteratorNext.value 109 | } 110 | 111 | return false 112 | } 113 | 114 | log() { 115 | let currentNode = this.#topNode 116 | while (currentNode !== null) { 117 | console.log(currentNode.data); 118 | currentNode = currentNode.next 119 | } 120 | } 121 | 122 | iterator() { 123 | // generator function that returns an iterator 124 | const iterator = iteratorGenerator(this.#topNode) 125 | return iterator 126 | } 127 | } 128 | -------------------------------------------------------------------------------- /stack/stackNode.ts: -------------------------------------------------------------------------------- 1 | import { DataType, StackType } from "./helper.d.ts" 2 | 3 | export class StackNode { 4 | public data: DataType 5 | public next: StackType|null = null 6 | 7 | constructor(data: DataType) { 8 | this.data = data; 9 | this.next = null; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /stack/test.ts: -------------------------------------------------------------------------------- 1 | // import { Stack } from "https://deno.land/x/datastructure/mod.ts"; 2 | import { Stack } from "./stack.ts"; 3 | 4 | const stack = Stack.createStack() 5 | 6 | stack.push({key: 'a', value: 'apple'}) 7 | stack.push({key: 'b', value: [1, 2, 4]}) 8 | stack.push({key: 'c', value: [8, 9, 2]}) 9 | stack.push({key: 'd', value: 'dd'}) 10 | 11 | // stack.pop(); 12 | // console.log(stack.update('d', {name: 'Sourav'})); 13 | 14 | // console.log(stack.getTop(), stack.getBottom()); 15 | // console.log(stack.search('d')); 16 | 17 | const iterator = stack.iterator() 18 | // let iteratorNext = iterator.next() 19 | console.log(iterator.next(), iterator.next(), iterator.next()); 20 | // while (iteratorNext.done === false) { 21 | // console.log(iteratorNext.value); 22 | // iteratorNext = iterator.next() 23 | // } 24 | 25 | // console.log(stack) 26 | // stack.log() 27 | --------------------------------------------------------------------------------