图之邻接多重表

邻接多重表是无向图的一种链式存储结构；
边结点：对应无向图中的边，其结点结构如下：

mark	ivex	ilink	jvex	jlink	info

其中，mark为标志域，用于标记该条边是否被搜索过；ivex和jvex为该边依附的两个顶点在图中的位置；ilink指向下一条依附于顶点ivex的边；jlink指向下一条依附于顶点jvex的边；info指示和当前边相关的信息 ，如权重等；

头结点：对应于无向图中的顶点，其结点结构如下：

data	firstedge

其中，data域存储和该顶点相关的信息；firstedge域指示第一条依附于该顶点的边；

优点：克服了邻接表中关于对两个结点操作不方便的缺点；

下面给出邻接多重表的Java实现：

package org.sky.graph;

import java.util.Scanner;

/**
 * @description 利用邻接多重表构建无向图
 * @author sky
 * @date 2016/12/30
 */
public class AdjacencyMultilistGragh {

    @SuppressWarnings("unused")
    private static class EdgeBox{
        boolean mark;           //标志域，标记边是否被搜索过
        int iVex, jVex;         //顶点域，指示边的两个顶点的位置
        EdgeBox iLink;          //边域，指示依附于顶点iVex的下一条边
        EdgeBox jLInk;          //边域，指示依附于顶点jVex的下一条边
        int value;              //边的信息，如权重

        public EdgeBox(boolean mark, int iVex, int jVex, EdgeBox iLink,
                EdgeBox jLInk, int value) {
            super();
            this.mark = mark;
            this.iVex = iVex;
            this.jVex = jVex;
            this.iLink = iLink;
            this.jLInk = jLInk;
            this.value = value;
        }

        public boolean isMark() {
            return mark;
        }

        public void setMark(boolean mark) {
            this.mark = mark;
        }

        public int getiVex() {
            return iVex;
        }

        public void setiVex(int iVex) {
            this.iVex = iVex;
        }

        public int getjVex() {
            return jVex;
        }

        public void setjVex(int jVex) {
            this.jVex = jVex;
        }

        public EdgeBox getiLink() {
            return iLink;
        }

        public void setiLink(EdgeBox iLink) {
            this.iLink = iLink;
        }

        public EdgeBox getjLInk() {
            return jLInk;
        }

        public void setjLInk(EdgeBox jLInk) {
            this.jLInk = jLInk;
        }

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }
    }

    @SuppressWarnings("unused")
    private static class VexBox{
        Object data;            //顶点信息
        EdgeBox firstEdge;      //指向第一条依附于该顶点的边

        public VexBox(Object data, EdgeBox firstEdge) {
            super();
            this.data = data;
            this.firstEdge = firstEdge;
        }
        public Object getData() {
            return data;
        }
        public void setData(Object data) {
            this.data = data;
        }
        public EdgeBox getFirstEdge() {
            return firstEdge;
        }
        public void setFirstEdge(EdgeBox firstEdge) {
            this.firstEdge = firstEdge;
        }
    }

    private int numVex;         //图的当前顶点数
    private int numEdge;            //图的当前弧数

    private VexBox[] adjMulist; //存储表头结点，通常采用顺序存储结构

    public AdjacencyMultilistGragh(int numVex, int numEdge, VexBox[] adjMulist) {
        super();
        this.numVex = numVex;
        this.numEdge = numEdge;
        this.adjMulist = adjMulist;
    }

    /**
     * @Desciption 采用邻接多重表存储表示，构造有向图
     */
    public void createUDG(){
        @SuppressWarnings("resource")
        Scanner sc = new Scanner(System.in);
        System.out.println("请分别输入图的顶点数及边数");
        numVex = sc.nextInt();
        numEdge = sc.nextInt();
        adjMulist = new VexBox[numVex];
        System.out.println("请分别输入图的各个顶点：");
        for(int i = 0; i < numVex; i++){
            adjMulist[i] = new VexBox(sc.next(), null);
        }
        System.out.println("请输入各个边的起始顶点及其权值value");
        for(int k = 0; k < numEdge; k++){
            int i = locateVex(sc.next());   //输入一条弧的始点，即弧尾
            int j = locateVex(sc.next());   //输入一条弧的终点，即弧头
            int value = sc.nextInt();       //输入弧的权重
            EdgeBox p = new EdgeBox(false, i, j, adjMulist[i].firstEdge, adjMulist[j].firstEdge, value);
            adjMulist[i].firstEdge = p;
            adjMulist[j].firstEdge = p;
        }
    }

    /**
     * @Desciption 返回与传入值相对应的定点位置
     */ 
    public int locateVex(Object vex){
        for(int v = 0; v < numVex; v++){
            if(adjMulist[v].getData().equals(vex)){
                return v;
            }
        }
        return -1;
    }       
}