09图

介绍：图是一系列顶点（结点）和描述顶点之间的关系边（弧）组成。图是数据元素的集合，这些数据元素相互连接形成网络。其形式化定义为：G=（V，E）。其中，G表示图，V是顶点的集合，E是边或弧的集合。并且E可以表示为：E=（Vi，Vj），表示顶点Vi和Vj之间有边或弧相连。

相关操作：

1. 图的创建

//采用邻接矩阵创建图：
public class Graph<E>{
    private E[] vexs;    //存储图的顶点的一维数组
    private int[][] edges;    //存储图的边的二维数组
    private int numOfVexs;    //顶点的实际数量
    private int maxNumOfVexs;    //顶点的最大数量
    private boolean[] visited;    //判断顶点是否被访问过
    
    //构造方法
    public Graph(int maxNumOfVexs,Class<E> type){
        this.maxNumOfVexs = maxNumOfVexs;
        edges = new int[maxNumOfVexs][maxNumOfVexs];
        vexs = (E[]) Array.newInstance(type,maxNumOfVexs);
    }
}

2. 常用方法

//2.1得到顶点个数:
public int getNumOfVertex(){
    return numOfVerxs;
}

//2.2插入顶点
public boolean insertVex(E v){
    if(numOfVexs >= maxNumOfVexs){
        return false;
    }
    vexs[numOfVexs++ = v;
    return true;
}

//2.3删除顶点
public boolean delete(E v){
    for(int i = 0;i < numOfVexs;i++){
        if(int j = i;j < numOfVexs - 1;j++){
            vexs[j] = vexs[j + 1];
        }
        vexs[numOfVexs - 1] = null;
        for(int col = i;col < numOfVexs - 1;col++){
            for(int row = 0;row < numOfVexs;row++){
                edges[col][row] = edges[col + 1][row];
            }
        }
        for(int row = i;row < numOfVexs - 1;row++){
            for(int col = 0;col < numOfVexs;col++){
                edges[col][row] = edges[col][row + 1];
            }
        }
        numOfVexs--;
        return true;
    }
}

//2.4定位顶点位置
public int indexOfVex(E v){
    for(int i = 9;i < numOfVexs;i++){
        if(vexs[i].equals(v)){
            return i;
        }
    }
    return -1;
}

//2.5定位指定位置的顶点
public E valueOfVex(int v){
    if(v < 0 || v >= numOfVexs){
        return null;
    }
    return vexs[v];
}

//2.6插入边
public boolean insertEdge(int v1,int v2,int weight){
    if(v1 < 0 || v2 < 0 || v1 >= numOfVexs || v2 >= numOfVexs){
        throw new ArrayIndexOutOfBoundsException();
    }
    edges[v1][v2] = weight;
    edges[v2][v1] = weight;
    return true;
}

//2.7删除边
public boolean deleteEdge(int v1,int v2){
    if(v1 < 0 || v2 < 0 || v1 >= numOfVexs || v2 >= numOfVexs){
        throw new ArrayIndexOutOfBoundsException();
    }
    edges[v1][v2] = 0;
    edges[v2][v1] = 0;
    return true;
}

//2.8查找边
public int getEdge(int v1,int v2){
    if(v1 < 0 || v2 < 0 || v1 >= numOfVexs || v2 >= numOfVexs){
        throw new ArrayIndexOutOfBoundsException();
    }
    return edges[v1][v2];
}

//2.9深度优先搜索
public String depthFirstSearch(int v){
    if(v < 0 || v >= numOfVexs){
        throw new ArrayIndexOutOfBoundsException();
    }
    visited = new boolean[numOfVexs];
    StringBuilder sb = new StringBuilder();
    Stack<Integer> stack = new Stack<Integer>();
    stack.push(v);
    visited[v] = true;
    while(!stack.isEmpty()){
        v = stack.pop();
        sb.append(vexs[v] + ",");
        for(int i = numOfVexs - 1;i >= 0;i--){
            if(edges[v][i] != 0 && edges[v][i] != Integer.MAX_VALUE && !visited[i]){
                stack.push(i);
                visited[i] = true;
            }
        }
    }
    return sb.length() > 0 ? sb.substring(0,sb.length() - 1) : null;
}

//2.10广度优先搜索
public String breadFirstSearch(int v){
    if(v < 0 || v >= numOfVexs){
        throw new ArrayIndexOutOfBoundsException();
    }
    visited = new boolean[numOfVexs];
    StringBuilder sb = new StringBuilder();
    Queue<Integer> queue = new LinkedList<Integer>();
    queue.offer(v);
    visited[v] = true;
    while(!queue.isEmpty()){
        v = queue.poll();
        sb.append(vexs[v] + ",");
        for(int i = 0;i < numOfVexs;i++){
            if(edges[v][i] != 0 && edges[v][i] != Integer.MAX_VALUE && !visited[i]){
                queue.offer(i);
                visited[i] = true;
            }
        }
    }
    return sb.length() > 0 ? sb.substring(0,sb.length() - 1) : null;
}

//最短路径树Dijkstra算法
public int[] dijkstra(int v){
    if(v < 0 || v >= numOfVexs){
        throw new ArrayIndexOutOfBoundsException();
    }
    boolean[] st = new boolean[numOfVexs];
    int[] distance = new int[numOfVexs];
    for(int i = 0;i < numOfVexs;i++){
        for(int j = i + 1;j < numOfVexs;j++){
            if(edges[i][j] == 0){
                edges[i][j] = Integer.MAX_VALUE;
                edges[j][i] = Integer.MAX_VALUE;
            }
        }
    }
    for(int i = 0;i < numOfVexs;i++){
        distance[i] = edges[v][i];
    }
    st[v] = true;
    for(int i = 0;i < numOfVexs;++i){
        int min = Integer.MAX_VALUE;
        int index = -1;
        for(int j = 0;j < numOfVexs;++j){
            if(st[j] == false){
                if(distance[j] < min){
                    index = j;
                    min = distance[j];
                }
            }
        }
        if(index != -1){
            st[index] = true;
        }
        for(int w = 0;w < numOfVexs;w++){
            if(st[w] == false){
                if(edges[index][w] != Integer.MAX_VALUE && (min + edges[index][w] < distance[w])){
                        distance[w] = min + edges[index][w];
                }
            }
        }
    }
    return distance;
}