java数据结构之DirectGraph

 

1.MyLinkedListWithIterator：给vetex保存邻接边用，

由于要作为邻接边集合，所以开头不能有哨兵节点，即不能有含空data的节点

在构造方法里去掉//first=new MNode<T>();

public MyLinkedListWithIterator(){

clear();

//first=new MNode<T>(); //不要first哨兵，为了给DirectedGraph用

}

调用getNodeAt取最后节点时要减一

package com.jimmy.impl;

import java.util.Iterator;
import java.util.NoSuchElementException;

import com.jimmy.ListInterface;

public class MyLinkedListWithIterator<T> implements ListInterface<T> {
 
 public Iterator getIteratorForLinkedList()
 {
 return new IteratorForLinkedList();
 }
private class IteratorForLinkedList implements Iterator<T>{
 private MNode nextNode;
 private IteratorForLinkedList(){
  nextNode=first;
 }
 @Override
 public boolean hasNext() {
  
  return nextNode!=null;
 }

 @Override
 public T next() {
  if(hasNext())
  {
   MNode returnNode=nextNode;
   nextNode=nextNode.next;
   return (T)returnNode.getData();
  }else
   throw new NoSuchElementException();
 }

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

 private MNode<T> first;

 private int length;

 public MyLinkedListWithIterator(){

 clear();

 //first=new MNode<T>();           //不要first哨兵，为了给DirectedGraph用

 }

 

 //默认放到last后头

 public boolean add(Object entry) {

 MNode<T> newNode=new MNode(entry);

 if(isEmpty()){

 first=newNode;

 }

 else{

 MNode<T> lastNode=getNodeAt(length-1);

 lastNode.next=newNode;//放到last后头
 
 

 }

 length++;

 return true;

 }

 public boolean add(int pos, Object entry) {
return true;
 }

 public boolean remove(int pos) {

 MNode pre = null;

 MNode<T> cur=first; //first为哨兵

 

 if(pos>=1&&pos<=length){

 for(int i=0;i<pos;i++){ //从一开始

 

 pre=cur;

 cur=cur.next;

 }

 }

 pre.next=cur.next;

 cur=null;

 length--;

 return true;

 }

 public void clear() {

 first=null;

 MNode<T> pre = null;

 MNode<T> cur=first; //first为哨兵

 

 for(int i=0;i<length;i++){ //从一开始

 

 pre=cur;

 cur=cur.next;

 pre=null;

 }

 length=0;

 }

 public boolean repalce(int pos, Object entry) {

 MNode<T> pre = null;

 MNode<T> cur=first; //first为哨兵

 for(int i=0;i<pos;i++){ //从一开始
 pre=cur;
 cur=cur.next;

 }

 MNode<T> tmp=new MNode(entry);
 pre.next=tmp;
 tmp.next=cur.next;
 cur=null;
 return true;
 }

 public Object getEntry(int pos) {

 MNode<T> cur=first; //first为哨兵

 if(pos>=0&&pos<=length){     //这里从0开始

 for(int i=0;i<pos;i++){ //从一开始
 cur=cur.next;

 }

 }

 return cur.getData();

 }

 public boolean contains(Object entry) {

 MNode<T> cur=first; //first为哨兵

 

 for(int i=0;i<length;i++){ //从一开始

 

 cur=cur.next;

 if(cur.getData().equals(entry));

 {

 System.out.print("list contains "+entry);

 return true;

 }

 }

 return false;

 }

 public int getLength() {

 return length;

 }

 public boolean isEmpty() {

 if(length==0)

 {assert(first==null);

 return true;}

 else

 

 return false;

 }

public void display() {

MNode<T> cur=first; //first为哨兵

System.out.print(cur.getData()+",");

for(int i=0;i<length;i++){ //从一开始

 

cur=cur.next;

if(cur!=null)

System.out.print(cur.getData()+",");

}

System.out.println();

 

 

}

 //外部输入pos，pos从1开始

 

 public MNode<T> getNodeAt(int pos)

