update DSA doubly linkedlist, queue, stack

Author: sangtrandev00

src/data_structure/linkedList/doublyLinkedList.test.ts

@@ -0,0 +1,96 @@
+class DoublyLinkedList {
+    head: any;
+    tail: any;
+    length: number;
+
+    constructor(value: any) {
+        this.head = {
+            value: value,
+            prev: null,
+            next: null,
+        };
+        this.tail = this.head;
+        this.length = 1;
+    }
+    append(value: any) {
+        const newNode = {
+            value: value,
+            prev: null,
+            next: null,
+        };
+        newNode.prev = this.tail;
+        this.tail.next = newNode;
+        this.tail = newNode;
+        this.length++;
+        return this;
+    }
+    prepend(value: any) {
+        const newNode = {
+            value: value,
+            prev: null,
+            next: null,
+        };
+        newNode.next = this.head;
+        this.head.prev = newNode;
+        this.head = newNode;
+        this.length++;
+        return this;
+    }
+    printList() {
+        const array = [];
+        let currentNode = this.head;
+        while (currentNode !== null) {
+            array.push(currentNode.value);
+            currentNode = currentNode.next;
+        }
+        return console.log(array);
+    }
+    insert(index: number, value: any) {
+        //Check for proper parameters;
+        if (index >= this.length) {
+            console.log("yes");
+            return this.append(value);
+        }
+
+        const newNode = {
+            value: value,
+            prev: null,
+            next: null,
+        };
+        const leader = this.traverseToIndex(index - 1);
+        const follower = leader.next;
+        leader.next = newNode;
+        newNode.prev = leader;
+        newNode.next = follower;
+        follower.prev = newNode;
+        this.length++;
+        return this.printList();
+    }
+    traverseToIndex(index: number) {
+        //Check parameters
+        let counter = 0;
+        let currentNode = this.head;
+        while (counter !== index) {
+            currentNode = currentNode.next;
+            counter++;
+        }
+        return currentNode;
+    }
+    remove(index: number) {
+        // Check Parameters
+        const leader = this.traverseToIndex(index - 1);
+        const unwantedNode = leader.next;
+        leader.next = unwantedNode.next;
+        this.length--;
+        return this.printList();
+    }
+}
+
+let myLinkedList = new DoublyLinkedList(10);
+myLinkedList.append(5);
+myLinkedList.append(16);
+myLinkedList.prepend(1);
+myLinkedList.printList();
+myLinkedList.insert(2, 99);
+//   myLinkedList.insert(20, 88);
+//   myLinkedList.remove(2);

src/data_structure/linkedList/doublyLinkedList.ts

@@ -0,0 +1,61 @@
+class Node {
+    value: any;
+    next: any;
+    constructor(value: any) {
+        this.value = value;
+        this.next = null;
+    }
+}
+
+class Queue {
+    // Dùng Single LinkedList là được rồi!
+    first: any;
+    last: any;
+    length: number;
+    constructor() {
+        this.first = null;
+        this.last = null;
+        this.length = 0;
+    }
+    peek() {
+        return this.first
+    }
+    enqueue(value: any) {
+        if (this.length === 0) {
+            this.first = new Node(value)
+            this.last = this.first
+        } else {
+            const newNode = new Node(value)
+            this.last.next = newNode
+            this.last = newNode
+        }
+        this.length++
+        return this.last
+    }
+    dequeue() {
+        const holder = this.first
+        this.first = this.first.next;
+        this.length--
+        return holder
+    }
+    isEmpty() {
+        return this.length === 0
+    }
+    //isEmpty;
+}
+
+const myQueue = new Queue();
+myQueue.enqueue('Joy');
+myQueue.enqueue('Matt');
+myQueue.enqueue('Pavel');
+myQueue.enqueue('Samir');
+// console.log("myQueue", myQueue);
+// myQueue.dequeue();
+// myQueue.dequeue();
+console.log("dequeue", myQueue.dequeue());
+// console.log("myQueue after dequeue", myQueue);
+
+//Joy
+//Matt
+//Pavel
+//Samir

src/data_structure/queue/queue-implement.ts

@@ -0,0 +1,64 @@
+class Node {
+    value: any;
+    next: any;
+    constructor(value: any) {
+        this.value = value;
+        this.next = null;
+    }
+}
+
+class Stack {
+    array: any = []
+    top: any;
+    bottom: any;
+    length: number;
+    constructor() {
+        this.top = null;
+        this.bottom = null;
+        this.length = 0;
+    }
+
+    peek() {
+        if (this.length == 0) return null
+        return this.top
+    }
+
+    push(value: any) {
+        this.array.push(value)
+        if (this.length === 0) {
+            this.top = this.array[0]
+            this.bottom = this.array[0]
+        } else {
+            this.top = this.array[this.length]
+        }
+        this.length++
+
+    }
+
+    pop() {
+        if (this.length == 0) return null
+        const remove = this.array.pop()
+        if (this.length == 0) {
+            this.bottom = null
+            this.top = null
+        } else {
+            this.top = this.array[this.array.length - 1]
+        }
+        this.length--
+        return remove
+    }
+
+    isEmpty() {
+        return this.length === 0
+    }
+
+    //isEmpty
+}
+
+const myStack = new Stack();
+myStack.push(1)
+myStack.push(30)
+myStack.push(1000)
+console.log("peek", myStack.peek());
+console.log("pop", myStack.pop());
+console.log("myStack", myStack);

src/data_structure/stack/stack-array-implement.ts

@@ -0,0 +1,68 @@
+import { LinkedList } from "../linkedList/reverseLinkedList";
+
+class Node {
+    value: any
+    next: any
+    constructor(value: any) {
+        this.value = value;
+        this.next = null;
+    }
+}
+
+class Stack {
+    top: any
+    bottom: any
+    length: number
+    constructor() {
+        this.top = null;
+        this.bottom = null;
+        this.length = 0;
+    }
+
+    peek() {
+        return this.top
+    }
+
+    push(value: any) {
+        const newNode = new Node(value)
+        if (this.length == 0) {
+            this.top = newNode
+            this.bottom = newNode
+        } else {
+            const holdingPointer = this.top
+            this.top = newNode
+            this.top.next = holdingPointer
+        }
+        this.length++
+        return this
+    }
+
+    pop() {
+        if (!this.top) return null
+        const holderPointer = this.top
+
+        this.top = this.top.next
+        if (this.top == null) {
+            this.bottom = null
+        }
+        this.length--
+        return holderPointer
+    }
+
+    isEmpty() {
+        return this.length === 0
+    }
+
+    //isEmpty
+}
+
+const myStack = new Stack();
+myStack.push(1)
+myStack.push(3)
+myStack.push(100)
+myStack.push(3000)
+console.log("myStack", myStack);
+console.log("myStack", myStack.pop());
+// console.log("myStack.pop()", myStack.pop());
+// console.log("myStack", myStack);
+// console.log("peek", myStack.peek());