图与搜索

• 图是什么

　　　　图，顾名思义，就是一张大大的网，网中的每个节点都与另外一个节点直接或者间接的联系。互联网就是一个大大的图，从A到B到C经过的路由，就是图的搜索算法。

　　　　要给图下一个定义，那就是在众多离散节点中可以产生回路的数据结构。比之线性数据结构的单线特性，树形结构的多路分叉特性，图的最大特点就是有回路的树形结构。图可以表示很多具体的事物，它是现实的一种抽象模型。比如地图寻址、路由寻址、状态机等。图是用来当做计算模型使用的，在某些高级场合十分适用。

• 图的定义

　　　　图的定义主要通过两种方式：1.邻接矩阵；2.邻接表。

　　　　还有一种非常复杂的定义：十字链表。

　　　　邻接矩阵的定义十分的直观，它通过二维矩阵来表示节点之间的消耗。比如a[i][j]表示从i节点到j节点的消耗，可以定义为0则没有通路。 在无向图中，通常这个矩阵是对称阵，即a[i][j] = a[j][i]；在有向图中，它是反对称阵，即a[i][j] = -a[j][i]。可以看到使用邻接矩阵来存储消耗了额外的一半空间，但是查询非常的方便。

　　　　邻接表，使用邻接表来存储图，则存储一个链表数组，每个头结点就是图的节点，它指向与它有联系的节点并存储消耗。这种方式节省了空间，但是查询节点是否有联系的时候必须遍历链表，这样增加了时间的消耗。

　　　　图的种类大概会有：无向图，有向图，双向图。

　　　　Java的邻接矩阵实现，用一个类存储矩阵，在构造函数时候传入大小，新建的是n*n的矩阵，然后就是写API了，无外乎CRUD。

package Graph;
import java.util.ArrayList;
import java.util.List;

/**
 * 邻接矩阵
 * @author ctk
 *
 */
public class AdjacencyMatrixGraph {
    private int edges ;
    private int[][] weight;
    private List<String> nodes;
    private int vertex;
    public AdjacencyMatrixGraph(int vertex){
        this.vertex = vertex;
        weight = new int[vertex][vertex];
        nodes = new ArrayList<>(vertex);
        edges = 0;
    }
    //获得节点数
    public int getNodes(){
        return nodes.size();
    }
    //获得边数
    public int getEdges(){
        return edges;
    }
    //插入节点
    public boolean insertNode(String name){
        if(nodes.size() == vertex)
            return false;
        nodes.add(name);
        return true;
    }
    //设置权重
    public boolean setWeight(int i,int j,int weight){
        if(i >= vertex || j >= vertex || i < 0 || j < 0)
            return false;
        if(this.weight[i][j] == 0)
            edges++;
        this.weight[i][j] = weight;
        return true;
    }
    //获得i节点
    public String getNode(int i){
        if(i > nodes.size())
            return null;
        else
            return nodes.get(i);
    }
    //获得边权重
    public int getWeight(int i,int j){
        if(i >= vertex || j >= vertex || i < 0 || j < 0)
            return -1;
        else
            return weight[i][j];
    }
    //删除边
    public void deleteEdge(int i,int j){
        if(i >= vertex || j >= vertex || i < 0 || j < 0){
            System.out.println("越界");
            return ;
        }
        weight[i][j] = 0;
    }
    //打印矩阵
    public void printMatrix(){
        for(int i=0;i<weight.length;i++)
        {
            for(int j=0;j<weight[i].length;j++){
                System.out.print(weight[i][j]+" ");
            }
            System.out.println();
        }
    }
    public static void main(String[] args) {
        AdjacencyMatrixGraph graph = new AdjacencyMatrixGraph(5);
        String node1 = "n1";
        String node2 = "n2";
        String node3 = "n3";
        String node4 = "n4";
        graph.insertNode(node1);
        graph.insertNode(node2);
        graph.insertNode(node3);
        graph.insertNode(node4);
        graph.setWeight(0, 1, 2);
        graph.setWeight(0, 2, 5);
        graph.setWeight(2, 3, 8);
        graph.setWeight(3, 0, 7);
        System.out.println("边数："+graph.getEdges());
        System.out.println("节点数："+graph.getNodes());
        graph.printMatrix();
    }
}

