20162328蔡文琛實驗四圖的實現與應用

時間 2019-12-06

標籤實驗實現應用简体版

原文原文鏈接

20162328蔡文琛大二實驗四

任務詳情

實驗1

用鄰接矩陣實現無向圖（邊和頂點都要保存），實如今包含添加和刪除結點的方法，添加和刪除邊的方法，size(),isEmpty()，廣度優先迭代器，深度優先迭代器java

實現類

public class MatrixUDG {

    private char[] mVexs;       // 頂點集合
    private int[][] mMatrix;    // 鄰接矩陣

    /*
     * 建立圖(本身輸入數據)
     */
    public boolean isEmpty(){
        boolean result = true;
        if (mVexs.equals(0) )
            return result = false;
        return result;
    }
    public void size(){
        int num= 0;
        num = mVexs.length;
        System.out.println(num);
    }
    public MatrixUDG(char[] vexs, char[][] edges) {

        // 初始化"頂點數"和"邊數"
        int vlen = vexs.length;
        int elen = edges.length;

        // 初始化"頂點"
        mVexs = new char[vlen];
        for (int i = 0; i < mVexs.length; i++)
            mVexs[i] = vexs[i];

        // 初始化"邊"
        mMatrix = new int[vlen][vlen];
        for (int i = 0; i < elen; i++) {
            // 讀取邊的起始頂點和結束頂點
            int p1 = getPosition(edges[i][0]);
            int p2 = getPosition(edges[i][1]);

            mMatrix[p1][p2] = 1;
            mMatrix[p2][p1] = 1;
        }
    }

    /*
     * 返回ch位置
     */
    private int getPosition(char ch) {
        for (int i = 0; i < mVexs.length; i++)
            if (mVexs[i] == ch)
                return i;
        return -1;
    }

    /*
     * 讀取一個輸入字符
     */
    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;
    }

    /*
     * 讀取一個輸入字符
     */
    private int readInt() {
        Scanner scanner = new Scanner(System.in);
        return scanner.nextInt();
    }

    /*
     * 打印矩陣隊列圖
     */
    public void print() {
        System.out.printf("Martix Graph:\n");
        for (int i = 0; i < mVexs.length; i++) {
            for (int j = 0; j < mVexs.length; j++)
                System.out.printf("%d ", mMatrix[i][j]);
            System.out.printf("\n");
        }
    }
}

實驗2

用十字鏈表實現無向圖（邊和頂點都要保存），實如今包含添加和刪除結點的方法，添加和刪除邊的方法，size(),isEmpty()，廣度優先迭代器，深度優先迭代器網絡

public class Main {
    public static class Vertex<E,T>  {
        E data;
        Edge<T> firstIn;
        Edge<T> firstOut;

        public Vertex(E data) {
            this.data = data;
        }
    }
    public static class Edge<E> {
        E data;
        int fromVertexIndex;
        int toVertexIndex;
        Edge<E> nextSameFromVertex;
        Edge<E> nextSameToVertex;

