Javascript之數據結構與算法的圖（Graph）實現

原創 vincent_wsc 2019-01-10 21:36

Javascript之數據結構與算法的圖（Graph）實現

簡介

廣度優先搜索算法會從指定的第一個頂點開始遍歷圖，先訪問其所有的相鄰點，就像一次訪
問圖的一層。換句話說，就是先寬後深地訪問頂點。如圖：
在這裏插入圖片描述
相關代碼：

bfs(v,callback){
    let color=this.initializeColor();
    let adjList=items.get(this).adjList;
    let queue=new Queue();
    queue.enqueue(v);
    while(!queue.empty()){
        let u=queue.dequeue();
        let neighbors=adjList.get(u);
        color[u]='grey';
        for(let i=0;i<neighbors.length;i++){
            let w=neighbors[i];
            if(color[w]=='white'){
                color[w]='grey';
                queue.enqueue(w);
            }
        }
        color[u]='black';
        if(callback){
            callback(u);
        }
    }
}

深度優先搜索將會從第一個指定的頂點開始遍歷圖，沿着路徑直到這條路徑最後一個頂
點被訪問了，接着原路回退並探索下一條路徑。換句話說，它是先深度後廣度地訪問頂點問所有節點。如圖：
在這裏插入圖片描述
相關代碼：

dfs(callback){
    let color=this.initializeColor();
    let vertices=items.get(this).vertices;
    for(let i=0;i<vertices.length;i++){
        if(color[vertices[i]]=='white'){
            items.get(this).dfsVisit(items.get(this).adjList,items.get(this).dfsVisit,vertices[i],color,callback);
        }
    }
}
dfsVisit(adjList,dfsVisit,u,color,callback){
    color[u]='grey';
    if(callback){
        callback(u);
    }
    let neighbors=adjList.get(u);
    for(let i=0;i<neighbors.length;i++){
        let w=neighbors[i];
        if(color[w]=='white'){
            dfsVisit(adjList,dfsVisit,w,color,callback);
        }
    }
    color[u]='black';
}

廣度優先搜索算法實際應用-最短路徑（非權值）

問題背景：
給定一個圖G和源頂點v，找出對每個頂點u， u和v之間最短路徑的距離（以邊的數量計）。
解決辦法：
改良bfs算法即BFS：

BFS(v){//-不加權最短路徑
    let color=this.initializeColor();
    let queue=new Queue();
    let d=[];//存路徑
    let pred=[];
    queue.enqueue(v);
    let vertices=items.get(this).vertices;
    let adjList=items.get(this).adjList;
    for(let i=0;i<vertices.length;i++){
        d[vertices[i]]=0;
        pred[vertices[i]]=null;
    }
    while(!queue.empty()){
        let u=queue.dequeue();
        let neighbors=adjList.get(u);
        color[u]='grey';
        for(let i=0;i<neighbors.length;i++){
            let w=neighbors[i];
            if(color[w]=='white'){
                color[w]='grey';
                d[w]=d[u]+1;
                pred[w]=u;
                queue.enqueue(w);
            }
        }
        color[u]='black';
    }
    return {distances:d,predecessors:pred}
}

測試代碼：

var graph = new Graph();
var myVertices = ['A','B','C','D','E','F','G','H','I']; //{7}
for (var i=0; i<myVertices.length; i++){ //{8}
graph.addVertex(myVertices[i]);
}
graph.addEdge('A', 'B'); //{9}
graph.addEdge('A', 'C');
graph.addEdge('A', 'D');
graph.addEdge('C', 'D');
graph.addEdge('C', 'G');
graph.addEdge('D', 'G');
graph.addEdge('D', 'H');
graph.addEdge('B', 'E');
graph.addEdge('B', 'F');
graph.addEdge('E', 'I');
var shortestPathA = graph.BFS(myVertices[0]);
console.log(shortestPathA);
//輸出結果：
distances: [A: 0, B: 1, C: 1, D: 1, E: 2, F: 2, G: 2, H: 2 , I: 3],
predecessors: [A: null, B: "A", C: "A", D: "A", E: "B", F: "B", G: "C", H: "D", I: "E"]
//顯示頂點到其他頂點的路徑
var fromVertex = myVertices[0];
for (var i=1; i<myVertices.length; i++){ 
	var toVertex = myVertices[i],
		path = new Stack(); 
	for (var v=toVertex; v!== fromVertex;v=shortestPathA.predecessors[v]) { 
		path.push(v); 
	}
	path.push(fromVertex); 
	var s = path.pop(); 
	while (!path.isEmpty()){ 
		s += ' - ' + path.pop(); 
	}
	console.log(s); 
}

