邻接表图java实现

 
package cn.edu.lnu.graph2;

import java.io.IOException;
import java.util.Scanner;

public class ListDG {
    private class Enode{
        int ivex;
        Enode nextEdge;
    }
    private class Vnode{
        char data;
        Enode firstEdge;
    }
    private  Vnode[] mVexs;
    
    public ListDG(){
         System.out.printf("input vertex number: ");
         int vlen = readInt();
         System.out.printf("input edge number: ");
         int elen = readInt();
         if ( vlen < 1 || elen < 1 || (elen > (vlen*(vlen - 1)))) {
                System.out.printf("input error: invalid parameters!\n");
                return ;
            }
        // 初始化"顶点"
            mVexs = new Vnode[vlen];
            for(int i = 0; i < mVexs.length; i++){
                System.out.printf("vertex(%d): ", i);
                mVexs[i] = new Vnode();
                 mVexs[i].data = readChar();
                 mVexs[i].firstEdge = null;
            }
         // 初始化"边"
          for(int i = 0; i < elen; i++){
            // 读取边的起始顶点和结束顶点
                System.out.printf("edge(%d):", i);
                char c1 = readChar();
                char c2 = readChar();
                int p1 = getPosition(c1);
                int p2 = getPosition(c2);
                // 初始化node1
                Enode node1 = new Enode();
                node1.ivex = p2;
             // 将node1链接到"p1所在链表的末尾"
                if(mVexs[p1].firstEdge ==null){
                    mVexs[p1].firstEdge = node1;
                }else{
                    linkLast(mVexs[p1].firstEdge,node1);
                }
          }
    }
    
     public ListDG(char[] vexs, char[][] edges) {

            // 初始化"顶点数"和"边数"
            int vlen = vexs.length;
            int elen = edges.length;

            // 初始化"顶点"
            mVexs = new Vnode[vlen];
            for (int i = 0; i < mVexs.length; i++) {
                mVexs[i] = new Vnode();
                mVexs[i].data = vexs[i];
                mVexs[i].firstEdge = null;
            }
            // 初始化"边"
            for(int i = 0; i < elen; i++){
                char c1 = edges[i][0];
                char c2 = edges[i][1];
                 // 读取边的起始顶点和结束顶点
                int p1 = getPosition(edges[i][0]);
                int p2 = getPosition(edges[i][1]);
             // 初始化node1
                Enode node1 = new Enode();
                node1.ivex = p2;
             // 将node1链接到"p1所在链表的末尾"
                if(mVexs[p1].firstEdge == null){
                    mVexs[p1].firstEdge = node1;
                }else{
                    linkLast(mVexs[p1].firstEdge, node1);
                }
            }
     }
     /*
     * 将node节点链接到list的最后
     */
    private void linkLast(Enode list,Enode node){
        Enode p = list;
        while(p.nextEdge != null){
            p = p.nextEdge;
        }
        p.nextEdge = node;
    }
    
    /*
     * 读取一个输入字符
     */
    private int readInt() {
        Scanner scanner = new Scanner(System.in);
        return scanner.nextInt();
    }
    
    /*
     * 读取一个输入字符
     */
    private char readChar() {
        char ch='0';

        do {
            try {
                ch = (char)System.in.read();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } while(!((ch>='a'&&ch<='z') || (ch>='A'&&ch<='Z')));

        return ch;
    }

    /*
     * 返回ch位置
     */
    private int getPosition(char ch) {
        for(int i=0; i<mVexs.length; i++)
            if(mVexs[i].data==ch)
                return i;
        return -1;
    }
    
    /*
     * 打印矩阵队列图
     */
    public void print(){
         System.out.printf("List Graph:\n");
         for(int i = 0; i < mVexs.length; i++){
             System.out.printf("%c->",mVexs[i].data);
             Enode node = mVexs[i].firstEdge;
             while(node != null){
                 System.out.printf("%c ", mVexs[node.ivex].data);
                 node = node.nextEdge;
             }
             System.out.printf("\n");
         }
    }
    
    public static void main(String[] args) {
        char[] vexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
         char[][] edges = new char[][]{
                    {'A', 'B'},
                    {'B', 'C'},
                    {'B', 'E'},
                    {'B', 'F'},
                    {'C', 'E'},
                    {'D', 'C'},
                    {'E', 'B'},
                    {'E', 'D'},
                    {'F', 'G'}};
         ListDG pG;
         pG = new ListDG(vexs, edges);

         pG.print();   // 打印图
    }
}