 {

 MNode<T> cur=first; //first为哨兵
 if(pos>=0&&pos<=length){

 for(int i=0;i<pos;i++){

 cur=cur.next;

 }

 }

 return cur;

 }

 public static void main(String as[]){

 MyLinkedListWithIterator<Integer> ll=new MyLinkedListWithIterator<Integer>();

 ll.add(1);

 

 

 ll.add(5);

 ll.add(3);

 ll.display();                                 //1,5,3

 ll.repalce(2,new Integer(9));  //1,9,3

 ll.display();

 Integer a=(Integer)ll.getEntry(2);     //注意这里getEntry（）查找二的显示9，即符合中文习惯，第一个为1

 System.out.println("a="+a);

 System.out.println("length="+ll.length);

 System.out.println(ll.contains(new Integer(9)));

 }

 }

 

 

package com.jimmy.impl;

import java.util.HashMap;

import java.util.Iterator;

import com.jimmy.GraphInterface;

import com.jimmy.QueueInterf;

import com.jimmy.VetexInterface;

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

/**

* @param args

*/

public static void main(String[] args) {

DirectedGraph g=new DirectedGraph();

String a=new String("A");

String b=new String("B");

String c=new String("C");

String d=new String("D");

String e=new String("E");

String f=new String("F");

String gg=new String("G");

String h=new String("H");

String i=new String("I");

g.addVetex(a);

g.addVetex(b);

// g.addVetex(c);

g.addVetex(d);

g.addVetex(e);

// g.addVetex(f);

g.addVetex(gg);

g.addVetex(h);

// g.addVetex(i);

g.addEdge(a, b,2);

g.addEdge(a, d,5);

g.addEdge(a, e,4);

g.addEdge(b, e,1);

g.addEdge(d, gg,2);

// g.addEdge(e, f,3);

g.addEdge(e, h,6);

g.addEdge(gg, h,1);

// g.addEdge(h,i,1);

// g.addEdge(i, f,1);

// g.addEdge(f, c,4);

// g.addEdge(c, b,3);

g.getBreadthFirstTranversal(a);

}

private int edgeCount;

private HashMap<T,VetexInterface<T>> vertics;

public DirectedGraph()

{

this.edgeCount=0;

vertics=new HashMap<T,VetexInterface<T>>();

}

public boolean addVetex(T label)

{

VetexInterface<T> isDuplicate=vertics.put(label, new Vetex(label));

return isDuplicate==null;

}

public boolean addEdge(T begin,T end,double edgeWeight){

boolean result=false;

VetexInterface<T> beginV=vertics.get(begin);

VetexInterface<T> endV=vertics.get(end);

if(beginV!=null&&endV!=null)

{

result=beginV.connect(endV,edgeWeight);

}

if(result)

{

edgeCount++;

}

return result;

}

public boolean addEdge(T begin,T end){

return addEdge(begin,end,0);

}

public boolean isEmpty()

{

return vertics.isEmpty();

}

public void clear()

{

vertics.clear();

}

public int getNumOfVetics()

{

return vertics.size();

}

public int getNumOfEdge()

{

return this.edgeCount;

}

public boolean hasEdge(T begin,T end){

boolean found=false;

VetexInterface<T> beginV=vertics.get(begin);

VetexInterface<T> endV=vertics.get(end);

if(beginV!=null&&endV!=null)

{

Iterator<VetexInterface<T>> neighbors=beginV.getNeighborIterator();

while(!found&&neighbors.hasNext())

{

VetexInterface<T> neighbor=neighbors.next();

if(endV.equals(neighbor))

found=true;

}

}

return found;

}

public void resetVertics()

{

Iterator<VetexInterface<T>> vt=vertics.values().iterator();

while(vt.hasNext())

{

VetexInterface<T> nextV=vt.next();

nextV.unvisit();

nextV.setCost(0);

nextV.setPredecessor(null);

}

}

public QueueInterf<VetexInterface<T>> getBreadthFirstTranversal(T orgin)

{

resetVertics();

QueueInterf<VetexInterface<T>> vq=new LinkedQueue<VetexInterface<T>>(); //存放邻接点的新队列

QueueInterf<VetexInterface<T>> tranverseOrder=new LinkedQueue<VetexInterface<T>>(); //存放遍历顺序的新队列

VetexInterface<T> orginV=vertics.get(orgin);

orginV.visit();

tranverseOrder.enqueue(orginV);

vq.enqueue(orginV);

while(!vq.isEmpty()) //开始从A起，A出列后加入了BDE

{

VetexInterface<T> fv=vq.dequeue(); //A出列,

Iterator<VetexInterface<T>> edges=fv.getNeighborIterator();//edges表示A的邻接边BDE

System.out.print("fv ="+fv.getLabel()+" its neighbor:");

while(edges.hasNext()) //遍历A的邻接边BDE

{

VetexInterface<T> neighbor=edges.next();

System.out.print(neighbor.getLabel());

if(!neighbor.isVisit()){

neighbor.visit();

tranverseOrder.enqueue(neighbor); //循环访问A的邻接边BDE

vq.enqueue(neighbor); //同时把A的邻接点BDE放到vq做为新的邻接点

}

}

System.out.println();

LinkedQueue vqq=(LinkedQueue)vq;

System.out.print("display vetexQueue(显示当前队列的节点):");

vqq.display(); //显示A的邻接边BDE

System.out.println();

}

return tranverseOrder;

}

}