深度優先搜索算法實際應用-拓撲排序（有向無環圖）

編排一些任務或步驟的執行順序時，這稱爲拓撲排序
例如：
當我們開始學習一門計算機科學課程，在學習某些知識之前得按順序完成一些知識儲備（你不可以在上算法前先上算法）。當我們在開發一個項目時，需要按順序執行一些步驟，例如，首先我們得從客戶那裏得到需求，接着開發客戶要求的東西，最後交付項目。
解決辦法：
改良版dfs即DFS：

DFS(){
   let color=this.initializeColor();
    let d=[];
    let f=[];
    let p=[];
    items.get(this).time=0;
    let vertices=items.get(this).vertices;
    for(let i=0;i<vertices.length;i++){
        f[vertices[i]]=0;
        d[vertices[i]]=0;
        p[vertices[i]]=null;
    }
    for(let i=0;i<vertices.length;i++){
        if(color[vertices[i]]=='white'){
            items.get(this).DFSVisit(items.get(this).time,items.get(this).adjList,items.get(this).DFSVisit,vertices[i],color,d,f,p);
        }
    }
    return {
        discovered:d,
        finished:f,
        predecessors:p
    }
}

Dijkstra 算法

Dijkstra算法是一種計算從單個源到所有其他源的最短路徑的貪心算法。
例如：
在這裏插入圖片描述
將圖上信息轉化爲鄰接矩陣：

graph.graph = [[0, 2, 4, 0, 0, 0],
[2, 0, 2, 4, 2, 0],
[4, 2, 0, 0, 3, 0],
[0, 4, 0, 0, 3, 2],
[0, 2, 3, 3, 0, 2],
[0, 0, 0, 2, 2, 0]];

相關代碼：

//Dijkstra算法
dijkstra(src){
    let dist=[];
    let INF=Number.MAX_SAFE_INTEGER;
    let visited=[];
    let length=this.graph.length;
    for(let i=0;i<length;i++){//把所有的距離（ dist）初始化爲無限大（ JavaScript最大的數INF = Number.MAX_SAFE_INTEGER），將visited[]初始化爲false
        dist[i]=INF;
        visited[i]=false;
    }
    dist[src]=0;//把源頂點到自己的距離設爲0
    for(let i=0;i<length-1;i++){
        let u=items.get(this).minDistance(dist,visited);//從尚未處理的頂點中選出距離最近的頂點
        visited[u]=true;//把選出的頂點標爲visited，以免重複計算
        for(let v=0;v<length;v++){//查找更短的路徑
            if(!visited[v]&&this.graph[u][v]!=0&&dist[u]!=INF&&dist[u]+this.graph[u][v]<dist[v]){
                dist[v]=dist[u]+this.graph[u][v];//更新最短路徑的值
            }
        }
    }
    return dist;
}
minDistance(dist,visited){
    let INF=Number.MAX_SAFE_INTEGER;
    let min=INF;
    let minIndex=-1;
    for(let v=0;v<dist.length;v++){
        if(visited[v]==false&&dist[v]<=min){
            min=dist[v];
            minIndex=v;
        }
    }
    return minIndex;
}

Floyd-Warshall 算法

Floyd-Warshall算法是一種計算圖中所有最短路徑的動態規劃算法

