data-structure-typed 1.18.6 → 1.18.8

package/README.md

@@ -204,22 +204,6 @@ wide range of data structures
 DFS, DFSIterative, BFS, morris, Bellman-Ford Algorithm, Dijkstra's Algorithm, Floyd-Warshall Algorithm, Tarjan's Algorithm
 
 # How
-
-[API Docs](https://data-structure-typed-docs.vercel.app)
-
-[Live Examples](https://data-structure-typed-examples.vercel.app)
-
-
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/dfs-pre-order.webp)
-
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/test-graphs.webp)
-
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/cut-off-trees-for-golf.webp)
-
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/parenthesis-check.webp)
-
-<a href="https://data-structure-typed-examples.vercel.app" target="_blank">Live Examples</a>
-
 ## install
 
 ### yarn
@@ -236,366 +220,159 @@ npm install data-structure-typed
 
 ### Binary Search Tree (BST) snippet
 
+#### TS
 ```typescript
     import {BST, BSTNode} from 'data-structure-typed';
 
-    const tree = new BST();
-    expect(tree).toBeInstanceOf(BST);
-
-    const ids = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    tree.addMany(ids);
-    expect(tree.root).toBeInstanceOf(BSTNode);
-    if (tree.root) expect(tree.root.id).toBe(11);
-    expect(tree.count).toBe(16);
-    expect(tree.has(6)).toBe(true);
-
-    const node6 = tree.get(6);
-    expect(node6 && tree.getHeight(node6)).toBe(2);
-    expect(node6 && tree.getDepth(node6)).toBe(3);
-
-    const nodeId10 = tree.get(10, 'id');
-    expect(nodeId10?.id).toBe(10);
-
-    const nodeVal9 = tree.get(9, 'val');
-    expect(nodeVal9?.id).toBe(9);
-
-    const nodesByCount1 = tree.getNodes(1, 'count');
-    expect(nodesByCount1.length).toBe(16);
-
-    const leftMost = tree.getLeftMost();
+    const bst = new BST();
+    bst.add(11);
+    bst.add(3);
+    bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
+    bst.size === 16;        // true
+    bst.has(6);             // true
+    const node6 = bst.get(6);
+    bst.getHeight(6) === 2; // true
+    bst.getHeight() === 5;  // true
+    bst.getDepth(6) === 3;  // true
+    const leftMost = bst.getLeftMost();
+    leftMost?.id === 1;     // true
     expect(leftMost?.id).toBe(1);
+    bst.remove(6);
+    bst.get(6);             // null
+    bst.isAVLBalanced();    // true or false
+    const bfsIDs = bst.BFS();
+    bfsIDs[0] === 11;   // true
+    expect(bfsIDs[0]).toBe(11);
+    
+    const objBST = new BST<BSTNode<{ id: number, keyA: number }>>();
+    objBST.add(11, {id: 11, keyA: 11});
+    objBST.add(3, {id: 3, keyA: 3});
+    
+    objBST.addMany([{id: 15, keyA: 15}, {id: 1, keyA: 1}, {id: 8, keyA: 8},
+        {id: 13, keyA: 13}, {id: 16, keyA: 16}, {id: 2, keyA: 2},
+        {id: 6, keyA: 6}, {id: 9, keyA: 9}, {id: 12, keyA: 12},
+        {id: 14, keyA: 14}, {id: 4, keyA: 4}, {id: 7, keyA: 7},
+        {id: 10, keyA: 10}, {id: 5, keyA: 5}]);
+    
+    objBST.remove(11);
+    
+    
+    const avlTree = new AVLTree();
+    avlTree.addMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5])
+    avlTree.isAVLBalanced();    // true
+    avlTree.remove(10);
+    avlTree.isAVLBalanced();    // true
 
-    const node15 = tree.get(15);
-    const minNodeBySpecificNode = node15 && tree.getLeftMost(node15);
-    expect(minNodeBySpecificNode?.id).toBe(12);
-
-    const subTreeSum = node15 && tree.subTreeSum(node15);
-    expect(subTreeSum).toBe(70);
-
-    const lesserSum = tree.lesserSum(10);
-    expect(lesserSum).toBe(45);
-
-    expect(node15).toBeInstanceOf(BSTNode);
-    if (node15 instanceof BSTNode) {
-        const subTreeAdd = tree.subTreeAdd(node15, 1, 'count');
-        expect(subTreeAdd).toBeDefined();
-    }
-
-    const node11 = tree.get(11);
-    expect(node11).toBeInstanceOf(BSTNode);
-    if (node11 instanceof BSTNode) {
-        const allGreaterNodesAdded = tree.allGreaterNodesAdd(node11, 2, 'count');
-        expect(allGreaterNodesAdded).toBeDefined();
-    }
-
-    const dfsInorderNodes = tree.DFS('in', 'node');
-    expect(dfsInorderNodes[0].id).toBe(1);
-    expect(dfsInorderNodes[dfsInorderNodes.length - 1].id).toBe(16);
-
-    tree.balance();
-    expect(tree.isBalanced()).toBe(true);
-
-    const bfsNodesAfterBalanced = tree.BFS('node');
-    expect(bfsNodesAfterBalanced[0].id).toBe(8);
-    expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].id).toBe(16);
-
-    const removed11 = tree.remove(11, true);
-    expect(removed11).toBeInstanceOf(Array);
-    expect(removed11[0]).toBeDefined();
-    expect(removed11[0].deleted).toBeDefined();
-
-    if (removed11[0].deleted) expect(removed11[0].deleted.id).toBe(11);
-
-    expect(tree.isAVLBalanced()).toBe(true);
-
-    expect(node15 && tree.getHeight(node15)).toBe(2);
-
-    const removed1 = tree.remove(1, true);
-    expect(removed1).toBeInstanceOf(Array);
-    expect(removed1[0]).toBeDefined();
-    expect(removed1[0].deleted).toBeDefined();
-    if (removed1[0].deleted) expect(removed1[0].deleted.id).toBe(1);
-
-    expect(tree.isAVLBalanced()).toBe(true);
-
-    expect(tree.getHeight()).toBe(4);
-
-    // The code for removing these nodes (4, 10, 15, 5, 13, 3, 8, 6, 7, 9, 14) in sequence has been omitted.
-
-    expect(tree.isAVLBalanced()).toBe(false);
-
-    const bfsIDs = tree.BFS();
-    expect(bfsIDs[0]).toBe(2);
-    expect(bfsIDs[1]).toBe(12);
-    expect(bfsIDs[2]).toBe(16);
+```
+#### JS
+```javascript
+    const {BST, BSTNode} = require('data-structure-typed');
+
+    const bst = new BST();
+    bst.add(11);
+    bst.add(3);
+    bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
+    bst.size === 16;        // true
+    bst.has(6);             // true
+    const node6 = bst.get(6);
+    bst.getHeight(6) === 2; // true
+    bst.getHeight() === 5;  // true
+    bst.getDepth(6) === 3;  // true
+    const leftMost = bst.getLeftMost();
+    leftMost?.id === 1;     // true
+    expect(leftMost?.id).toBe(1);
+    bst.remove(6);
+    bst.get(6);             // null
+    bst.isAVLBalanced();    // true or false
+    const bfsIDs = bst.BFS();
+    bfsIDs[0] === 11;   // true
+    expect(bfsIDs[0]).toBe(11);
+    
+    const objBST = new BST();
+    objBST.add(11, {id: 11, keyA: 11});
+    objBST.add(3, {id: 3, keyA: 3});
+    
+    objBST.addMany([{id: 15, keyA: 15}, {id: 1, keyA: 1}, {id: 8, keyA: 8},
+        {id: 13, keyA: 13}, {id: 16, keyA: 16}, {id: 2, keyA: 2},
+        {id: 6, keyA: 6}, {id: 9, keyA: 9}, {id: 12, keyA: 12},
+        {id: 14, keyA: 14}, {id: 4, keyA: 4}, {id: 7, keyA: 7},
+        {id: 10, keyA: 10}, {id: 5, keyA: 5}]);
+    
+    objBST.remove(11);
+    
+    
+    const avlTree = new AVLTree();
+    avlTree.addMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5])
+    avlTree.isAVLBalanced();    // true
+    avlTree.remove(10);
+    avlTree.isAVLBalanced();    // true
 
-    const bfsNodes = tree.BFS('node');
-    expect(bfsNodes[0].id).toBe(2);
-    expect(bfsNodes[1].id).toBe(12);
-    expect(bfsNodes[2].id).toBe(16);
 ```
 
 ### Directed Graph simple snippet
 
