Add data structure tree and graph

Author: Ren0503

src/data-structures/graph/Graph.js

@@ -0,0 +1,197 @@
+export default class Graph {
+    /**
+     * @param {boolean} isDirected
+     */
+    constructor(isDirected = false) {
+        this.vertices = {};
+        this.edges = {};
+        this.isDirected = isDirected;
+    }
+
+    /**
+     * @param {GraphVertex} newVertex
+     * @returns {Graph}
+     */
+    addVertex(newVertex) {
+        this.vertices[newVertex.getKey()] = newVertex;
+
+        return this;
+    }
+
+    /**
+     * @param {string} vertexKey
+     * @returns Đỉnh đồ thị.
+     */
+    getVertexByKey(vertexKey) {
+        return this.vertices[vertexKey];
+    }
+
+    /**
+     * @param {GraphVertex} vertex
+     * @returns {GraphVertex[]}
+     */
+    getNeighbors(vertex) {
+        return vertex.getNeighbors();
+    }
+
+    /**
+     * @return {GraphVertex[]}
+     */
+    getAllVertices() {
+        return Object.values(this.vertices);
+    }
+
+    /**
+     * @return {GraphEdge[]}
+     */
+    getAllEdges() {
+        return Object.values(this.edges);
+    }
+
+    /**
+     * @param {GraphEdge} edge
+     * @returns {Graph}
+     */
+    addEdge(edge) {
+        // Tìm đỉnh bắt đầu và kết thúc.
+        let startVertex = this.getVertexByKey(edge.startVertex.getKey());
+        let endVertex = this.getVertexByKey(edge.endVertex.getKey());
+
+        // Chèn đỉnh bắt đầu vào nếu nó chưa được chèn.
+        if (!startVertex) {
+            this.addVertex(edge.startVertex);
+            startVertex = this.getVertexByKey(edge.startVertex.getKey());
+        }
+
+        // Chèn đỉnh kết thúc vào nếu nó chưa được chèn.
+        if (!endVertex) {
+            this.addVertex(edge.endVertex);
+            endVertex = this.getVertexByKey(edge.endVertex.getKey());
+        }
+
+        // Kiểm tra nếu cạnh đã tồn tại.
+        if (this.edges[edge.getKey()]) {
+            throw new Error('Edge has already been added before');
+        } else {
+            this.edges[edge.getKey()] = edge;
+        }
+
+        // Thêm cạnh cho đỉnh.
+        if (this.isDirected) {
+            // Nếu đồ thị là có hướng chỉ thêm cạnh vào đỉnh bắt đầu.
+            startVertex.addEdge(edge);
+        } else {
+            // Nếu đồ thị là vô hướng thêm cạnh cho cả hai đỉnh.
+            startVertex.addEdge(edge);
+            endVertex.addEdge(edge);
+        }
+
+        return this;
+    }
+
+    /**
+     * @param {GraphEdge} edge
+     */
+    deleteEdge(edge) {
+        // Xoá cạnh khỏi tập hợp cạnh.
+        if (this.edges[edge.getKey()]) {
+            delete this.edges[edge.getKey()];
+        } else {
+            throw new Error('Edge not found in graph');
+        }
+
+        // Tìm đỉnh bắt đầu và kết thúc và xoá cạnh khỏi chúng
+        const startVertex = this.getVertexByKey(edge.startVertex.getKey());
+        const endVertex = this.getVertexByKey(edge.endVertex.getKey());
+
+        startVertex.deleteEdge(edge);
+        endVertex.deleteEdge(edge);
+    }
+
+    /**
+     * @param {GraphVertex} startVertex
+     * @param {GraphVertex} endVertex
+     * @return {(GraphEdge|null)}
+     */
+    findEdge(startVertex, endVertex) {
+        const vertex = this.getVertexByKey(startVertex.getKey());
+
+        if (!vertex) {
+            return null;
+        }
+
+        return vertex.findEdge(endVertex);
+    }
+
+    /**
+     * @return {number}
+     */
+    getWeight() {
+        return this.getAllEdges().reduce((weight, graphEdge) => {
+            return weight + graphEdge.weight;
+        }, 0);
+    }
+
+    /**
+     * Đảo tất cả cạnh của đồ thị có hướng.
+     * @return {Graph}
+     */
+    reverse() {
+        /** @param {GraphEdge} edge */
+        this.getAllEdges().forEach((edge) => {
+            // Xóa cạnh thẳng khỏi đồ thị và khỏi các đỉnh.
+            this.deleteEdge(edge);
+
+            // Đảo cạnh.
+            edge.reverse();
+
+            // Thêm cạnh đảo ngược trở lại đồ thị và các đỉnh của nó.
+            this.addEdge(edge);
+        });
+
+        return this;
+    }
+
+    /**
+     * @return {object}
+     */
+    getVerticesIndices() {
+        const verticesIndices = {};
+        this.getAllVertices().forEach((vertex, index) => {
+            verticesIndices[vertex.getKey()] = index;
+        });
+
+        return verticesIndices;
+    }
+
+    /**
+     * @return {*[][]}
+     */
+    getAdjacencyMatrix() {
+        const vertices = this.getAllVertices();
+        const verticesIndices = this.getVerticesIndices();
+
+        // Tạo ma trận với vô hạn số nghĩa là không có cách nào
+        // để đi từ đỉnh này sang đỉnh khác.
+        const adjacencyMatrix = Array(vertices.length).fill(null).map(() => {
+            return Array(vertices.length).fill(Infinity);
+        });
+
+        // Điền đấy các cột.
+        vertices.forEach((vertex, vertexIndex) => {
+            vertex.getNeighbors().forEach((neighbor) => {
+                const neighborIndex = verticesIndices[neighbor.getKey()];
+                adjacencyMatrix[vertexIndex][neighborIndex] = this.findEdge(vertex, neighbor).weight;
+            });
+        });
+
+        return adjacencyMatrix;
+    }
+
+    /**
+     * @return {string}
+     */
+    toString() {
+        return Object.keys(this.vertices).toString();
+    }
+}

