add dfs (deep first search) with 3 case (InOrder, PreOrder, PostOrder)

Author: sangtrandev00

src/algorithm/searching/bfs-dfs.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, beforeEach, test } from 'bun:test'
+import { BinarySearchTree } from './bfs-dfs';
+
+describe('BinarySearchTree', () => {
+    let tree: BinarySearchTree;
+
+    beforeEach(() => {
+        tree = new BinarySearchTree();
+        // Insert nodes for testing
+        tree.insert(9);
+        tree.insert(4);
+        tree.insert(6);
+        tree.insert(20);
+        tree.insert(170);
+        tree.insert(15);
+        tree.insert(1);
+    });
+
+    test('breathFirstSearch should return values in breadth-first order', () => {
+        const result = tree.breathFirstSearch();
+        expect(result).toEqual([9, 4, 20, 1, 6, 15, 170]);
+    });
+
+    test('breathFirstSearchRecursive should return values in breadth-first order', () => {
+        const result = tree.breathFirstSearchRecursive([tree.root], []);
+        expect(result).toEqual([9, 4, 20, 1, 6, 15, 170]);
+    });
+
+    test('DFSInorder should return values in inorder traversal', () => {
+        const result = tree.DFSInorder();
+        expect(result).toEqual([1, 4, 6, 9, 15, 20, 170]);
+    });
+
+    test('DFSPreorder should return values in preorder traversal', () => {
+        const result = tree.DFSPreorder();
+        expect(result).toEqual([9, 4, 1, 6, 20, 15, 170]);
+    });
+
+    test('DFSPostorder should return values in postorder traversal', () => {
+        const result = tree.DFSPostorder();
+        expect(result).toEqual([1, 6, 4, 15, 170, 20, 9]);
+    });
+});

src/algorithm/searching/breath-first-search.ts renamed to src/algorithm/searching/bfs-dfs.ts

@@ -175,14 +175,78 @@ export class BinarySearchTree {
         // Recursive case
         return this.breathFirstSearchRecursive(queue, list)
     }
+
+    DFSInorder() {
+        return this.traverseInOrder(this.root, [])
+    }
+
+    DFSPreorder() {
+        return this.traversePreOrder(this.root, [])
+    }
+    DFSPostorder() {
+        return this.traversePostOrder(this.root, [])
+    }
+
+    //     9
+    //  4     20
+    //1  6  15  170
+    // InOrder - Left -> Root -> Right: [1, 4, 6, 9, 15, 20, 170]
+    traverseInOrder(node: any, list: number[]) { // Đều sử dụng cấu trúc dữ liệu stack. Function nào gọi sau -> thì thực hiện trước!
+
+        console.log(node.value);
+        console.log(list);
+        // Recursive case:
+        if (node.left) {
+            this.traverseInOrder(node.left, list)
+        }
+        list.push(node.value)
+        if (node.right) {
+            this.traverseInOrder(node.right, list)
+        }
+        // Base case ?
+        return list
+    }
+
+    // PreOrder - Root -> Left -> Right: [9, 4, 1, 6, 20, 15, 170]
+    traversePreOrder(node: any, list: number[]) { // Đều sử dụng cấu trúc dữ liệu stack. Function nào gọi sau -> thì thực hiện trước!
+        console.log(node.value);
+        console.log(list);
+        list.push(node.value)
+        // Recursive case:
+        if (node.left) {
+            this.traversePreOrder(node.left, list)
+        }
+        if (node.right) {
+            this.traversePreOrder(node.right, list)
+        }
+
+        // Base case ?
+        return list
+    }
+
+    traversePostOrder(node: any, list: number[]) { // Đều sử dụng cấu trúc dữ liệu stack. Function nào gọi sau -> thì thực hiện trước!
+        console.log(node.value);
+        console.log(list);
+        // Recursive case:
+        if (node.left) {
+            this.traversePostOrder(node.left, list)
+        }
+        if (node.right) {
+            this.traversePostOrder(node.right, list)
+        }
+        list.push(node.value)
+        // Base case ?
+        return list // Space complexity -> O(h) h: là chiều cao của cây nhị phân
+    }
+
 }
 
 //     9
 //  4     20
 //1  6  15  170
 // InOrder - Left -> Root -> Right: [1, 4, 6, 9, 15, 20, 170]
 // PreOrder - Root -> Left -> Right: [9, 4, 1, 6, 20, 15, 170]
-// PostOrder - Left -> Right -> Root: [9, 15, 6, 20, 170, 1, 4]
+// PostOrder - Left -> Right -> Root: [1, 4, 6, 9, 15, 20, 170]
 
 const tree = new BinarySearchTree();
 tree.insert(9);
@@ -192,11 +256,14 @@ tree.insert(20);
 tree.insert(170);
 tree.insert(15);
 tree.insert(1);
-tree.remove(170);
+// tree.remove(170);
 // JSON.stringify(traverse(tree.root));
 // console.log(tree.lookup(20));
-console.log(tree.breathFirstSearch());
-console.log(tree.breathFirstSearchRecursive([tree.root], []));
+// console.log(tree.breathFirstSearch());
+// console.log(tree.breathFirstSearchRecursive([tree.root], []));
+// console.log(tree.DFSInorder());
+// console.log(tree.DFSPreorder());
+console.log(tree.DFSPostorder());
 function traverse(node: Node | null) {
     if (!node) return null
     const tree: Node | null = { value: node.value, left: null, right: null };