Merge pull request wangzheng0822#271 from WayneCui/master

FEAT: add ac_automata_unicode and DSF by JS

javascript/36_ac_automata/ac_automata_unicode.js

@@ -0,0 +1,109 @@
+
+class ACNode {
+    constructor(data){
+        this.data = data;
+        this.children = new Map();
+        this.isEndingChar = false;
+        this.length = 0;
+        this.fail = null;
+    }
+}
+
+class ACTree {
+
+    constructor(data){
+        this.root = new ACNode('/')
+    }
+
+    insert (text) {
+        let node = this.root;
+        for (let char of text) {
+            if(!node.children.get(char)) {
+                node.children.set(char, new ACNode(char));
+            }
+            node = node.children.get(char);
+        }
+
+        node.isEndingChar = true;
+        node.length = text.length;
+    }
+
+    buildFailurePointer() {
+        let root = this.root;
+        let queue = [];
+        queue.push(root);
+
+        while (queue.length > 0) {
+            let p = queue.shift();
+
+            for(var pc of p.children.values()){
+                if (!pc) {
+                    continue;
+                } 
+
+                if(p == root) {
+                    pc.fail = root;
+                } else {
+                    let q = p.fail;
+                    while (q) {
+                        let qc = q.children.get(pc.data);
+                        if(qc) {
+                            pc.fail = qc;
+                            break;
+                        }
+                        q = q.fail;
+                    }
+                    if(!q) {
+                        pc.fail = root;
+                    }
+                }
+                queue.push(pc);
+            }
+        }
+    }
+
+    match (text) {
+        let root = this.root;
+        let n = text.length;
+        let p = root;
+
+        for(let i = 0; i < n; i++) {
+            let char = text[i];
+            while(!p.children.get(char) && p != root){
+                p = p.fail;
+            }
+
+            p = p.children.get(char);
+            if(!p) {
+                p = root;
+            }
+
+            let tmp = p;
+            while ( tmp != root) {
+                if (tmp.isEndingChar == true) {
+                    console.log(`Start from ${i - p.length + 1}, length: ${p.length}`);
+                }
+                tmp = tmp.fail;
+            }
+        }
+    }
+}
+
+function match( text, patterns) {
+    let automata = new ACTree();
+    for (let pattern of patterns) {
+        automata.insert(pattern);
+    }
+
+    automata.buildFailurePointer();
+    automata.match(text);
+}
+
+let patterns = ["at", "art", "oars", "soar"];
+let text = "soarsoars";
+match(text, patterns);
+
+let patterns2 = ["Fxtec Pro1", "谷歌Pixel"];
+let text2 = "一家总部位于伦敦的公司Fxtex在MWC上就推出了一款名为Fxtec Pro1的手机，该机最大的亮点就是采用了侧滑式全键盘设计。DxOMark年度总榜发布 华为P20 Pro/谷歌Pixel 3争冠";
+match(text2, patterns2);
+

javascript/43_topological_sorting/dsf.js

@@ -0,0 +1,91 @@
+
+function Graph() {
+    var graph = {
+        adj: new Map(),
+        addEdge: function (from, to){
+            if(!this.adj.get(from)) {
+                this.adj.set(from, [ to ]);
+            } else {
+                this.adj.get(from).push(to);
+            }
+        },
+        sortingByDsf: function(){
+            var inverseAdj = new Map();
+            var keys = this.adj.keys();
+            for(let key of keys) {
+                let blk = this.adj.get(key);
+                if(blk) {
+                    for(let v of blk) {
+                        if(!inverseAdj.get(v)) {
+                            inverseAdj.set(v, [key]);
+                        } else {
+                            inverseAdj.get(v).push(key);
+                        }
+                    }
+                }
+            }
+
+            let inKeys = inverseAdj.keys();
+            let vertexes = new Set([...keys, ...inKeys]);
+            let visited = [];
+            for(let vertex of vertexes) {
+                if(!visited.includes(vertex)) {
+                    visited.push(vertex);
+                    this.dsf(vertex, inverseAdj, visited);
+                }
+            }
+        },
+        dsf: function(vertex, inverseAdj, visited) {
+            if(!inverseAdj.get(vertex)) {
+                inverseAdj.set(vertex, []);
+            }
+
+            for(let v of inverseAdj.get(vertex)) {
+                if(visited.includes(v)) {
+                    continue;
+                }
+
+                visited.push(v);
+
+                this.dsf(v, inverseAdj, visited);
+            }
+
+            console.log("->" + vertex);
+        }
+    }
+
+    return graph;
+}
+
+var dag = new Graph();
+dag.addEdge(2, 1);
+dag.addEdge(3, 2);
+dag.addEdge(2, 4);
+dag.addEdge(4, 1);
+dag.sortingByDsf();
+
+
+var dag2 = new Graph();
+dag2.addEdge("main", "parse_options");
+dag2.addEdge("main", "tail_file");
+dag2.addEdge("main", "tail_forever");
+dag2.addEdge("tail_file", "pretty_name");
+dag2.addEdge("tail_file", "write_header");
+dag2.addEdge("tail_file", "tail");
+dag2.addEdge("tail_forever", "recheck");
+dag2.addEdge("tail_forever", "pretty_name");
+dag2.addEdge("tail_forever", "write_header");
+dag2.addEdge("tail_forever", "dump_remainder");
+dag2.addEdge("tail", "tail_lines");
+dag2.addEdge("tail", "tail_bytes");
+dag2.addEdge("tail_lines", "start_lines");
+dag2.addEdge("tail_lines", "dump_remainder");
+dag2.addEdge("tail_lines", "file_lines");
+dag2.addEdge("tail_lines", "pipe_lines");
+dag2.addEdge("tail_bytes", "xlseek");
+dag2.addEdge("tail_bytes", "start_bytes");
+dag2.addEdge("tail_bytes", "dump_remainder");
+dag2.addEdge("tail_bytes", "pipe_bytes");
+dag2.addEdge("file_lines", "dump_remainder");
+dag2.addEdge("recheck", "pretty_name");
+dag2.sortingByDsf();