　　　　邻接表的实现，写一个节点类，然后初始化的时候新建这么大的数组，把每个空格放入新建的节点。

package Graph;

import java.util.ArrayList;
import java.util.List;

/**
 * 邻接表实现的图
 * @author ctk
 *
 */
public class ListGraph {
    private List<GraphNode> gNodes ;
    private int vertex ;
    private int edges ;
    public ListGraph(int vertex){
        this.vertex = vertex ;
        gNodes = new ArrayList<>(vertex);
        for(int i=0;i<vertex;i++)
        {
            GraphNode gnode = new GraphNode();
            gnode.setNodeIndex(i);
            gnode.setNext(null);
            gNodes.add(gnode);
        }
    }
    //添加边
    public void addEdge(int i,int j,int weight){
        if(i >= vertex || j >= vertex || i < 0 || j < 0)
        {
            System.out.println("输入的i和j超过范围");
            return;
        }
        GraphNode gnode = gNodes.get(i);
        boolean isAlter = false;
        while(gnode.getNext() != null)
        {
            if(gnode.getNodeIndex() == j)
            {
                gnode.setData(weight);
                isAlter = true;
                break;
            }
            gnode = gnode.getNext();
        }
        if(i == j){
            gnode.setData(weight);
            isAlter = true;
        }
        if(!isAlter){
            GraphNode edgeNode = new GraphNode();
            edgeNode.setData(weight);
            edgeNode.setNodeIndex(j);
            edgeNode.setNext(null);
            gnode.setNext(edgeNode);
        }
    }
    //生成邻接矩阵
    public int[][] getMartix(){
        int[][] martix = new int[vertex][vertex];
        GraphNode temp = null;
        for(int i=0;i<gNodes.size();i++){
            temp = gNodes.get(i);
            while(temp != null){
                martix[i][temp.getNodeIndex()] = temp.getData();
                temp = temp.getNext();
            }
        }
        return martix;
    }
    //获得某边
    public int getEdge(int i,int j){
        int weight = 0;
        if(i >= vertex || j >= vertex || i < 0 || j < 0)
        {
            System.out.println("输入的i和j超过范围");
            return weight;
        }
        GraphNode temp = gNodes.get(i);
        while(temp != null){
            if(temp.getNodeIndex() == j){
                weight = temp.getData();
                break;
            }
            temp = temp.getNext();
        }
        return weight;
    }
    public int getVertex() {
        return vertex;
    }
    public int getEdges() {
        return edges;
    }
    
    public static void main(String[] args) {
        ListGraph graph = new ListGraph(5);
        graph.addEdge(0, 1, 2);
        graph.addEdge(0, 2, 3);
        graph.addEdge(1, 1, 4);
        graph.addEdge(2, 3, 6);
        int[][] martix = graph.getMartix();
        for(int i =0;i<martix.length;i++){
            for(int j=0;j<martix[i].length;j++)
                System.out.print(martix[i][j]+" ");
            System.out.println();
        }
        System.out.println("获取边<1,1> :"+graph.getEdge(1, 1));
    }
}
//节点类
class GraphNode{
    private int nodeIndex;
    private int data;
    private GraphNode next;
    
    public int getNodeIndex() {
        return nodeIndex;
    }
    public void setNodeIndex(int nodeIndex) {
        this.nodeIndex = nodeIndex;
    }
    public int getData() {
        return data;
    }
    public void setData(int data) {
        this.data = data;
    }
    public GraphNode getNext() {
        return next;
    }
    public void setNext(GraphNode next) {
        this.next = next;
    }
}

　　　　　　　　　　　　　　　　　　　　