+#### TS or JS
 ```typescript
-import {DirectedGraph, DirectedVertex, DirectedEdge, VertexId} from 'data-structure-typed';
-
-let graph: DirectedGraph<DirectedVertex, DirectedEdge>;
-
-    beforeEach(() => {
-        graph = new DirectedGraph();
-    });
-
-
-    it('should add vertices', () => {
-        const vertex1 = new DirectedVertex('A');
-        const vertex2 = new DirectedVertex('B');
-
-        graph.addVertex(vertex1);
-        graph.addVertex(vertex2);
-
-        expect(graph.hasVertex(vertex1)).toBe(true);
-        expect(graph.hasVertex(vertex2)).toBe(true);
-    });
+import {DirectedGraph} from 'data-structure-typed';
+
+    const graph = new DirectedGraph();
+    
+    graph.addVertex('A');
+    graph.addVertex('B');
+    
+    graph.hasVertex('A');       // true
+    graph.hasVertex('B');       // true
+    graph.hasVertex('C');       // false
+    
+    graph.addEdge('A', 'B');
+    graph.hasEdge('A', 'B'); // true
+    graph.hasEdge('B', 'A'); // false
+    
+    graph.removeEdgeSrcToDest('A', 'B');
+    graph.hasEdge('A', 'B');    // false
+    
+    graph.addVertex('C');
+    
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'C');
+    
+    const topologicalOrderIds = graph.topologicalSort(); // ['A', 'B', 'C']
+```
 