//Floyd-Warshall算法
floydWarshall(){
    let INF=Number.MAX_SAFE_INTEGER;
    let dist=[],
        length=this.graph.length;
    for(let i=0;i<length;i++){//首先，把dist數組初始化爲每個頂點之間的權值，因爲i到j可能的最短距離就是這些頂點間的權值。
        dist[i]=[];
        for(let j=0;j<length;j++){
            if(this.graph[i][j]==0&&i!=j){
                dist[i][j]=INF;
            }else{
                dist[i][j]=this.graph[i][j];
            }
            
        }
    }
    for(let k=0;k<length;k++){//通過k，得到i途徑頂點0至k，到達j的最短路徑。
        for(let i=0;i<length;i++){
            for(let j=0;j<length;j++){
                if(dist[i][k]+dist[k][j]<dist[i][j]){//通過k，得到i途徑頂點0至k，到達j的最短路徑。
                    dist[i][j]=dist[i][k]+dist[k][j];//如果是更短的路徑，則更新最短路徑的值
                }
            }
        }
    }
    return dist;
}

最小生成樹（MST）-Prim算法

實用背景：
你的公司有幾間辦公室，要以最低的成本實現辦公室電話線路相互連通，以節省資金；
在n個島嶼之間建造橋樑，想用最低的成本實現所有島嶼相互連通。
圖結構如下：
在這裏插入圖片描述
Prim算法是一種求解加權無向連通圖的MST問題的貪心算法。它能找出一個邊的子集，使得
其構成的樹包含圖中所有頂點，且邊的權值之和最小。
相關代碼：

prim(){
    let parent=[],
        key=[],
        visited=[],
        length=this.graph.length,
        INF=Number.MAX_SAFE_INTEGER;//代表無窮大即無路
    for(let i=0;i<this.graph.length;i++){
        for(let j=0;j<this.graph[i].length;j++){
            if(this.graph[i][j]==0&&i!=j){
                this.graph[i][j]=INF;
            }
        }
    }
    for(let i=0;i<length;i++){
        key[i]=INF;
        visited[i]=false;
    }
    key[0]=0;
    parent[0]=-1;//選擇第一個key作爲第一個頂點，同時，因爲第一個頂點總是MST的根節點，所以parent[0] = -1。
    for(let i=0;i<length-1;i++){
        let u=items.get(this).minKey(key,visited);//從未處理的頂點集合中選出key值最小的頂點（與Dijkstra算法中使用的函數一樣，只是名字不同）
        visited[u]=true;
        for(let v=0;v<length;v++){
            if(this.graph[u][v]&&visited[v]==false&&this.graph[u][v]<key[v]){
                parent[v]=u;
                key[v]=this.graph[u][v];
            }
        }
    }
    //console.log(key)
    return {
        parent:parent,
        key:key
    };
}

全部代碼

