java图

java的图，包括图的实现，广度遍历，深度遍历

后续要加上最小生成树Prim算法和Kruskal算法，最短路径Dijkstra算法

import java.util.Iterator;


public interface VertexInterface <T>{
    public T getLabel();
    public void visit();
    public void unVisit();
    public boolean isVisited();
    public boolean connect(VertexInterface<T> endVertex,double edgeWeight);
    public boolean connect(VertexInterface<T> endVertex);
    public Iterator<VertexInterface<T>> getNeighborIterator();
    public Iterator<Double> getWeightIterator();
    public boolean hasNeighbor();
    public VertexInterface<T> getUnvisitedNeighbor();
    public void setPredecessor(VertexInterface<T> predecessor);
    public VertexInterface<T> getPredecessor();
    public boolean hasPredecessor();
    public void setCost(double newCost);
    public double getCost();
    
    
}

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.NoSuchElementException;

import javax.print.attribute.standard.MediaSize.Other;

public class Vertex<T> implements VertexInterface<T>, Serializable {

	private T label;
	private ArrayList<Edge> edgeList;
	private boolean visited;
	private VertexInterface<T> previousVertex;
	private double cost;

	public Vertex(T vertexLabel) {
		label = vertexLabel;
		edgeList = new ArrayList<Edge>();
		visited = false;
		cost = 0;
		previousVertex = null;
	}
    public boolean equals(Object object)
    {
    	boolean result;
    	if((object==null)||(getClass()!=object.getClass()))
    		result=false;
    	else {
			Vertex<T> otherVertex=(Vertex<T>)object;
			result=label.equals(otherVertex.getLabel());
		}
    	return result;
    }
    
	@Override
	public T getLabel() {
		// TODO Auto-generated method stub
		return label;
	}

	@Override
	public void visit() {
		// TODO Auto-generated method stub
         visited=true;
	}

	@Override
	public void unVisit() {
		// TODO Auto-generated method stub
         visited =false;
	}

	@Override
	public boolean isVisited() {
		// TODO Auto-generated method stub
		return visited;
	}

	@Override
	public boolean connect(VertexInterface<T> endVertex, double edgeWeight) {
		// TODO Auto-generated method stub
		boolean result = false;
		if (!this.equals(endVertex)) {
			Iterator<VertexInterface<T>> neighbors = this.getNeighborIterator();
			boolean duplicateEdge = false;
			while (!duplicateEdge && neighbors.hasNext()) {
				VertexInterface<T> nextNeighbor = neighbors.next();
				if (endVertex.equals(neighbors))
					duplicateEdge = true;
			}
			if (!duplicateEdge) {
				edgeList.add(new Edge(endVertex, edgeWeight));
				result=true;
			}
		}
		return result;
	}

	@Override
	public boolean connect(VertexInterface<T> endVertex) {
		// TODO Auto-generated method stub
		return connect(endVertex, 0);
	}

	@Override
	public Iterator<VertexInterface<T>> getNeighborIterator() {
		// TODO Auto-generated method stub
		return new neighborIterator();
	}

	private class neighborIterator implements Iterator<VertexInterface<T>> {
		private Iterator<Edge> edges;

		private neighborIterator() {
			edges = edgeList.iterator();
		}

		@Override
		public boolean hasNext() {
			// TODO Auto-generated method stub
			return edges.hasNext();
		}

		@Override
		public VertexInterface<T> next() {
			// TODO Auto-generated method stub
			VertexInterface<T> nextNeighbor = null;
			if (edges.hasNext()) {
				Edge edgeToNextNeighbor = edges.next();
				nextNeighbor = edgeToNextNeighbor.getEndVertex();
			} else
				throw new NoSuchElementException();
			return nextNeighbor;
		}

		@Override
		public void remove() {
			// TODO Auto-generated method stub
			throw new UnsupportedOperationException();
		}

	}

	@Override
	public Iterator<Double> getWeightIterator() {
		// TODO Auto-generated method stub
		return new weightIterator();
	}

	private class weightIterator implements Iterator<Double> {
		private Iterator<Edge> edges;

		private weightIterator() {
			edges = edgeList.iterator();
		}

		@Override
		public boolean hasNext() {
			// TODO Auto-generated method stub

			return edges.hasNext();
		}

		@Override
		public Double next() {
			// TODO Auto-generated method stub
			double weight = 0;
			if (edges.hasNext()) {
				Edge edgeToNextNeighbor = edges.next();
				weight = edgeToNextNeighbor.getWeight();

			} else
				throw new NoSuchElementException();
			return weight;

		}