src/data-structures/graph/GraphEdge.js

@@ -0,0 +1,40 @@
+export default class GraphEdge {
+    /**
+     * @param {GraphVertex} startVertex
+     * @param {GraphVertex} endVertex
+     * @param {number} [weight=1]
+     */
+    constructor(startVertex, endVertex, weight = 0) {
+        this.startVertex = startVertex;
+        this.endVertex = endVertex;
+        this.weight = weight;
+    }
+
+    /**
+     * @return {string}
+     */
+    getKey() {
+        const startVertexKey = this.startVertex.getKey();
+        const endVertexKey = this.endVertex.getKey();
+
+        return `${startVertexKey}_${endVertexKey}`;
+    }
+
+    /**
+     * @return {GraphEdge}
+     */
+    reverse() {
+        const tmp = this.startVertex;
+        this.startVertex = this.endVertex;
+        this.endVertex = tmp;
+
+        return this;
+    }
+
+    /**
+     * @return {string}
+     */
+    toString() {
+        return this.getKey();
+    }
+}

src/data-structures/graph/GraphVertex.js

@@ -0,0 +1,138 @@
+import LinkedList from '../linked-list/LinkedList';
+
+export default class GraphVertex {
+    /**
+     * @param {*} value
+     */
+    constructor(value) {
+        if (value === undefined) {
+            throw new Error('Graph vertex must have a value');
+        }
+
+        /**
+         * @param {GraphEdge} edgeA
+         * @param {GraphEdge} edgeB
+         */
+        const edgeComparator = (edgeA, edgeB) => {
+            if (edgeA.getKey() === edgeB.getKey()) {
+                return 0;
+            }
+
+            return edgeA.getKey() < edgeB.getKey() ? -1 : 1;
+        };
+
+        // Thông thường ta sẽ lưu chuỗi value như tên đỉnh
+        // Nhưng nó cũng có thể là bất kỳ đối tượng nào.
+        this.value = value;
+        this.edges = new LinkedList(edgeComparator);
+    }
+
+    /**
+     * @param {GraphEdge} edge
+     * @returns {GraphVertex}
+     */
+    addEdge(edge) {
+        this.edges.append(edge);
+
+        return this;
+    }
+
+    /**
+     * @param {GraphEdge} edge
+     */
+    deleteEdge(edge) {
+        this.edges.delete(edge);
+    }
+
+    /**
+     * @returns {GraphVertex[]}
+     */
+    getNeighbors() {
+        const edges = this.edges.toArray();
+
+        /** @param {LinkedListNode} node */
+        const neighborsConverter = (node) => {
+            return node.value.startVertex === this ? node.value.endVertex : node.value.startVertex;
+        };
+
+        // Trả về đỉnh bắt đầu hoặc kết thúc.
+        // Đối với đồ thị vô hướng, có thể đỉnh hiện tại sẽ là đỉnh cuối.
+        return edges.map(neighborsConverter);
+    }
+
+    /**
+     * @return {GraphEdge[]}
+     */
+    getEdges() {
+        return this.edges.toArray().map((linkedListNode) => linkedListNode.value);
+    }
+
+    /**
+     * @return {number}
+     */
+    getDegree() {
+        return this.edges.toArray().length;
+    }
+
+    /**
+     * @param {GraphEdge} requiredEdge
+     * @returns {boolean}
+     */
+    hasEdge(requiredEdge) {
+        const edgeNode = this.edges.find({
+            callback: (edge) => edge === requiredEdge,
+        });
+
+        return !!edgeNode;
+    }
+
+    /**
+     * @param {GraphVertex} vertex
+     * @returns {boolean}
+     */
+    hasNeighbor(vertex) {
+        const vertexNode = this.edges.find({
+            callback: (edge) => edge.startVertex === vertex || edge.endVertex === vertex,
+        });
+
+        return !!vertexNode;
+    }
+
+    /**
+     * @param {GraphVertex} vertex
+     * @returns {(GraphEdge|null)}
+     */
+    findEdge(vertex) {
+        const edgeFinder = (edge) => {
+            return edge.startVertex === vertex || edge.endVertex === vertex;
+        };
+
+        const edge = this.edges.find({ callback: edgeFinder });
+
+        return edge ? edge.value : null;
+    }
+
+    /**
+     * @returns {string}
+     */
+    getKey() {
+        return this.value;
+    }
+
+    /**
+     * @return {GraphVertex}
+     */
+    deleteAllEdges() {
+        this.getEdges().forEach((edge) => this.deleteEdge(edge));
+
+        return this;
+    }
+
+    /**
+     * @param {function} [callback]
+     * @returns {string}
+     */
+    toString(callback) {
+        return callback ? callback(this.value) : `${this.value}`;
+    }
+}

