public class Main {
public static class Vertex {
E data;
Edge firstIn;
Edge firstOut;
public Vertex(E data) {
this.data = data;
}
}
public static class Edge {
E data;
int fromVertexIndex;
int toVertexIndex;
Edge nextSameFromVertex;
Edge nextSameToVertex;
public Edge(E data, int fromVertexIndex, int toVertexIndex) {
this.data = data;
this.fromVertexIndex = fromVertexIndex;
this.toVertexIndex = toVertexIndex;
}
}
public static void insertEdge(Edge edge, List> vertexList) {
int fromVertexIndex = edge.fromVertexIndex;
int toVertexIndex = edge.toVertexIndex;
Vertex fromVertex = vertexList.get(fromVertexIndex);
Vertex toVertex = vertexList.get(toVertexIndex);
if (fromVertex.firstOut == null) {
//插入到顶点的出边属性
fromVertex.firstOut = edge;
} else {
// 插入到edge的nextSameFromVertex属性
Edge 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 tempEdge = toVertex.firstIn;
//找到最后一个Edge
while (tempEdge.nextSameToVertex != null) {
tempEdge = tempEdge.nextSameToVertex;
}
tempEdge.nextSameToVertex = edge;
}
}
public static void printVertexAndEdges(List> list) {
for (Vertex vertex : list) {
//输出入度
String infoIn = String.format("vertex: %3d - its in-edge are: ", vertex.data);
Edge 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 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> vertexList = new ArrayList<>();
for (int i=0; i v = new Vertex<>(i);
vertexList.add(v);
}
实验3
实现PP19.9
public class Router {
public int id;
public List
tableList;
public Router(){
tableList=new ArrayList
();
}
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
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
();
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
newList){
java.util.Iterator
iterator1= newList.iterator();
while(iterator1.hasNext()) {//对于对方每一项，检查自己所有项
Table table1= iterator1.next();//取出对方项
List
tempTableList=new ArrayList
();//临时表，存储新增的项目
int flag=0;//标志变量，记录是否找到相同目的地址的项
java.util.Iterator
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 BFSTraverse(int[][] ints, String[] m, int num) {
flag = new boolean[num];
ArrayList result = new ArrayList<>();
LinkedList queue = new LinkedList();
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;
}
Given a sorted linked list, delete all duplicates such that each element appear only once.
For example,Given 1->1->2, return 1->2.Given 1->1->2->3->3, return&
在JDK1.5之前的单例实现方式有两种(懒汉式和饿汉式并无设计上的区别故看做一种)，两者同是私有构
造器，导出静态成员变量，以便调用者访问。
第一种
package singleton;
public class Singleton {
//导出全局成员
public final static Singleton INSTANCE = new S