2.顶点接口

 

public interface VetexInterface<T> {

public T getLabel();

public void visit();

public boolean isVisit();

public void unvisit();

public boolean connect(VetexInterface<T> end,double edgeWeight);

public boolean connect(VetexInterface<T> end);

public boolean hasNeighbor();

public Iterator<VetexInterface<T>> getNeighborIterator();

public VetexInterface<T> getUnvisitedNeighbor();

public void setPredecessor(VetexInterface<T> predecessor);

public VetexInterface<T> getPredecessor();

public boolean hasPredecessor();

public void setCost(double newCost);

public double getCost();

}

 

2.顶点类，内含属性边类

Edge ，内又含顶点

 

package com.jimmy.impl;

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

import com.jimmy.VetexInterface;

public class Vetex<T> implements VetexInterface<T> {

 private double cost;
 private T label;
 private boolean visited;
 public  MyLinkedListWithIterator edgeList=new MyLinkedListWithIterator();
 private VetexInterface<T> pre;
 
 private class neighborIterator implements Iterator<VetexInterface<T>>{

  private Iterator<Edge> edges;
  private neighborIterator()
  {
   edges=edgeList.getIteratorForLinkedList();
  }
  public boolean hasNext() {
   
   return edges.hasNext();
  }

  @Override
  public VetexInterface<T> next() {
   VetexInterface<T> neighbor=null;
   if(edges.hasNext())
   {
    Edge edgreToNextNeighbor=edges.next();
    neighbor=edgreToNextNeighbor.getVet();
   }else
   {
    throw new NoSuchElementException();
    
   }
   
   return neighbor;
  }

  @Override
  public void remove() {
   throw new UnsupportedOperationException();
   
  }
  
 }
 
 protected class Edge implements Serializable {
  /**
   *
   */
  private static final long serialVersionUID = 1L;
  private VetexInterface<T> vet;
  private double weight;

  protected Edge(VetexInterface<T> end, double edgeWeight) {
   vet = end;
   weight = edgeWeight;

  }

  public VetexInterface<T> getVet() {
   return vet;
  }

  public void setVet(VetexInterface<T> vet) {
   this.vet = vet;
  }

  public double getWeight() {
   return weight;
  }

  public void setWeight(double weight) {
   this.weight = weight;
  }
 }

 public Vetex(T label) {
  edgeList=new MyLinkedListWithIterator<Edge>();
  this.label = label;
  visited = false;
  pre = null;
  cost = 0;
 }