　　　　上图使用一种工具Graphviz来实现画图的，有兴趣的同学可以百度一下，有一个建模语言dot。

• 图遍历算法

　　　　对线性或者树形进行遍历，通常都十分简单，因为到null就停止了，而图是有回路的数据结构，如果使用之前的遍历策略，则很容易就死循环了。

　　　　对于图来说，遍历的策略通常是：深度优先（DFS），广度优先（BFS）。

　　　　深度优先（DFS）

　　　　对于一个节点来说，尽可能的往下走，走到尽头再去选择这个节点的另外一条路。

　　　　以上图来说，从根节点触发，先一个一个遍历完橙色，再遍历完绿色，最后遍历完蓝色。当然选择节点的时候有个能先绿色，也可能先蓝色，不过一旦选择一种颜色之后就会遍历到底。树形结构明白之后，图的DFS更加清楚了。

　　　　　　　　　　　　　　　　

　　　　以上图为例，从a节点出发的DFS，假设装入都是按顺序的，首先遍历的是a-b-c-d-g，然后遍历e-f-h。总之顺序就是a-b-c-d-g-e-f-h。

　　　　要实现深度优先的搜索，观察这个遍历顺序，知道每次把节点拿到之后子节点优先遍历，那是一个先进后出的顺序，使用栈来存储。比如a拿到之后他的子节点b，e入栈，假设b在栈顶，则弹出遍历b后把b的子节点c，g压入栈中。如此往复，直到所有的节点都Visited。

　　　　使用C++定义一个集合专门存放节点的。

const int MAX = 100;

//图节点
typedef struct {
    int edges[MAX][MAX];
    int n;
    int e;
    int visited[MAX];
}MGraph;

　　　　

　　　　这是邻接矩阵的存储方式。接着是深度优先遍历方法。并采用上述例子模型。

void DFS2(MGraph &G,int v){
    stack<int> temp;
    cout<<"节点:"<<v<<" ";
    G.visited[v] = 1;
    temp.push(v);
    while(!temp.empty()){
        int i,j;
        i=temp.top();
        for(j=0;j<G.n;j++){
            if(G.edges[i][j] != 0 && G.visited[j] == 0)
            {
                cout<<"节点:"<<j<<" ";
                G.visited[j] = 1;
                temp.push(j);
                break;
            }
        }
        if(j==G.n)
            temp.pop();
    }
    cout<<endl;
    
}

　　　　由于深度优先是一个栈模型，所以递归很符合它的运算模型，所以可以使用递归来计算。

void DFS1(MGraph &G,int v){
    int i;
    cout<<"节点："<<v<<" ";
    G.visited[v] = 1;
    for(i=0;i<G.n;i++)
    {
        if(G.edges[v][i] !=0 && G.visited[i] == 0)
        {
            DFS1(G, i);
        }
    }

}

　　　　程序的运行结果是。

　　　　广度优先（BFS）

　　　　广度优先顾名思义，类似于树的层序遍历。把这个节点的子节点全部遍历之后，再把子节点的孩子遍历。在战争中类似于把周围的领土先占领完毕再进行扩张。

　　　　由于广度优先这个特性，使得它的实现是使用队列这种先进先出的计算模式。把父节点进入队列，然后出队列的时候把父节点的孩子节点依次加入队列尾部。

　　　　广度优先的C++代码。

void BFS(MGraph &G,int v){
    queue<int> Q;
    cout<<"节点:"<<v<<" ";
    Q.push(v);
    while(!Q.empty()){
        int i,j;
        i=Q.front();
        Q.pop();
        for(j=0;j<G.n;j++){
            if(G.edges[i][j] != 0 && G.visited[j] == 0){
                cout<<"节点:"<<j<<" ";
                G.visited[j] = 1;
                Q.push(j);
            }
        }
    }
    cout<<endl;
}

　　　　同上例，BFS的结果是。

　　　　从性能上来讲，深度优先优于广度优先，因为广度优先的队列会比栈容量要大，采用哪种搜索主要看需求。