        public Edge(E data, int fromVertexIndex, int toVertexIndex) {
            this.data = data;
            this.fromVertexIndex = fromVertexIndex;
            this.toVertexIndex = toVertexIndex;
        }
    }
    public static void insertEdge(Edge<Integer> edge, List<Vertex<Integer, Integer>> vertexList) {
        int fromVertexIndex = edge.fromVertexIndex;
        int toVertexIndex = edge.toVertexIndex;
        Vertex<Integer, Integer> fromVertex = vertexList.get(fromVertexIndex);
        Vertex<Integer, Integer> toVertex = vertexList.get(toVertexIndex);

        if (fromVertex.firstOut == null) {
            //插入到頂點的出邊屬性
            fromVertex.firstOut = edge;
        } else {
            // 插入到edge的nextSameFromVertex屬性
            Edge<Integer> tempEdge = fromVertex.firstOut;
            //找到最後一個Edge
            while (tempEdge.nextSameFromVertex != null) {
                tempEdge = tempEdge.nextSameFromVertex;
            }
            tempEdge.nextSameFromVertex = edge;
        }
        if (toVertex.firstIn == null) {
            //插入到頂點的入邊屬性
            toVertex.firstIn = edge;
        } else {
            // 插入到edge的nextSameToVertex屬性
            Edge<Integer> tempEdge = toVertex.firstIn;
            //找到最後一個Edge
            while (tempEdge.nextSameToVertex != null) {
                tempEdge = tempEdge.nextSameToVertex;
            }
            tempEdge.nextSameToVertex = edge;
        }
    }
    public static void printVertexAndEdges(List<Vertex<Integer, Integer>> list) {
        for (Vertex<Integer, Integer> vertex : list) {
            //輸出入度
            String infoIn = String.format("vertex: %3d - its in-edge are: ", vertex.data);
            Edge<Integer> edge = vertex.firstIn;
            while (edge != null) {
                infoIn += String.format("(from: %d, to: %d, data: %d)", edge.fromVertexIndex, edge.toVertexIndex, edge.data);
                edge = edge.nextSameToVertex;
            }
            System.out.println(infoIn);
            //輸出出度
            String infoOut = String.format("vertex: %3d - its out-edge are: ", vertex.data);
            Edge<Integer> edgeOut = vertex.firstOut;
            while (edgeOut != null) {
                infoOut += String.format("(from: %d, to: %d, data: %d)", edgeOut.fromVertexIndex, edgeOut.toVertexIndex, edgeOut.data);
                edgeOut = edgeOut.nextSameFromVertex;
            }
            System.out.println(infoOut);
        }
    }
    public static void main(String[] args) {
        int vertexNumber = 12;
        int edgeNumber = 21;
        // 檢查邊的數量是否正確
        // 有向徹底圖
        int maxEdgeNumber = vertexNumber*(vertexNumber-1);
        if (edgeNumber < 0 || edgeNumber > maxEdgeNumber) {
            return;
        }
        // 輸入有向圖數據
        // 1. 先輸入頂點，暫時令firstIn， firstOut爲null;
        ArrayList<Vertex<Integer, Integer>> vertexList = new ArrayList<>();
        for (int i=0; i<vertexNumber; i++) {
            Vertex<Integer, Integer> v = new Vertex<>(i);
            vertexList.add(v);
        }

實驗3

實現PP19.9this

public class Router {
        public int id;
         public List<Table> tableList;

        public Router(){
        tableList=new ArrayList<Table>();
        }
        public void printTable(){
        System.out.println("------------routTable of No "+id+"router is------------------");
        for (Table table : tableList) {
        System.out.println(table.hostId+" "+table.netId+"  "+table.distance+"  "+table.nextJumpId);
        }
       }
        public boolean isNearby(Router router){
         List<Table> tablesOther= router.tableList;
        for (Table table : tablesOther) {
       for (Table table2 : tableList) {
        if ((table.netId==table2.netId)&&(table.distance==1)&&(table2.distance==1)&&(table.hostId!=table2.hostId)) {
        return true;//判斷相鄰的條件：兩個路由器，對於相同的網絡，都直接相連（距離爲1）  
        }
        }
        }
        return false;
        }
        public void init(int[][]near){//初始化問題：輸入鄰接矩陣，對每個路由器，循環感知相連的網絡  
        tableList=new ArrayList<Table>();
        for (int i=0;i< near[id].length;i++)//對矩陣的第id行作循環,注意net編號是從0開始的  
        {
        if (near[id][i]==1) {//id路由器和i號網絡相連  
         Table temptTable=new Table();
        temptTable.hostId=id;
        temptTable.netId=i;
        temptTable.distance=1;
        temptTable.nextJumpId=-1;//下一跳id爲-1，表示直接交付  
        tableList.add(temptTable);
        }
        }
        }
        public void send(Router router){//向指定路由器發送table,假設已知道兩者相連  
       router.update(tableList);//直接讓對方更新本身的表就好了  
        }
        public void update(List <Table> newList){
        java.util.Iterator<Table > iterator1= newList.iterator();
        while(iterator1.hasNext()) {//對於對方每一項，檢查本身全部項  
        Table table1= iterator1.next();//取出對方項  
        List<Table>tempTableList=new ArrayList<Table>();//臨時表，存儲新增的項目  
       int flag=0;//標誌變量，記錄是否找到相同目的地址的項  
        java.util.Iterator<Table> iterator2=tableList.iterator();
      while (iterator2.hasNext()) {
        Table table2 = (Table) iterator2.next();//  
       if (table2.netId==table1.netId) {
        flag=1;
  if (table2.nextJumpId==table1.hostId) {
      table2.distance=table1.distance+1;
 }
else {
if (table2.distance>table1.distance+1) {
table2.nextJumpId=table1.hostId;
table2.distance=table1.distance+1;
}
}
}
}
if (flag==0){
flag=1;
     Table tempTable=new Table();
     tempTable.hostId=id;
  tempTable.netId=table1.netId;
   tempTable.nextJumpId=table1.hostId;
tempTable.distance=table1.distance+1;

tableList.add(tempTable);
}

}
printTable();
}
        }

遍歷類

public class Graph {
    private boolean[] flag;

        static String[] vertexs;

         int[][] edges;


        public void DFSTraverse(int num1) {
        flag = new boolean[num1];
        for (int i = 0; i < num1; i++) {
       if (flag[i] == false) {// 當前頂點沒有被訪問
        DFS(i);
        }
        }
        }


       public void DFS(int i) {
        flag[i] = true;// 第i個頂點被訪問
        System.out.print(vertexs[i] + " ");
     for (int j = 0; j < flag.length; j++) {
        if (flag[j] == false && edges[i][j] == 1) {
        DFS(j);
        }
        }
        }


       public ArrayList<String> BFSTraverse(int[][] ints, String[] m, int num) {
        flag = new boolean[num];
        ArrayList<String> result = new ArrayList<>();
        LinkedList<Integer> queue = new LinkedList<Integer>();
        flag[0] = true;
        queue.add(0);
        while (!queue.isEmpty()) {
        int j = queue.remove(0);
        result.add(m[j]);
        for (int k = 0; k < num; k++) {
        if (ints[j][k] == 1 && flag[k] == false) {
        flag[k] = true;
        queue.add(k);
        }
        }
        }
        return result;
        }

代碼參考http://blog.csdn.net/coslay/article/details/47748089
http://www.sharejs.com/codes/java/6692
http://blog.csdn.net/caib1109/article/details/72777806.net