 @Override
 public T getLabel() {
  
  return this.label;
 }

 @Override
 public void visit() {
 // System.out.println(this.getLabel());
  visited = true;

 }

 @Override
 public boolean isVisit() {
  
  return visited==true;
 }

 @Override
 public void unvisit() {
  visited=false;

 }
  public Iterator<VetexInterface<T>> getNeighborIterator()
  {
   return new neighborIterator();
  }

 @Override
 public boolean connect(VetexInterface<T> end, double edgeWeight) {

  boolean result = false;
  if (!this.equals(end)) {
   Iterator<VetexInterface<T>> neighbors=this.getNeighborIterator();
 boolean duplicateEdge=false;
  while(!duplicateEdge&&neighbors.hasNext())
   {
   VetexInterface<T> neighbor=neighbors.next();
   if(end.equals(neighbor))
    {duplicateEdge=true;
    break;
    }
   
   }
  if(!duplicateEdge)
  {
   edgeList.add(new Edge(end,edgeWeight));
   result=true;
   
  }
  }

  return result;
 }

 @Override
 public boolean connect(VetexInterface<T> end) {
  
  return connect(end,0);
 }

 @Override
 public boolean hasNeighbor() {
  
  return !edgeList.isEmpty();
 }

 @Override
 public VetexInterface<T> getUnvisitedNeighbor() {
  VetexInterface<T> result=null;
  Iterator<VetexInterface<T>> neighbors=this.getNeighborIterator();
  while(neighbors.hasNext()&&(result!=null))
  {
   VetexInterface<T> nextNeighbor=neighbors.next();
   if(!nextNeighbor.isVisit())
    result=nextNeighbor;
   
  }
  return result;
 }

 @Override
 public boolean equals(Object obj) {
  boolean result;
  if((obj==null)||getClass()!=obj.getClass())
    result=false;
  else
  {
   Vetex<T> other=(Vetex<T>)obj;
   result=label.equals(other.label);
  }
  return result;
 }

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

 }

 @Override
 public VetexInterface<T> getPredecessor() {
  
  return this.pre;
 }

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

 public void setCost(double newCost) {
  cost = newCost;
 }

 public double getCost() {
  // TODO Auto-generated method stub
  return cost;
 }
 public String toString()
 {
  //System.out.println(this.label);
  return this.label.toString();
 }

 

}

3.有向图

package com.jimmy.impl;

import java.util.HashMap;

import java.util.Iterator;

import com.jimmy.GraphInterface;

import com.jimmy.QueueInterf;

import com.jimmy.VetexInterface;

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

public static void main(String[] args) {

DirectedGraph g=new DirectedGraph();

String a=new String("A");

String b=new String("B");

String c=new String("C");

String d=new String("D");

String e=new String("E");

String f=new String("F");

String gg=new String("G");

String h=new String("H");

String i=new String("I");

g.addVetex(a);

g.addVetex(b);

// g.addVetex(c);

 

g.addVetex(d);

g.addVetex(e);

// g.addVetex(f);

 

g.addVetex(gg);

g.addVetex(h);

// g.addVetex(i);

 

g.addEdge(a, b,2);

g.addEdge(a, d,5);

g.addEdge(a, e,4);

g.addEdge(b, e,1);

g.addEdge(d, gg,2);

// g.addEdge(e, f,3);

 

g.addEdge(e, h,6);

g.addEdge(gg, h,1);

// g.addEdge(h,i,1);

 

// g.addEdge(i, f,1);

 

// g.addEdge(f, c,4);

 

// g.addEdge(c, b,3);

 

g.getBreadthFirstTranversal(a);

}

private int edgeCount;

private HashMap<T,VetexInterface<T>> vertics;

public DirectedGraph()

{

this.edgeCount=0;

vertics=new HashMap<T,VetexInterface<T>>();

}

public boolean addVetex(T label)

{

VetexInterface<T> isDuplicate=vertics.put(label, new Vetex(label));

return isDuplicate==null;

}

