JAVA实践图的存储结构---邻接表（利用链表）

前言

关于邻接表，实现过一次数组版本的。
http://blog.csdn.net/xubaifu1997/article/details/51984760

虽然会写了，也感觉略绕，所以尝试用了自带的链表对象粗暴的实现了。

参考

图来自：http://www.cnblogs.com/skywang12345/p/3707612.html

如上图，有7个顶点。

我的实现思路非常粗暴，让每个顶点拥有一个链表。

那就7个链表了，让顶点与链表对应起来就可以实现。

链表的节点对象仅存储 末端的顶点和权值 。

那么起点顶点怎么办呢？我又用一个对象对它们进行组合，记录顶点的起点，以及链表。

所以，粗暴的实现如下：

class VertexNode {
    private int toVertex;//末端顶点
    private int weightVertex;//权值

    VertexNode(int toVertex, int weightVertex) {
        this.toVertex = toVertex;
        this.weightVertex = weightVertex;
    }

    public int getWeightVertex() {
        return weightVertex;
    }

    public int getToVertex() {
        return toVertex;
    }
}

这个只针对邻接表设计的节点。
存着末端顶点，以及权值。那么其起点呢，请看下一个对象？

class LinkedVertex {
    private LinkedList<VertexNode> vertexNodes;
    private int fromVertex;//起点

    LinkedVertex() {
        vertexNodes = new LinkedList<VertexNode>();
    }

    public void setFromVertex(int fromVertex) {
        this.fromVertex = fromVertex;
    }

    public int getFromVertex() {
        return fromVertex;
    }

    public int edgeSize() {
        return vertexNodes.size();
    }

    public void addNext(VertexNode to) {
        vertexNodes.addLast(to);
    }

    public VertexNode getEdge(int i) {
        return vertexNodes.get(i);
    }

    public void setEdge(int i, VertexNode v) {
        vertexNodes.set(i, v);
    }
}

可以看到这里存储了起点以及一个链表。
因为不知道会与起点连接的顶点有几个，所以使用了链表来存储与该起点相连的顶点，及它们相连的权值。

使用的是时候就很简单了。

5个顶点：

LinkedVertex[] lvs = new LinkedVertex[5];
0角标代表顶点1，1角标代表顶点2
//假设顶点1与2相连，权值2
//假设顶点1与3相连，权值4
lvs[0] = new LinkedVertex();
lvs[0].addNext(new VertexNode(2, 2));
lvs[0].addNext(new VertexNode(3, 4));

取得话则使用写好的get方法即可。

lvs[0].getFromVertex();//获取起点
lvs[0].getEdge(0).getToVertex();//获取第一个与其相连的端点
lvs[0].getEdge(0).getWeightVertex();//获取权值

到此，实现得就是这么粗暴了。

完整代码实现

import java.util.LinkedList;
import java.util.Scanner;
public class PrimNewDemo {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n, m;

        n = in.nextInt();
        m = in.nextInt();
        LinkedVertex[] lvs = new LinkedVertex[n];

        for (int i = 0; i < n; i++) {
            lvs[i] = new LinkedVertex();
            lvs[i].setFromVertex(i + 1);
        }

        int from, to, weight;
        for (int i = 0; i < m; i++) {
            from = in.nextInt();
            to = in.nextInt();
            weight = in.nextInt();
            //模拟无向图
            lvs[from - 1].addNext(new VertexNode(to, weight));
            lvs[to - 1].addNext(new VertexNode(from, weight));
        }
        showMap(lvs, n);
    }

    static void showMap(LinkedVertex[] lvs, int n) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < lvs[i].edgeSize(); j++) {
                System.out.println(lvs[i].getFromVertex()
                        + " to "
                        + lvs[i].getEdge(j).getToVertex()
                        + " weight:"
                        + lvs[i].getEdge(j).getWeightVertex());
            }
        }
    }
}

class LinkedVertex {
    private LinkedList<VertexNode> vertexNodes;
    private int fromVertex;

    LinkedVertex() {
        vertexNodes = new LinkedList<VertexNode>();
    }

    public void setFromVertex(int fromVertex) {
        this.fromVertex = fromVertex;
    }

    public int getFromVertex() {
        return fromVertex;
    }

    public int edgeSize() {
        return vertexNodes.size();
    }

    public void addNext(VertexNode to) {
        vertexNodes.addLast(to);
    }

    public VertexNode getEdge(int i) {
        return vertexNodes.get(i);
    }

    public void setEdge(int i, VertexNode v) {
        vertexNodes.set(i, v);
    }
}

class VertexNode {
    private int toVertex;//顶点信息
    private int weightVertex;//权值

    VertexNode(int toVertex, int weightVertex) {
        this.toVertex = toVertex;
        this.weightVertex = weightVertex;
    }

    public int getWeightVertex() {
        return weightVertex;
    }

    public int getToVertex() {
        return toVertex;
    }
}

结果

输入：
6 9
2 4 11
3 5 13
4 6 3
5 6 4
2 3 6
4 5 7
1 2 1
3 4 9
1 3 2
输出：
1 to 2 weight:1
1 to 3 weight:2
2 to 4 weight:11
2 to 3 weight:6
2 to 1 weight:1
3 to 5 weight:13
3 to 2 weight:6
3 to 4 weight:9
3 to 1 weight:2
4 to 2 weight:11
4 to 6 weight:3
4 to 5 weight:7
4 to 3 weight:9
5 to 3 weight:13
5 to 6 weight:4
5 to 4 weight:7
6 to 4 weight:3
6 to 5 weight:4

结束感言

嗯，这样子写了之后，个人感觉比数组版的更好用了，而且存储无向图更方便。实在是居家旅行，杀人必备良品（逃

END