src/data-structures/graph/README.md

@@ -0,0 +1,13 @@
+# Đồ thị
+
+Trong khoa học máy tính, **đồ thị** là một kiểu dữ liệu trừu tượng để triển khai đồ thị vô hướng và có hướng trong toán học, đặc biệt trong mảng lý thuyết đồ thị.
+
+Cấu trúc dữ liệu đồ thị bao gồm một hữu hạn (có thể thay đổi) tập hợp đỉnh hoặc nút hoặc điểm, cùng với một tập hợp không tuần tự cặp đỉnh cho đồ thị vô hướng và tập hợp tuần tự cặp đỉnh cho đồ thị có hướng. Cặp đỉnh còn được biết đến là cạnh, vòng hoặc đoạn trong đồ thị vô hướng và là mũi tên, cạnh có hướng hoặc đoạn có hướng trong đồ thị có hướng. Các đỉnh có thể là một phần của cấu trúc đồ thị hoặc có thể là các thực thể bên ngoài được biểu diễn bằng các chỉ số nguyên hoặc tham chiếu.
+
+![Graph](https://www.tutorialspoint.com/data_structures_algorithms/images/graph.jpg)
+
+## Liên kết
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Graph_(abstract_data_type))
+- [Introduction to Graphs on YouTube](https://www.youtube.com/watch?v=gXgEDyodOJU&index=9&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [Graphs representation on YouTube](https://www.youtube.com/watch?v=k1wraWzqtvQ&index=10&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)