public boolean addEdge(T begin,T end,double edgeWeight){

boolean result=false;

VetexInterface<T> beginV=vertics.get(begin);

VetexInterface<T> endV=vertics.get(end);

if(beginV!=null&&endV!=null)

{

result=beginV.connect(endV,edgeWeight);

}

if(result)

{

edgeCount++;

}

return result;

}

public boolean addEdge(T begin,T end){

return addEdge(begin,end,0);

}

public boolean isEmpty()

{

return vertics.isEmpty();

}

public void clear()

{

vertics.clear();

}

public int getNumOfVetics()

{

return vertics.size();

}

public int getNumOfEdge()

{

return this.edgeCount;

}

public boolean hasEdge(T begin,T end){

boolean found=false;

VetexInterface<T> beginV=vertics.get(begin);

VetexInterface<T> endV=vertics.get(end);

if(beginV!=null&&endV!=null)

{

Iterator<VetexInterface<T>> neighbors=beginV.getNeighborIterator();

while(!found&&neighbors.hasNext())

{

VetexInterface<T> neighbor=neighbors.next();

if(endV.equals(neighbor))

found=true;

}

}

return found;

}

public void resetVertics()

{

Iterator<VetexInterface<T>> vt=vertics.values().iterator();

while(vt.hasNext())

{

VetexInterface<T> nextV=vt.next();

nextV.unvisit();

nextV.setCost(0);

nextV.setPredecessor(null);

}

}

public QueueInterf<VetexInterface<T>> getBreadthFirstTranversal(T orgin)

{

resetVertics();

QueueInterf<VetexInterface<T>> vq=new LinkedQueue<VetexInterface<T>>(); //存放邻接点的新队列，动态变化

 

QueueInterf<VetexInterface<T>> tranverseOrder=new LinkedQueue<VetexInterface<T>>(); //存放遍历顺序的新队列  一直增长到ABDEGFHCI

 

VetexInterface<T> orginV=vertics.get(orgin);

orginV.visit();

tranverseOrder.enqueue(orginV);

vq.enqueue(orginV);

while(!vq.isEmpty()) //开始从A起，A出列后加入了BDE

{

VetexInterface<T> fv=vq.dequeue(); //A出列,

 

Iterator<VetexInterface<T>> edges=fv.getNeighborIterator();//edges表示A的邻接边BDE

 

System.out.print("fv ="+fv.getLabel()+" its neighbor:");

while(edges.hasNext()) //遍历A的邻接边BDE

 

{

VetexInterface<T> neighbor=edges.next();

System.out.print(neighbor.getLabel());

if(!neighbor.isVisit()){

neighbor.visit();

tranverseOrder.enqueue(neighbor); //循环访问A的邻接边BDE

 

vq.enqueue(neighbor); //同时把A的邻接点BDE放到vq做为新的邻接点

}

}

System.out.println();

LinkedQueue vqq=(LinkedQueue)vq;

System.out.print("display vetexQueue(显示当前队列的节点):");

vqq.display(); //显示A的邻接边BDE

System.out.println();

 

}

return tranverseOrder;

}

}

 

打印：

//访问A,即A出列

fv =A its neighbor:BDE                    //A的邻接点BDE

display vetexQueue(显示当前队列的节点):B,D,E,

 

//访问B,即B出列

fv =B its neighbor:E                      // B的邻接E

display vetexQueue(显示当前队列的节点):D,E,    //B出队列后剩下DE 本来压入B的邻接点E，但是E已经访问，已在队列里了

fv =D its neighbor:G                  // D的邻接点G

display vetexQueue(显示当前队列的节点):E,G,       //D出队列后剩下E，同时压入D的邻接点G ，所以就是EG

fv =E its neighbor:H                         E的邻接点H

display vetexQueue(显示当前队列的节点):G,H,

fv =G its neighbor:H

display vetexQueue(显示当前队列的节点):H,

fv =H its neighbor:

display vetexQueue(显示当前队列的节点):