let Dictionary=require('./Dictionary')
let Queue=require('./Queue')
let Stack=require('./Stack')
let items=new WeakMap();
/** 
* 白色：表示該頂點還沒有被訪問。
* 灰色：表示該頂點被訪問過，但並未被探索過。
* 黑色：表示該頂點被訪問過且被完全探索過
*/
class Graph{
    constructor(){
        items.set(this,{
            "vertices":[],
            "adjList":new Dictionary(),
            "time":0,
            "dfsVisit":function(adjList,dfsVisit,u,color,callback){
                color[u]='grey';
                if(callback){
                    callback(u);
                }
                let neighbors=adjList.get(u);
                for(let i=0;i<neighbors.length;i++){
                    let w=neighbors[i];
                    if(color[w]=='white'){
                        dfsVisit(adjList,dfsVisit,w,color,callback);
                    }
                }
                color[u]='black';
            },
            "DFSVisit":function(time,adjList,DFSVisit,u,color,d,f,p){
                console.log('discovered '+u);
                color[u]='grey';
                d[u]=++time;
                let neighbors=adjList.get(u);
                for(let i=0;i<neighbors.length;i++){
                    let w=neighbors[i];
                    if(color[w]=='white'){
                        p[w]=u;
                        DFSVisit(time,adjList,DFSVisit,w,color,d,f,p);
                    }
                }
                color[u]='black';
                f[u]=++time;
                console.log('explored '+u);
            },
            "minDistance":function(dist,visited){
                let INF=Number.MAX_SAFE_INTEGER;
                let min=INF;
                let minIndex=-1;
                for(let v=0;v<dist.length;v++){
                    if(visited[v]==false&&dist[v]<=min){
                        min=dist[v];
                        minIndex=v;
                    }
                }
                return minIndex;
            },
            "minKey":function(key,visited){
                let INF=Number.MAX_SAFE_INTEGER;
                let min=INF;
                let minIndex=-1;
                for(let v=0;v<key.length;v++){
                    if(visited[v]==false&&key[v]<=min){
                        min=key[v];
                        minIndex=v;
                    }
                }
                return minIndex;
            }
        });//私有屬性
        this.graph=[];//dijkstra算法使用
    }
    addVertex(v){
        items.get(this).vertices.push(v);
        items.get(this).adjList.set(v,[]);
    }
    addEdge(v,w){
        items.get(this).adjList.get(v).push(w);
        items.get(this).adjList.get(w).push(v);
    }
    toString(){
        let s='';
        let vertices=items.get(this).vertices;
        for(let i=0;i<vertices.length;i++){
            s+=vertices[i]+'->';
            let neighbors=items.get(this).adjList.get(vertices[i])
            for(let j=0;j<neighbors.length;j++){
                s+=neighbors[j]+' ';
            }
            s+='\n';
        }
        return s;
    }
    //初始化節點顏色
    initializeColor(){
        let color=[];
        let vertices=items.get(this).vertices;
        for(let i=0;i<vertices.length;i++){
            color[vertices[i]]='white';
        }
        return color;
    }
    //廣度優先搜索
    bfs(v,callback){
        let color=this.initializeColor();
        let adjList=items.get(this).adjList;
        let queue=new Queue();
        queue.enqueue(v);
        while(!queue.empty()){
            let u=queue.dequeue();
            let neighbors=adjList.get(u);
            color[u]='grey';
            for(let i=0;i<neighbors.length;i++){
                let w=neighbors[i];
                if(color[w]=='white'){
                    color[w]='grey';
                    queue.enqueue(w);
                }
            }
            color[u]='black';
            if(callback){
                callback(u);
            }
        }
    }
    BFS(v){//-不加權最短路徑
        let color=this.initializeColor();
        let queue=new Queue();
        let d=[];//存路徑
        let pred=[];
        queue.enqueue(v);
        let vertices=items.get(this).vertices;
        let adjList=items.get(this).adjList;
        for(let i=0;i<vertices.length;i++){
            d[vertices[i]]=0;
            pred[vertices[i]]=null;
        }
        while(!queue.empty()){
            let u=queue.dequeue();
            let neighbors=adjList.get(u);
            color[u]='grey';
            for(let i=0;i<neighbors.length;i++){
                let w=neighbors[i];
                if(color[w]=='white'){
                    color[w]='grey';
                    d[w]=d[u]+1;
                    pred[w]=u;
                    queue.enqueue(w);
                }
            }
            color[u]='black';
        }
        return {distances:d,predecessors:pred}
    }
    //深度優先搜索
    dfs(callback){
        let color=this.initializeColor();
        let vertices=items.get(this).vertices;
        for(let i=0;i<vertices.length;i++){
            if(color[vertices[i]]=='white'){
                items.get(this).dfsVisit(items.get(this).adjList,items.get(this).dfsVisit,vertices[i],color,callback);
            }
        }
    }
    //探索深度優先算法
    DFS(){
        let color=this.initializeColor();
        let d=[];
        let f=[];
        let p=[];
        items.get(this).time=0;
        let vertices=items.get(this).vertices;
        for(let i=0;i<vertices.length;i++){
            f[vertices[i]]=0;
            d[vertices[i]]=0;
            p[vertices[i]]=null;
        }
        for(let i=0;i<vertices.length;i++){
            if(color[vertices[i]]=='white'){
                items.get(this).DFSVisit(items.get(this).time,items.get(this).adjList,items.get(this).DFSVisit,vertices[i],color,d,f,p);
            }
        }
        return {
            discovered:d,
            finished:f,
            predecessors:p
        }
    }
    //Dijkstra算法
    dijkstra(src){
        let dist=[];
        let INF=Number.MAX_SAFE_INTEGER;
        let visited=[];
        let length=this.graph.length;
        for(let i=0;i<length;i++){//把所有的距離（ dist）初始化爲無限大（ JavaScript最大的數INF = Number.MAX_SAFE_INTEGER），將visited[]初始化爲false
            dist[i]=INF;
            visited[i]=false;
        }
        dist[src]=0;//把源頂點到自己的距離設爲0
        for(let i=0;i<length-1;i++){
            let u=items.get(this).minDistance(dist,visited);//從尚未處理的頂點中選出距離最近的頂點
            visited[u]=true;//把選出的頂點標爲visited，以免重複計算
            for(let v=0;v<length;v++){//查找更短的路徑
                if(!visited[v]&&this.graph[u][v]!=0&&dist[u]!=INF&&dist[u]+this.graph[u][v]<dist[v]){
                    dist[v]=dist[u]+this.graph[u][v];//更新最短路徑的值
                }
            }
        }
        return dist;
    }
    //Floyd-Warshall算法
    floydWarshall(){
        let INF=Number.MAX_SAFE_INTEGER;
        let dist=[],
            length=this.graph.length;
        for(let i=0;i<length;i++){//首先，把dist數組初始化爲每個頂點之間的權值，因爲i到j可能的最短距離就是這些頂點間的權值。
            dist[i]=[];
            for(let j=0;j<length;j++){
                if(this.graph[i][j]==0&&i!=j){
                    dist[i][j]=INF;
                }else{
                    dist[i][j]=this.graph[i][j];
                }
                
            }
        }
        for(let k=0;k<length;k++){//通過k，得到i途徑頂點0至k，到達j的最短路徑。
            for(let i=0;i<length;i++){
                for(let j=0;j<length;j++){
                    if(dist[i][k]+dist[k][j]<dist[i][j]){//通過k，得到i途徑頂點0至k，到達j的最短路徑。
                        dist[i][j]=dist[i][k]+dist[k][j];//如果是更短的路徑，則更新最短路徑的值
                    }
                }
            }
        }
        return dist;
    }
    //最小生成樹
    //Prim算法
    prim(){
        let parent=[],
            key=[],
            visited=[],
            length=this.graph.length,
            INF=Number.MAX_SAFE_INTEGER;
        for(let i=0;i<this.graph.length;i++){
            for(let j=0;j<this.graph[i].length;j++){
                if(this.graph[i][j]==0&&i!=j){
                    this.graph[i][j]=INF;
                }
            }
        }
        for(let i=0;i<length;i++){
            key[i]=INF;
            visited[i]=false;
        }
        key[0]=0;
        parent[0]=-1;//選擇第一個key作爲第一個頂點，同時，因爲第一個頂點總是MST的根節點，所以parent[0] = -1。
        for(let i=0;i<length-1;i++){
            let u=items.get(this).minKey(key,visited);//從未處理的頂點集合中選出key值最小的頂點（與Dijkstra算法中使用的函數一樣，只是名字不同）
            visited[u]=true;
            for(let v=0;v<length;v++){
                if(this.graph[u][v]&&visited[v]==false&&this.graph[u][v]<key[v]){
                    parent[v]=u;
                    key[v]=this.graph[u][v];
                }
            }
        }
        //console.log(key)
        return {
            parent:parent,
            key:key
        };
    }
}
let graph=new Graph();
// let myVertices=['A','B','C','E','D','F','G','H','I'];
// for(let i=0;i<myVertices.length;i++){
//     graph.addVertex(myVertices[i]);
// }
// graph.addEdge('A', 'B'); //{9}
// graph.addEdge('A', 'C');
// graph.addEdge('A', 'D');
// graph.addEdge('C', 'D');
// graph.addEdge('C', 'G');
// graph.addEdge('D', 'G');
// graph.addEdge('D', 'H');
// graph.addEdge('B', 'E');
// graph.addEdge('B', 'F');
// graph.addEdge('E', 'I');
// console.log(graph.toString())
// graph.bfs(myVertices[0],function(result){
//     console.log('Visited vertex:',result)
// })
// let shortestPathA=graph.BFS(myVertices[0]);
// console.log(shortestPathA)
// let fromVertex=myVertices[0];
// for(let i=1;i<myVertices.length;i++){
//     let toVertex=myVertices[i];
//     let path=new Stack();
//     for(let v=toVertex;v!=fromVertex;v=shortestPathA.predecessors[v]){
//         path.push(v);
//     }
//     path.push(fromVertex);
//     let s=path.pop();
//     while(!path.empty()){
//         s+='-'+path.pop();
//     }
//     console.log(s)
// }

