数据结构 -图

图-定义：

图由 边的集合 及 顶点的集合 组成;
图 分
有向图 和 无序图;
1:如果顶点对 是有序的，则是有向图，无序的则是无序图;

边：
顶点与顶点之间的连接;
路径：
一系列的顶点构成路径;
路径中的所有顶点都是由边连接的; 路径的长度：路径中第一个顶点到最后一个顶点之间边的数量；
环：
由自身顶点指向的路径称为环；环的长度=0；
圈：
至少有一条边的路径，且 第一个顶点与最后一个顶点相同；
1：简单圈： 无论是有向图 还是 无序图，只要没有重复边 或重复顶点的圈，即为简单圈；
2：平凡圈：除了第一个和最后一个顶点，路径的其他顶点有重复的圈，则称为平凡圈；

强连通：
如果两个顶点之间有路径，则两个顶点即为强连通；
如果有向图的所有顶点是强连通的，那么这个有向图就是强连通的；

创建图类：

第一步：
创建一个类来保存顶点和边；
tip:图的实际信息都保存在边上，它描述了图的结构；
图的结构要灵活的多：一个顶点可以有一条边，也可以有多条边与它相连；

使用：邻接表，或邻接表数组来存放一个顶点所连接的所有边，并且以这个顶点做索引，同时也可以高效地访问与这个顶点相邻的顶点的列表；

另一种方法：邻接矩阵，矩阵元素表示两个顶点之间是否有边；

搜索图：
从指定一个顶点是否可以到达另一个顶点，有哪几种路劲；

有两种基础搜索：广度优先搜索 深度优先搜索；

深度优先：从一个路径的开始顶点开始追溯，知道到达最后一个顶点，然后回溯； 继续追溯下一条路径；如此反复，直到没有路径；
实现理念：范文一个没有访问过的顶点，然后标记；在递归地访问初始顶点的邻接表中没有访问过的顶点。

广度优先：从第一个顶点开始，尝试访问尽可能靠近它的顶点；
在图上的搜索是 逐层移动的，先检查离顶点的第一层，再逐渐向下移动到离起始顶点最远的层进行检查；
实现理念：这里使用抽象的队列而不是数组来对已经访问过的定点进行排序；
step1:查找与当前顶点相邻的所有未访问的顶点，将其添加到已访问列表及队列中；
step2:从图中取出下一个顶点v，添加到已访问的顶点列表；
step3:将所有与顶点v相邻的未访问顶点添加到队列中；
在执行广度优先，会自动查找从一个顶点到另一个相邻顶点的最短路劲；

function Graph(v){
    this.vertices=v;//图的顶点数量
    this.edges=0;//边的数量
    this.adj=[];//存放边的数据，连接着什么顶点；

    this.edgTo=[];//广度优先用：保存一个顶点到另一个顶点的所有边；
    for (var i=0;i<this.vertices;i++) {
        this.adj[i]=[];
        this.adj[i].push(" ");
    }
    this.addEdge=addEdge;
    this.showGraph=showGraph;
    this.pathTo=pathTo;
    this.hasPathTo=hasPathTo;

    //广度优先搜索
    this.bfs=bfs;


//  深度优先搜索
    this.dfs=dfs;

    //初始化标记顶顶啊是否被访问过；
    this.marked=[];//
    for (var i=0;i<this.vertices;++i) {
        this.marked[i]=false;
    }
}

function addEdge(v,w){
    this.adj[v].push(w);
    this.adj[w].push(v);
    this.edges++;
}
function showGraph(){
    for (var i=0;i<this.vertices;i++) {
        var m=i+"->";
        for (var j=0;j<this.vertices;j++) {
            if(this.adj[i][j]!=undefined){
            m+=this.adj[i][j]+' ';
            }

        }console.log(m);

    }
}
//深度优先搜索 递归的关键是：  找出每次重复的环节，以及自然结束递归的条件；
//重复环节是：找顶点的临边没有访问的顶点，输出，在这个顶点继续，抓住this对象切换；
function dfs(v){
    this.marked[v]=true;
    if (this.adj[v]!=undefined) {
        console.log("visited Vertex:"+v);
    } //继续搜索邻边的下面有没有，临边的其他顶点标记为false则继续访问，
    for (var w in this.adj[v]){
        if (!this.marked[w]) {
            this.dfs(w);
        }
    }
}

//广度优先搜索
function bfs(s){
    var queue=[];
    this.marked[s]=true;

    queue.push(s);
    while(queue.length>0)
    {
        var v=queue.shift();
        if (v!=undefined) {
            console.log("visited vectex:"+v);
        }
        for (var w in this.adj[v]) {
            if (!this.marked[w]) {//所有未访问节点
                this.edgTo[w]=v;//
                this.marked[w]=true;
                queue.push(w);//添加到队列中
            }
        }

    }
}
//最短路径使用
function pathTo(v){
    var source=0;
    if(!this.hasPathTo(v))
    {
        return undefined;
    }
    var path=[];
    for (var i=v;i!=source;i=this.edgTo[i]) {
        path.push(i);//把拥有公共边的所有顶点都放入栈中；

    }
    path.push(s);
    return path;
}

function hasPathTo(v){
    return this.marked[v];
}
g=new Graph(5);
g.addEdge(0,1);
g.addEdge(0,2);
g.addEdge(1,3);
g.addEdge(2,4);
g.bfs(0);
var vectex=4;g.showGraph();
var paths=g.pathTo(vectex);
try{
    while(paths.length>0){
    if (paths.length>0) {
        console.log(paths.pop()+'-');
    } else{
        console.log(paths.pop());
    }


}
}catch(e){
    console.log(e);
}


//g.bfs(0);