		@Override
		public void remove() {
			// TODO Auto-generated method stub
			throw new UnsupportedOperationException();
		}

	}

	@Override
	public boolean hasNeighbor() {
		// TODO Auto-generated method stub
		return !edgeList.isEmpty();
	}

	@Override
	public VertexInterface<T> getUnvisitedNeighbor() {
		// TODO Auto-generated method stub
		VertexInterface<T> result = null;
		Iterator<VertexInterface<T>> neighbors = getNeighborIterator();
		while (neighbors.hasNext() && (result == null)) {
               VertexInterface<T> nextNeighbor=neighbors.next();
               if(!nextNeighbor.isVisited())
            	   result=nextNeighbor;
		}
		return result;
	}

	@Override
	public void setPredecessor(VertexInterface<T> predecessor) {
		// TODO Auto-generated method stub

	}

	@Override
	public VertexInterface<T> getPredecessor() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public boolean hasPredecessor() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void setCost(double newCost) {
		// TODO Auto-generated method stub

	}

	@Override
	public double getCost() {
		// TODO Auto-generated method stub
		return 0;
	}

	protected class Edge implements Serializable {
		private Vertex vertex;
		private double weight;

		protected Edge(VertexInterface<T> endVertex, double edgeWeight) {
			vertex = (Vertex) endVertex;
			weight = edgeWeight;
		}

		protected VertexInterface<T> getEndVertex() {
			return vertex;
		}

		protected double getWeight() {
			return weight;
		}

	}
}

public interface BasicGraphInterface<T> {
public boolean addVertex(T vertexLabel);
public boolean addEdge(T begin,T end,double edgeWeight);
public boolean addEdge(T begin,T end);
public boolean hasEdge(T begin,T end);
public boolean isEmpty();
public int getNumberOfVertices();
public int getNumberOfEdges();
public void clear();
}

import java.util.Queue;
import java.util.Stack;


public interface GraphAlgorithmsInterface <T> {
public Queue<T> getDepthFirstTraversal(T origin);
public Queue<T> getBreadthFirstTraversal(T origin);
public Stack<T> getTopologicalSort();
public int getShortestPath(T begin,T end,Stack<T> path);
public double getCheapestPath(T begin,T end,Stack<T> path);
}

public interface GraphInterface<T> extends BasicGraphInterface<T> ,GraphAlgorithmsInterface<T>
{

}