// graph.dfs(function(result){
//     console.log('visited vertex:',result)
// })

//拓撲排序
// let myVertices=['A','B','C','D','E','F'];
// for(let i=0;i<myVertices.length;i++){
//     graph.addVertex(myVertices[i]);
// }
// graph.addEdge('A', 'C');
// graph.addEdge('A', 'D');
// graph.addEdge('B', 'D');
// graph.addEdge('B', 'E');
// graph.addEdge('C', 'F');
// graph.addEdge('F', 'E');
// var result = graph.DFS();
// console.log(result)

//dijkstra算法
// graph.graph=[[0, 2, 4, 0, 0, 0],
// [0, 0, 1, 4, 2, 0],
// [0, 0, 0, 0, 3, 0],
// [0, 0, 0, 0, 0, 2],
// [0, 0, 0, 3, 0, 2],
// [0, 0, 0, 0, 0, 0]];
//console.log(graph.dijkstra(0))
//floyd-warshall算法
//console.log(graph.floydWarshall());

//prim
graph.graph = [[0, 2, 4, 0, 0, 0],
[2, 0, 2, 4, 2, 0],
[4, 2, 0, 0, 3, 0],
[0, 4, 0, 0, 3, 2],
[0, 2, 3, 3, 0, 2],
[0, 0, 0, 2, 2, 0]];
let json=graph.prim();
console.log("Edge\t"+"Weight");
let key=json.key;
let parent=json.parent;
for(let i=1;i<key.length;i++){
    console.log(parent[i]+"-"+i+"\t"+key[i]);
}
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