-    it('should add edges', () => {
-        const vertex1 = new DirectedVertex('A');
-        const vertex2 = new DirectedVertex('B');
-        const edge = new DirectedEdge('A', 'B');
+### Undirected Graph snippet
 
-        graph.addVertex(vertex1);
-        graph.addVertex(vertex2);
-        graph.addEdge(edge);
+#### TS or JS
+```typescript
+import {UndirectedGraph} from 'data-structure-typed';
+
+    const graph = new UndirectedGraph();
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+    graph.removeVertex('C');
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'D');
+    
+    const dijkstraResult = graph.dijkstra('A');
+    Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.id) // ['A', 'B', 'D']
+```
 
-        expect(graph.hasEdge('A', 'B')).toBe(true);
-        expect(graph.hasEdge('B', 'A')).toBe(false);
-    });
+[API Docs](https://data-structure-typed-docs.vercel.app)
 
-    it('should remove edges', () => {
-        const vertex1 = new DirectedVertex('A');
-        const vertex2 = new DirectedVertex('B');
-        const edge = new DirectedEdge('A', 'B');
+[Live Examples](https://data-structure-typed-examples.vercel.app)
 
-        graph.addVertex(vertex1);
-        graph.addVertex(vertex2);
-        graph.addEdge(edge);
 
-        expect(graph.removeEdge(edge)).toBe(edge);
-        expect(graph.hasEdge('A', 'B')).toBe(false);
-    });
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/dfs-pre-order.webp)
 
-    it('should perform topological sort', () => {
-        const vertexA = new DirectedVertex('A');
-        const vertexB = new DirectedVertex('B');
-        const vertexC = new DirectedVertex('C');
-        const edgeAB = new DirectedEdge('A', 'B');
-        const edgeBC = new DirectedEdge('B', 'C');
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/test-graphs.webp)
 
-        graph.addVertex(vertexA);
-        graph.addVertex(vertexB);
-        graph.addVertex(vertexC);
-        graph.addEdge(edgeAB);
-        graph.addEdge(edgeBC);
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/cut-off-trees-for-golf.webp)
 
-        const topologicalOrder = graph.topologicalSort();
-        if (topologicalOrder) expect(topologicalOrder.map(v => v.id)).toEqual(['A', 'B', 'C']);
-    });
-```
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/parenthesis-check.webp)
 
-### Directed Graph complex snippet
+<a href="https://data-structure-typed-examples.vercel.app" target="_blank">Live Examples</a>
 
-```typescript
-import {DirectedGraph, DirectedVertex, DirectedEdge, VertexId} from 'data-structure-typed';
-
-class MyVertex extends DirectedVertex {
-    private _data: string;
-    get data(): string {
-        return this._data;
-    }
-    set data(value: string) {
-        this._data = value;
-    }
-
-    constructor(id: VertexId, data: string) {
-        super(id);
-        this._data = data;
-    }
-}
-
-class MyEdge extends DirectedEdge {
-    private _data: string;
-    get data(): string {
-        return this._data;
-    }
-    set data(value: string) {
-        this._data = value;
-    }
-
-    constructor(v1: VertexId, v2: VertexId, weight: number, data: string) {
-        super(v1, v2, weight);
-        this._data = data;
-    }
-}
-
-describe('DirectedGraph Test3', () => {
-    const myGraph = new DirectedGraph<MyVertex, MyEdge>();
-
-    it('should test graph operations', () => {
-        const vertex1 = new MyVertex(1, 'data1');
-        const vertex2 = new MyVertex(2, 'data2');
-        const vertex3 = new MyVertex(3, 'data3');
-        const vertex4 = new MyVertex(4, 'data4');
-        const vertex5 = new MyVertex(5, 'data5');
-        const vertex6 = new MyVertex(6, 'data6');
-        const vertex7 = new MyVertex(7, 'data7');
-        const vertex8 = new MyVertex(8, 'data8');
-        const vertex9 = new MyVertex(9, 'data9');
-        myGraph.addVertex(vertex1);
-        myGraph.addVertex(vertex2);
-        myGraph.addVertex(vertex3);
-        myGraph.addVertex(vertex4);
-        myGraph.addVertex(vertex5);
-        myGraph.addVertex(vertex6);
-        myGraph.addVertex(vertex7);
-        myGraph.addVertex(vertex8);
-        myGraph.addVertex(vertex9);
-
-        myGraph.addEdge(new MyEdge(1, 2, 10, 'edge-data1-2'));
-        myGraph.addEdge(new MyEdge(2, 1, 20, 'edge-data2-1'));
-
-        expect(myGraph.getEdge(1, 2)).toBeTruthy();
-        expect(myGraph.getEdge(2, 1)).toBeTruthy();
-        expect(myGraph.getEdge(1, '100')).toBeFalsy();
-
-        myGraph.removeEdgeBetween(1, 2);
-        expect(myGraph.getEdge(1, 2)).toBeFalsy();
-
-        myGraph.addEdge(new MyEdge(3, 1, 3, 'edge-data-3-1'));
-        myGraph.addEdge(new MyEdge(1, 9, 19, 'edge-data1-9'));
-        myGraph.addEdge(new MyEdge(9, 7, 97, 'edge-data9-7'));
-        myGraph.addEdge(new MyEdge(7, 9, 79, 'edge-data7-9'));
-        myGraph.addEdge(new MyEdge(1, 4, 14, 'edge-data1-4'));
-        myGraph.addEdge(new MyEdge(4, 7, 47, 'edge-data4-7'));
-        myGraph.addEdge(new MyEdge(1, 2, 12, 'edge-data1-2'));
-        myGraph.addEdge(new MyEdge(2, 3, 23, 'edge-data2-3'));
-        myGraph.addEdge(new MyEdge(3, 5, 35, 'edge-data3-5'));
-        myGraph.addEdge(new MyEdge(5, 7, 57, 'edge-data5-7'));
-        myGraph.addEdge(new MyEdge(7, 3, 73, 'edge-data7-3'));
-        
-        const topologicalSorted = myGraph.topologicalSort();
-        expect(topologicalSorted).toBeNull();
-
-        const minPath1to7 = myGraph.getMinPathBetween(1, 7);
-        expect(minPath1to7).toBeInstanceOf(Array);
-        if (minPath1to7 && minPath1to7.length > 0) {
-            expect(minPath1to7).toHaveLength(3);
-            expect(minPath1to7[0]).toBeInstanceOf(MyVertex);
-            expect(minPath1to7[0].id).toBe(1);
-            expect(minPath1to7[1].id).toBe(9);
-            expect(minPath1to7[2].id).toBe(7);
-        }
-
-        const fordResult1 = myGraph.bellmanFord(1);
-        expect(fordResult1).toBeTruthy();
-        expect(fordResult1.hasNegativeCycle).toBeUndefined();
-        const {distMap, preMap, paths, min, minPath} = fordResult1;
-        expect(distMap).toBeInstanceOf(Map);
-        expect(distMap.size).toBe(9);
-        expect(distMap.get(vertex1)).toBe(0);
-        expect(distMap.get(vertex2)).toBe(12);
-        expect(distMap.get(vertex3)).toBe(35);
-        expect(distMap.get(vertex4)).toBe(14);
-        expect(distMap.get(vertex5)).toBe(70);
-        expect(distMap.get(vertex6)).toBe(Infinity);
-        expect(distMap.get(vertex7)).toBe(61);
-        expect(distMap.get(vertex8)).toBe(Infinity);
-        expect(distMap.get(vertex9)).toBe(19);
-
-        expect(preMap).toBeInstanceOf(Map);
-        expect(preMap.size).toBe(0);
-
-        expect(paths).toBeInstanceOf(Array);
-        expect(paths.length).toBe(0);
-        expect(min).toBe(Infinity);
-        expect(minPath).toBeInstanceOf(Array);
-        
-        const floydResult = myGraph.floyd();
-        expect(floydResult).toBeTruthy();
-        if (floydResult) {
-            const {costs, predecessor} = floydResult;
-            expect(costs).toBeInstanceOf(Array);
-            expect(costs.length).toBe(9);
-            expect(costs[0]).toEqual([32, 12, 35, 14, 70, Infinity, 61, Infinity, 19]);
-            expect(costs[1]).toEqual([20, 32, 23, 34, 58, Infinity, 81, Infinity, 39]);
-            expect(costs[2]).toEqual([3, 15, 38, 17, 35, Infinity, 64, Infinity, 22]);
-            expect(costs[3]).toEqual([123, 135, 120, 137, 155, Infinity, 47, Infinity, 126]);
-            expect(costs[4]).toEqual([133, 145, 130, 147, 165, Infinity, 57, Infinity, 136]);
-            expect(costs[5]).toEqual([Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity]);
-            expect(costs[6]).toEqual([76, 88, 73, 90, 108, Infinity, 137, Infinity, 79]);
-            expect(costs[7]).toEqual([Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity]);
-            expect(costs[8]).toEqual([173, 185, 170, 187, 205, Infinity, 97, Infinity, 176]);
-
-            expect(predecessor).toBeInstanceOf(Array);
-            expect(predecessor.length).toBe(9);
-            expect(predecessor[0]).toEqual([vertex2, null, vertex2, null, vertex3, null, vertex4, null, null]);
-            expect(predecessor[1]).toEqual([null, vertex1, null, vertex1, vertex3, null, vertex4, null, vertex1]);
-            expect(predecessor[5]).toEqual([null, null, null, null, null, null, null, null, null]);
-            expect(predecessor[7]).toEqual([null, null, null, null, null, null, null, null, null]);
-            expect(predecessor[8]).toEqual([vertex7, vertex7, vertex7, vertex7, vertex7, null, null, null, vertex7]);
-        }
-
-        const dijkstraRes12tt = myGraph.dijkstra(1, 2, true, true);
-        expect(dijkstraRes12tt).toBeTruthy();
-        if (dijkstraRes12tt) {
-            const {distMap, minDist, minPath, paths, preMap, seen} = dijkstraRes12tt;
-            expect(distMap).toBeInstanceOf(Map);
-            expect(distMap.size).toBe(9);
-            expect(distMap.get(vertex1)).toBe(0);
-            expect(distMap.get(vertex2)).toBe(12);
-            expect(distMap.get(vertex3)).toBe(Infinity);
-            expect(distMap.get(vertex4)).toBe(14);
-            expect(distMap.get(vertex5)).toBe(Infinity);
-            expect(distMap.get(vertex6)).toBe(Infinity);
-            expect(distMap.get(vertex7)).toBe(Infinity);
-            expect(distMap.get(vertex8)).toBe(Infinity);
-            expect(distMap.get(vertex9)).toBe(19);
-
-            expect(minDist).toBe(12);
-            expect(minPath).toBeInstanceOf(Array);
-            expect(minPath.length).toBe(2);
-            expect(minPath[0]).toBe(vertex1);
-            expect(minPath[1]).toBe(vertex2);
-
-            expect(paths).toBeInstanceOf(Array);
-            expect(paths.length).toBe(9);
-            expect(paths[0]).toBeInstanceOf(Array);
-            expect(paths[0][0]).toBe(vertex1);
-
-            expect(paths[1]).toBeInstanceOf(Array);
-            expect(paths[1][0]).toBe(vertex1);
-            expect(paths[1][1]).toBe(vertex2);
-
-            expect(paths[2]).toBeInstanceOf(Array);
-            expect(paths[2][0]).toBe(vertex3);
-            expect(paths[3]).toBeInstanceOf(Array);
-            expect(paths[3][0]).toBe(vertex1);
-            expect(paths[3][1]).toBe(vertex4);
-            expect(paths[4]).toBeInstanceOf(Array);
-            expect(paths[4][0]).toBe(vertex5);
-
-            expect(paths[5]).toBeInstanceOf(Array);
-            expect(paths[5][0]).toBe(vertex6);
-            expect(paths[6]).toBeInstanceOf(Array);
-            expect(paths[6][0]).toBe(vertex7);
-            expect(paths[7]).toBeInstanceOf(Array);
-            expect(paths[7][0]).toBe(vertex8);
-            expect(paths[8]).toBeInstanceOf(Array);
-            expect(paths[8][0]).toBe(vertex1);
-            expect(paths[8][1]).toBe(vertex9);
-        }
-    });
-});
-```
 
 ## API docs
 
@@ -875,29 +652,40 @@ describe('DirectedGraph Test3', () => {
 
 ![complexities of data structures](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/assets/data-structure-complexities.jpg)
 
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/binary-tree/bst-rotation.gif)
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/binary-tree/bst-rotation.gif&#41;)
 
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/binary-tree/avl-tree-inserting.gif)
+[//]: # ()
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/binary-tree/avl-tree-inserting.gif&#41;)
 
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/tarjan.webp)
+[//]: # ()
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/tarjan.webp&#41;)
 
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/adjacency-list.jpg)
+[//]: # ()
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/adjacency-list.jpg&#41;)
 
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/adjacency-list-pros-cons.jpg)
+[//]: # ()
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/adjacency-list-pros-cons.jpg&#41;)
 
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/adjacency-matrix.jpg)
+[//]: # ()
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/adjacency-matrix.jpg&#41;)
 
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/adjacency-matrix-pros-cons.jpg)
+[//]: # ()
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/adjacency-matrix-pros-cons.jpg&#41;)
 
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/dfs-can-do.jpg)
+[//]: # ()
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/dfs-can-do.jpg&#41;)
 
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/edge-list.jpg)
+[//]: # ()
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/edge-list.jpg&#41;)
 
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/edge-list-pros-cons.jpg)
+[//]: # ()
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/edge-list-pros-cons.jpg&#41;)
 
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/max-flow.jpg)
+[//]: # ()
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/max-flow.jpg&#41;)
 
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/mst.jpg)
+[//]: # ()
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/mst.jpg&#41;)
 
 [//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/tarjan-articulation-point-bridge.png&#41;)