import java.io.Serializable;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class DirectedGraph<T> implements GraphInterface<T>, Serializable {

	private HashMap<T, VertexInterface<T>> vertices;
	private int edgeCount;

	public DirectedGraph() {
		vertices = new HashMap<T, VertexInterface<T>>();
		edgeCount = 0;
	}

	@Override
	public boolean addVertex(T vertexLabel) {
		// TODO Auto-generated method stub
		VertexInterface<T> isDuplicate = vertices.put(vertexLabel, new Vertex(
				vertexLabel));
		return isDuplicate == null;

	}

	@Override
	public boolean addEdge(T begin, T end, double edgeWeight) {
		// TODO Auto-generated method stub
		boolean result = false;
		VertexInterface<T> beginVertex = vertices.get(begin);
		VertexInterface<T> endVertex = vertices.get(end);
		if ((beginVertex != null) && (endVertex != null))
			result = beginVertex.connect(endVertex, edgeWeight);
		if (result)
			edgeCount++;
		return result;
	}

	@Override
	public boolean addEdge(T begin, T end) {
		// TODO Auto-generated method stub
		return addEdge(begin, end, 0);
	}

	@Override
	public boolean hasEdge(T begin, T end) {
		// TODO Auto-generated method stub
		boolean found = false;
		VertexInterface<T> beginVertex = vertices.get(begin);
		VertexInterface<T> endVertex = vertices.get(end);
		if ((beginVertex != null) && (endVertex != null)) {
			Iterator<VertexInterface<T>> neighbors = beginVertex
					.getNeighborIterator();
			while (!found && neighbors.hasNext()) {
				VertexInterface<T> nextNeighbor = neighbors.next();
				if (endVertex.equals(nextNeighbor))
					found = true;
			}
		}
		return found;
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return vertices.isEmpty();
	}

	@Override
	public int getNumberOfVertices() {
		// TODO Auto-generated method stub
		return vertices.size();
	}

	@Override
	public int getNumberOfEdges() {
		// TODO Auto-generated method stub
		return edgeCount;
	}

	@Override
	public void clear() {
		vertices.clear();
		edgeCount = 0;
		// TODO Auto-generated method stub

	}

	// 重置visited，previousVertex，cost
	public void resetVertices() {
		Iterator<VertexInterface<T>> vertexiIterator = vertices.values()
				.iterator();
		while (vertexiIterator.hasNext()) {
			VertexInterface<T> nextVertex = vertexiIterator.next();
			nextVertex.unVisit();
			nextVertex.setCost(0);
			nextVertex.setPredecessor(null);
		}
	}

    /**
     * 深度优先遍历
     */
	@Override
	public Queue<T> getDepthFirstTraversal(T origin) {
		// TODO Auto-generated method stub
		resetVertices();
		LinkedList<VertexInterface<T>> vertexStack = new LinkedList<VertexInterface<T>>();
		LinkedList<T> traversalOrder = new LinkedList<T>();
		VertexInterface<T> orginVertex = vertices.get(origin);
		vertexStack.push(orginVertex);
		traversalOrder.add(origin);
		while (!vertexStack.isEmpty()) {
			VertexInterface<T> topVertex = vertexStack.peek();
			Iterator<VertexInterface<T>> edges = topVertex
					.getNeighborIterator();
			boolean found=false;
			while(edges.hasNext()) {
				VertexInterface<T> nextNeighbor = edges.next();
				if (!nextNeighbor.isVisited()) {
				    found=true;
					nextNeighbor.visit();
					traversalOrder.add(nextNeighbor.getLabel());
					System.out.println(nextNeighbor.getLabel());
					vertexStack.push(nextNeighbor);
					break;
				}
			} 
			if(!found)
				vertexStack.pop();
			
            
			
		}
		return traversalOrder;
	}
    /**
     * 广度优先遍历
     */
	@Override
	public Queue<T> getBreadthFirstTraversal(T origin) {
		// TODO Auto-generated method stub
		resetVertices();
		LinkedList<VertexInterface<T>> vertexQueue = new LinkedList<VertexInterface<T>>();
		LinkedList<T> traversalOrder = new LinkedList<T>();
		VertexInterface<T> orginVertex = vertices.get(origin);
		traversalOrder.add(origin);
		vertexQueue.add(orginVertex);
		while (!vertexQueue.isEmpty()) {
			VertexInterface<T> frontVertex = vertexQueue.poll();
			Iterator<VertexInterface<T>> edges = frontVertex
					.getNeighborIterator();
			while (edges.hasNext()) {
				VertexInterface<T> nextNeighbor = edges.next();
				if (!nextNeighbor.isVisited()) {					
					nextNeighbor.visit();
					traversalOrder.add(nextNeighbor.getLabel());
					vertexQueue.add(nextNeighbor);
				}
			}
		}
		return traversalOrder;
	}

	@Override
	public Stack<T> getTopologicalSort() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public int getShortestPath(T begin, T end, Stack<T> path) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public double getCheapestPath(T begin, T end, Stack<T> path) {
		// TODO Auto-generated method stub
		return 0;
	}

	public static void main(String[] args) {
		DirectedGraph<String> graph = new DirectedGraph<String>();
		graph.addVertex("a");
		graph.addVertex("b");
		graph.addVertex("c");
		graph.addVertex("d");
		graph.addVertex("e");
		graph.addVertex("f");
		graph.addVertex("g");
		graph.addVertex("h");
		graph.addVertex("i");
		graph.addEdge("i", "f", 1);
		graph.addEdge("a", "d", 5);
		graph.addEdge("a", "e", 4);
		graph.addEdge("d", "g", 2);
		graph.addEdge("e", "h", 6);
		graph.addEdge("f", "c", 4);
		graph.addEdge("b", "e", 1);
		graph.addEdge("a", "b", 2);		
		graph.addEdge("e", "f", 3);
		graph.addEdge("c", "b", 3);
		graph.addEdge("f", "h", 3);
		graph.addEdge("g", "h", 1);
		graph.addEdge("h", "i", 1);	
		System.out.println(graph.getNumberOfVertices());
		System.out.println(graph.getNumberOfEdges());
		System.out.println(graph.getBreadthFirstTraversal("a"));
		System.out.println(graph.getDepthFirstTraversal("a"));

	}

}