多線程和多進程 - 初窺

一、說明 在平常工作中，我們使用top命令查看一臺linux服務器的cpu使用情況時，會發現某個進程的cpu使用率會超過100%，這是爲什麼？ 二、舉例 實驗環境爲 CentOS7.6 + Python2.7 1. 多線程、多進程在操作系統

小豹子加油 2024-05-20 14:36:10

Xming - xmanager的替代方案

一、概述 安裝某些數據庫的時候使用圖像化還是比較方便的，但是由於服務器一般不提供圖形化界面。之前一直都是使用Xmanager去導出圖形，但是Xmanager是收費的，公司不讓用，所以找了一款可以完美替代的產品Xming，本文將介紹xming

小豹子加油 2024-05-20 14:36:10

Mysql - 數據庫時區是客戶端屬性還是服務端屬性

一、說明 同事問我數據庫的時區是客戶端屬性還是服務端屬性，我覺得這個問題十分有意思，之前沒怎麼留意，自己來做下實驗。 首先介紹幾個術語。 GMT（Greenwich Mean Time），格林尼治平均時間。 UTC（Coordinated

小豹子加油 2024-05-20 14:36:10

sql求連續值問題

一. 找出表test1中tflag字段連續出現3次及以上爲1的行 思路：1. 對行進行編號，2. 對相鄰三行進行求和算出值作爲sumflag，3. 如果值爲3，則該行以及接下來的2行都輸出出來，通過自關聯解決。 WITH tmp AS (

小豹子加油 2024-05-20 14:36:10

SQL優化-20231016

數據結構 數據庫的表和索引缺一不可 表 特點： 無序，插入速度快，查找速度慢 索引（B+Tree） 特點：有序，插入速度慢，查找速度快 查找的效率比較，如果按照讀取的數據塊來計算？ 測試數據 TABLE_OWNER TABLE

小豹子加油 2024-05-20 14:36:10

兩臺數據庫在數據寫入時性能的差異

介紹：我有兩臺數據庫，分別稱爲200和203，200和203的服務器性能配置相當，203的配置甚至還要好一點。都是安裝的centos7.7，oracle 19C，均已開日誌歸檔，這兩臺服務器在同一個機房，同一個網段。當我在本地使用JDBC去

小豹子加油 2024-05-20 14:36:10

Linux安裝MySQL配置教程

1.使用系統的root賬戶 2.切換到 /use/local 目錄下 3.下載mysql  根據自己需要安裝的版本下載。 wget https://dev.mysql.com/get/Downloads/MySQL-8.0/mysq

莫等閒也 2024-05-20 14:34:20

salesforce零基礎學習（一百三十七）零碎知識點小總結（九）

本篇參考：  https://help.salesforce.com/s/articleView?id=release-notes.rn_lab_conditional_visibiliy_tab.htm&release=250&type=

zero.zhang 2024-05-20 14:34:10

sql server sp_executesql 中使用表變量進行查詢

示例demo： DECLARE @table IdTableType INSERT INTO @table SELECT Id FROM dbo.t_pl_test DECLARE @SearchSQL NVARCHAR(MAX) SE

自閉玩家 2024-05-20 14:32:10

Flink精確消費一次

 在大數據計算裏面，計算引擎是處於承上啓下的作用，對上承接數據源，對下承接各種各種數據庫，比如mysql、oracle。對於任何數據計算來說要想精確消費一次，就需要支持事務或者冪等，我們最常見的支持事務的就是單點的oracle、mysql數

人不瘋狂枉一生 2024-05-20 14:27:59

5款.NET開源、免費、功能強大的圖表庫

LiveCharts2 LiveCharts2是一個.NET開源（MIT License）、簡單、靈活、交互式且功能強大的.NET圖表、地圖和儀表，現在幾乎可以在任何地方運行如：Maui、Uno Platform、Blazor-wasm、W

追逐時光 2024-05-20 14:26:59

終於搞懂了！原來 Vue 3 的 generate 是這樣生成 render 函數的

前言 在之前的 面試官：來說說vue3是怎麼處理內置的v-for、v-model等指令？ 文章中講了transform階段處理完v-for、v-model等指令後，會生成一棵javascript AST抽象語法樹。這篇文章我們來接着講gen

你假裝沒察覺 2024-05-20 14:26:19

Markdown基礎語法2024測試

標題一 標題二 標題三 標題四 標題五 標題六 hr 加粗字體 b 斜體字體 i 引用內容 code 超鏈接 a blockquote ol > li 有序列表 ul > li 無須列表 pre 代碼塊 p 表格標

喵喵撲 2024-05-20 14:26:09

ue5生成vs工程報錯-msvc版本太舊

ue生成VS工程報錯 右鍵 - uproject ，Generating VisualStudio project files ，報錯信息如下：就是我安裝的msvc版本太舊 Running C:/Program Files/Epic Ga

趙青青 2024-05-20 14:25:39

vscode 清理遠程服務器內存

因網絡中斷或其他原因，有時候服務器上留下較多無用的vscode-server進程，佔用內存資源 可以採用如下命令kill進程 ps uxa | grep .vscode-server | awk '{print $2}' | xargs k

張博的博客 2024-05-20 14:24:58