邻接表JAVA 实现

最近看了数据结构，关于图的那部分，总是感觉很难用链式存储。以前觉得好难，都不愿意去尝试，今天闲来无聊，尝试了一把:

在这里插入代码片
```/**
 * 
 */
package com.my.datastucture;

import java.util.ArrayList;
import java.util.LinkedList;

/**
 * @author Administrator
 *
 */
public class GraphLinkedNodeDemo {
public static void main(String args[]) {
	GraphLinked gl = new GraphLinked(6);
	String nodes[] = {"A","B","C","D","E","F"};
	for(int i=0;i<nodes.length;i++) {
//		GraphNode gn = new GraphNode(nodes[i],i);
		gl.addNode(nodes[i],i);
	}
	gl.addEdge(0, 2, 1);
	gl.addEdge(0, 4, 1);
	gl.addEdge(1, 5, 1);
	gl.addEdge(2, 3, 1);
//	gl.addEdge(1, 5, 1);
	
	gl.addEdge(2, 4, 1);
//	gl.addEdge(3, 4, 1);
//	gl.addEdge(4, 5, 1);
	System.out.println("******************");
	gl.show();
	System.out.println("*********dfs*********");
	gl.dfs();
	System.out.println();
	System.out.println("*********bfs*********");
	gl.bfs();
}

	
}

class GraphLinked{
	GraphNode[] nodes;
	int edgesnum;
	boolean[] isvisited;
	
	public GraphLinked(int n) {
		nodes = new GraphNode[n];
	}
	
	public int getNumEdges() {
		return edgesnum;
	}
	
	public void addNode(String name, int i) {
		if(i<nodes.length) {
			GraphNode node = new GraphNode(name,i);
			nodes[i]=node;
		}else {
			System.out.println("Graph is full");
			return;
		}
	}
	public void show() {
		for(int i=0;i<nodes.length;i++) {
			ArrayList<Edge> edges = nodes[i].graphNeighbors;
			System.out.print(nodes[i]+": ");
			for(Edge edge: edges) {
				System.out.print(edge.end+"=>");
			}
			System.out.println();
		}
		
	}
	public void addEdge(int start, int end, int weight) {
		GraphNode startnode = nodes[start];
		GraphNode endnode = nodes[end];
		startnode.addNeighbor(endnode, weight);
		endnode.addNeighbor(startnode, weight);
		edgesnum=edgesnum+1;
	}
	public void dfs(boolean isvisited[], GraphNode node) {
		System.out.print(node+"=>");
		isvisited[node.data] = true;
		GraphNode neighbor = node.getFirstNeighbor();
		while(neighbor !=null) {
			if(!isvisited[neighbor.data]) {
				dfs(isvisited, neighbor);
			}else {
				neighbor = node.getnextNeighbor(neighbor);
			}
		}
	}
	public void dfs() {
		isvisited = new boolean[nodes.length];
		for(int i=0;i<nodes.length;i++) {
			if(!isvisited[i] ) {
				dfs(isvisited, nodes[i]);
			}
		}
	}
	
	public void bfs(boolean isvisited[],GraphNode node) {
		GraphNode v;
		GraphNode w;
		System.out.print(node+"=>");
		LinkedList<GraphNode> queue = new LinkedList<GraphNode>();
		isvisited[node.data] = true;
		queue.addLast(node);
		
		while(!queue.isEmpty()) {
			v=queue.removeFirst(); //取出队列的队头元素
			w=v.getFirstNeighbor();
			while(w != null) {
			if(!isvisited[w.data]) {
				System.out.print(w+"=>");
				isvisited[w.data] = true;
				queue.addLast(w);
			}else {
				w=v.getnextNeighbor(w);
			}
			}
		}
	}
	
	public void bfs() {
		isvisited = new boolean[nodes.length];
		for(int i=0;i<nodes.length;i++) {
			
			if(!isvisited[i]) {
				bfs(isvisited,nodes[i]);
			}
		}
	}
}

class Edge{
	GraphNode start;
	GraphNode end;
	int weight;
	public Edge(GraphNode start, GraphNode end, int weight) {
		this.start = start;
		this.end = end;
		this.weight =weight;
	}
	
}
class GraphNode{
	String name;
	int data;
	ArrayList<Edge> graphNeighbors;
	/**
	 * @param name
	 * @param data
	 * @param graphNeighbors
	 */
	public GraphNode(String name, int data) {
		
		this.name = name;
		this.data = data;
		graphNeighbors = new ArrayList<Edge>();
	}
	
	@Override
	public String toString() {
		return "["+this.name+","+this.data+"]";
	}

	public void addNeighbor(GraphNode neighbor, int weight) {
		if(this.name.equals("B")) {
			System.out.println("hello");
		}
		Edge e = new Edge(this,neighbor, weight);
		graphNeighbors.add(e);
	}
	public GraphNode getFirstNeighbor() {
		for(Edge edge: graphNeighbors) {
			return edge.end;
		}
		return null;
	}
	
	public Edge getEdge(GraphNode gn) {
		for(int i=0;i<graphNeighbors.size();i++) {
			Edge edge = graphNeighbors.get(i);
			if(edge.end.equals(gn)) {
				return edge;
			}
		
		}
		return null;
	}
	

	public int getEdgeIndex(GraphNode gn) {
		for(int i=0;i<graphNeighbors.size();i++) {
			Edge edge = graphNeighbors.get(i);
			if(edge.end.equals(gn)) {
				return i;
			}
		
		}
		return -1;
	}
	public GraphNode getnextNeighbor(GraphNode node) {
		int edgeIndex = getEdgeIndex(node);
		for(int i=edgeIndex+1;i<graphNeighbors.size();i++) {
			return graphNeighbors.get(i).end;
			
		}
		return null;
	}
	
}