Add tree algorithms

Author: Ren0503

src/algorithms/tree/breadth-first-search/README.md

@@ -0,0 +1,43 @@
+# Tìm kiếm theo chiều rộng (BFS)
+
+Tìm kiếm theo chiều rộng là một thuật toán duyệt hoặc tìm kiếm trên cấu trúc cây hoặc đồ thị.Thuật toán bắt đầu từ đỉnh gốc và lần lượt nhìn các đỉnh kề với đỉnh gốc. Sau đó, với mỗi đỉnh trong số đó, thuật toán lại lần lượt nhìn trước các đỉnh kề với nó mà chưa được quan sát trước đó và lặp lại.
+
+![Algorithm Visualization](https://upload.wikimedia.org/wikipedia/commons/5/5d/Breadth-First-Search-Algorithm.gif)
+
+## Mã giả
+* Input : nút gốc trong cây BST
+* Output : các nút trong BST đã được truy cập theo thứ tự đầu tiên theo chiều rộng
+
+```text
+BFS(root)
+  q ← queue
+  while root != ø
+    yield root.value
+    if root.left != ø
+      q.enqueue(root.left)
+    end if
+    if root.right != ø
+      q.enqueue(root.right)
+    end if
+    if !q.isEmpty()
+      root ← q.dequeue()
+    else
+      root ← ø
+    end if
+  end while
+end BFS
+```
+
+Diễn giải :
+1. Chèn đỉnh gốc vào hàng đợi (đang hướng tới)
+2. Lấy ra đỉnh đầu tiên trong hàng đợi và quan sát nó
+  - Nếu đỉnh này là đỉnh đích, dừng quá trình tìm kiếm và trả về kết quả.
+  - Nếu không phải thì chèn tất cả các đỉnh kề với đỉnh vừa thăm nhưng chưa được quan sát trước đó vào hàng đợi.
+3. Nếu hàng đợi là rỗng, thì tất cả các đỉnh có thể đến được đều đã được quan sát – dừng việc tìm kiếm và trả về "không thấy".
+4. Nếu hàng đợi không rỗng thì quay về bước 2.
+
+## References
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Breadth-first_search)
+- [Tree Traversals (Inorder, Preorder and Postorder)](https://www.geeksforgeeks.org/tree-traversals-inorder-preorder-and-postorder/)
+- [BFS vs DFS](https://www.geeksforgeeks.org/bfs-vs-dfs-binary-tree/)

src/algorithms/tree/breadth-first-search/breadthFirstSearch.js

@@ -0,0 +1,58 @@
+import Queue from '../../../data-structures/queue/Queue';
+
+/**
+ * @typedef {Object} Callbacks
+ * @property {function(node: BinaryTreeNode, child: BinaryTreeNode): boolean} allowTraversal -
+ * Xác định xem BFS có nên truyền từ nút đến nút con của nó hay không.
+ * @property {function(node: BinaryTreeNode)} enterNode - Được gọi khi BFS đi vào nút.
+ * @property {function(node: BinaryTreeNode)} leaveNode - Được gọi khi BFS rời khỏi nút..
+ */
+
+/**
+ * @param {Callbacks} [callbacks]
+ * @returns {Callbacks}
+ */
+function initCallbacks(callbacks = {}) {
+    const initiatedCallback = callbacks;
+
+    const stubCallback = () => { };
+    const defaultAllowTraversal = () => true;
+
+    initiatedCallback.allowTraversal = callbacks.allowTraversal || defaultAllowTraversal;
+    initiatedCallback.enterNode = callbacks.enterNode || stubCallback;
+    initiatedCallback.leaveNode = callbacks.leaveNode || stubCallback;
+
+    return initiatedCallback;
+}
+
+/**
+ * @param {BinaryTreeNode} rootNode
+ * @param {Callbacks} [originalCallbacks]
+ */
+export default function breadthFirstSearch(rootNode, originalCallbacks) {
+    const callbacks = initCallbacks(originalCallbacks);
+    const nodeQueue = new Queue();
+
+    // Khởi tạo hàng đợi.
+    nodeQueue.enqueue(rootNode);
+
+    while (!nodeQueue.isEmpty()) {
+        const currentNode = nodeQueue.dequeue();
+
+        callbacks.enterNode(currentNode);
+
+        // Thêm tất cả các phần tử con vào hàng đợi để duyệt trong tương lai.
+
+        // Duyệt nhánh trái.
+        if (currentNode.left && callbacks.allowTraversal(currentNode, currentNode.left)) {
+            nodeQueue.enqueue(currentNode.left);
+        }
+
+        // Duyệt nhánh phải.
+        if (currentNode.right && callbacks.allowTraversal(currentNode, currentNode.right)) {
+            nodeQueue.enqueue(currentNode.right);
+        }
+
+        callbacks.leaveNode(currentNode);
+    }
+}

src/algorithms/tree/depth-first-search/README.md

@@ -0,0 +1,11 @@
+# Tìm kiếm theo chiều sâu (DFS)
+
+Tìm kiếm ưu tiên chiều sâu hay tìm kiếm theo chiều sâu là một thuật toán duyệt hoặc tìm kiếm trên cấu trúc cây hoặc đồ thị. Thuật toán bắt đầu tại gốc (hoặc chọn một đỉnh nào đó coi như gốc) và khám phá xa nhất có thể theo mỗi nhánh.
+
+![Algorithm Visualization](https://upload.wikimedia.org/wikipedia/commons/7/7f/Depth-First-Search.gif)
+
+## Liên kết
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Depth-first_search)
+- [Tree Traversals (Inorder, Preorder and Postorder)](https://www.geeksforgeeks.org/tree-traversals-inorder-preorder-and-postorder/)
+- [BFS vs DFS](https://www.geeksforgeeks.org/bfs-vs-dfs-binary-tree/)

src/algorithms/tree/depth-first-search/depthFirstSearch.js

@@ -0,0 +1,74 @@
+/**
+ * @typedef {Object} TraversalCallbacks
+ *
+ * @property {function(node: BinaryTreeNode, child: BinaryTreeNode): boolean} allowTraversal
+ * - Xác định xem DFS có nên truyền từ nút đến nút con của nó hay không.
+ *
+ * @property {function(node: BinaryTreeNode)} enterNode - Được gọi khi DFS đi vào nút..
+ *
+ * @property {function(node: BinaryTreeNode)} leaveNode - Được gọi khi DFS ra khỏi nút.
+ */
+
+/**
+ * Mở rộng các lệnh duyệt callback bị thiếu và callback mặc định.
+ *
+ * @param {TraversalCallbacks} [callbacks] - Đối tượng chứa lệnh duyệt callback.
+ * @returns {TraversalCallbacks} - Duyệt callbacks mở rộng với callbacks.
+ */
+function initCallbacks(callbacks = {}) {
+    // Khởi tạo đối tượng callback rỗng.
+    const initiatedCallbacks = {};
+
+    // Callback rỗng nghĩa là ta sẽ dùng trong trường hợp không được cung cấp hàm callback.
+    const stubCallback = () => { };
+    // Mặc định ta sẽ duyệt tất cả node trong trường hợp không được cung cấp callback.
+    const defaultAllowTraversalCallback = () => true;
+
+    // Sao chép callback gốc cho đối tượng initiatedCallbacks hoặc sử dụng callback mặc định
+    initiatedCallbacks.allowTraversal = callbacks.allowTraversal || defaultAllowTraversalCallback;
+    initiatedCallbacks.enterNode = callbacks.enterNode || stubCallback;
+    initiatedCallbacks.leaveNode = callbacks.leaveNode || stubCallback;
+
+    // Trả về danh sách quá trình callback.
+    return initiatedCallbacks;
+}
+
+/**
+ * Duyệt đệ quy DFS cho cây nhị phân.
+ *
+ * @param {BinaryTreeNode} node - nút của cây nhị phân mà ta muốn bắt đầu.
+ * @param {TraversalCallbacks} callbacks - đối tượng chứa hàm duyệt callback.
+ */
+export function depthFirstSearchRecursive(node, callbacks) {
+    // Gọi callback "enterNode" để thông báo rằng nút sẽ được duyệt.
+    callbacks.enterNode(node);
+
+    // Duyệt nhánh bên trái trong trường hợp nút trái cho phép.
+    if (node.left && callbacks.allowTraversal(node, node.left)) {
+        depthFirstSearchRecursive(node.left, callbacks);
+    }
+
+    // Duyệt nhánh bên phải trong trường hợp nút phải cho phép.
+    if (node.right && callbacks.allowTraversal(node, node.right)) {
+        depthFirstSearchRecursive(node.right, callbacks);
+    }
+
+    // Gọi callback "leaveNode" để thông báo việc duyệt nút hiện tại
+    //  và con của nút đã hoàn tất.
+    callbacks.leaveNode(node);
+}
+
+/**
+ * Duyệt DFS với rootNode
+ * Với tất cả bước duyệt gọi callback "allowTravel", "enterNode" và "leaveNode".
+ * Xem kiểu TraversalCallback định nghĩa chi tiết hơn về dạng đối tượng callback.
+ * @param {BinaryTreeNode} rootNode - Nút mà ta bắt đầu duyêt.
+ * @param {TraversalCallbacks} [callbacks] - Duyệt callbacks.
+ */
+export default function depthFirstSearch(rootNode, callbacks) {
+    // Trong trường hợp hàm callback không được cung cấp ta sẽ sử dụng hàm mặc đinh.
+    const processedCallbacks = initCallbacks(callbacks);
+
+    // Giờ, khi ta cần tất cả callback cần thiết, ta sẽ duyệt đệ quy.
+    depthFirstSearchRecursive(rootNode, processedCallbacks);
+}

src/data-structures/tree/red-black-tree/RedBlackTree.js

@@ -1,6 +1,6 @@
 import BinarySearchTree from '../binary-search-tree/BinarySearchTree';
 
-// Màu có thể của cây đỏ đen.
+// Màu của cây đỏ đen.
 const RED_BLACK_TREE_COLORS = {
     red: 'red',
     black: 'black',