Ｊａｖａ图的建立以及深度广度优先遍历（邻接矩阵）

package GraphPac;
//边类
public class Edge {
private int data;
private int weight;
public  enum ESTATUS{
UNDETERMINED,TREE,CROSS,FORWARD,BACKWARD
}
private ESTATUS estatus;
public Edge(int data){
this.data = data;
this.weight = -1;
this.estatus = ESTATUS.UNDETERMINED;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
public ESTATUS getEstatus() {
return estatus;
}
public void setEstatus(ESTATUS estatus) {
this.estatus = estatus;
}

}

package GraphPac;
//顶点类
public class Vertex {
private int data;//数据
private int indegree;//入度
private int outdegree;//

public enum STATUS{
UNDISCOVER,DISCOVER,VISITED

}
private STATUS status;
public STATUS getStatus() {
return status;
}
public void setStatus(STATUS discover) {
this.status = discover;
}
private int dtime;//访问初始时间
private int ftime;//最后时间
private int parent;//父节点
private int priority;//权值
public Vertex(int data){
this.data =data;
this.dtime = -1;
this.ftime = -1;
this.indegree = 0;
this.outdegree = 0;
this.parent = -1;
this.priority = -1;
this.status = STATUS.UNDISCOVER;

}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public int getIndegree() {
return indegree;
}
public void setIndegree(int indegree) {
this.indegree = indegree;
}
public int getOutdegree() {
return outdegree;
}
public void setOutdegree(int outdegree) {
this.outdegree = outdegree;
}
public int getDtime() {
return dtime;
}
public void setDtime(int dtime) {
this.dtime = dtime;
}
public int getFtime() {
return ftime;
}
public void setFtime(int ftime) {
this.ftime = ftime;
}
public int getParent() {
return parent;
}
public void setParent(int parent) {
this.parent = parent;
}
public int getPriority() {
return priority;
}
public void setPriority(int priority) {
this.priority = priority;
}


}

//图的建立，以及深度和广度优先遍历。


package GraphPac;


import java.util.ArrayList;
import java.util.Queue;
import java.util.Stack;
import java.util.concurrent.LinkedBlockingDeque;


import GraphPac.Edge.ESTATUS;
import GraphPac.Vertex.STATUS;


public class GraphMatrix {
private ArrayList<Vertex>  V = new ArrayList<Vertex>();
private Edge E[][] = new Edge[8][8];

public ArrayList<Vertex> getV() {
return V;
}
public void setV(ArrayList<Vertex> v) {
V = v;
}


//private Edge[] esz = new Edge[8];
public void addedge(int i,int j,int data){
E[i][j] = new Edge(data);
}
public void addvertex(int data){
Vertex v = new Vertex(data);
V.add(v);
}
public int getfristnbr(int i){
return getnextnbr(i,V.size());
}


public int getnextnbr(int i, int n) {
for(int j = n-1;j>-1;--j){
if(E[i][j].getData()!=0){
return j;
}
}
return -1;
}
//广度优先搜索，借助队列实现
public void BFSprint(Vertex v){
Queue<Vertex> q = new LinkedBlockingDeque<Vertex>();
v.setStatus(STATUS.DISCOVER);
q.add(v);
while(!q.isEmpty()){
Vertex ve = q.poll();
System.out.println("..."+ve.getData());
if(ve.getData() == 6){//此处为求最小路径的算法。遍历为该算法最主要部分。
int t = 0;
for(int i =ve.getParent();i>=0;i=V.get(i).getParent()){
t++;
if(i==V.indexOf(v))
break;
}
System.out.println("...distents..."+t);
break;

}
for(int u = getfristnbr(V.indexOf(ve));u>-1;u=getnextnbr(V.indexOf(ve), u)){
if(V.get(u).getStatus()==STATUS.UNDISCOVER){
V.get(u).setStatus(STATUS.DISCOVER);
E[V.indexOf(ve)][u].setEstatus(ESTATUS.TREE);
   V.get(u).setParent(V.indexOf(ve));
q.add(V.get(u));
}
else{
E[V.indexOf(ve)][u].setEstatus(ESTATUS.CROSS);
}
}
ve.setStatus(STATUS.VISITED);
}

}


//深度优先遍历。递归实现。
public void dfsprint(Vertex v){
v.setStatus(STATUS.DISCOVER);
System.out.println("深度优先..."+v.getData());
for(int u = getfristnbr(V.indexOf(v));u>-1;u=getnextnbr(V.indexOf(v), u)){
if(V.get(u).getStatus()==STATUS.UNDISCOVER){
V.get(u).setParent(V.indexOf(v));
dfsprint(V.get(u)); 
}
}
v.setStatus(STATUS.VISITED);
return;
}






//深度优先，非递归实现
public void dfsprint2(Vertex v){
Stack<Vertex> s = new Stack<Vertex>();
s.push(v);
while(!s.isEmpty()){
Vertex ve=s.pop();
ve.setStatus(STATUS.DISCOVER);
System.out.println("深度优先..."+ve.getData());
ve.setStatus(STATUS.VISITED);
for(int u = getfristnbr(V.indexOf(ve));u>-1;u=getnextnbr(V.indexOf(ve), u)){
if(V.get(u).getStatus()==STATUS.UNDISCOVER){//关键部分，找到一个满足条件的节点，压人栈中。
s.push(V.get(u));
break;
}
}


}


}
public void DFSprint(Vertex v){
int vs=0;
do{
if(v.getStatus()!=STATUS.VISITED){
dfsprint2(v);
}
  v = V.get(++vs);
}while(vs<V.size()-1);//此处加入循环，避免遍历不到的节点，未遍历，枚举个顶点
}





public static void main(String[] args){
GraphMatrix gmx = new GraphMatrix();
gmx.addvertex(1);
gmx.addvertex(2);
gmx.addvertex(3);
gmx.addvertex(4);
gmx.addvertex(5);
gmx.addvertex(6);
gmx.addvertex(7);
gmx.addvertex(8);
for(int i=0;i<8;i++){
for(int j=0;j<8;j++){
gmx.addedge(i, j, 0);
}
}
gmx.addedge(0, 1, 1);
gmx.addedge(1, 0, 1);
gmx.addedge(0, 3, 1);
gmx.addedge(0, 6, 1);
gmx.addedge(3, 0, 1);
gmx.addedge(6, 0, 1);
gmx.addedge(1, 2, 1);
gmx.addedge(2, 1, 1);
gmx.addedge(1, 6, 1);
gmx.addedge(6, 1, 1);
gmx.addedge(2, 7, 1);
gmx.addedge(7, 2, 1);
gmx.addedge(2, 5, 1);
gmx.addedge(5, 2, 1);
gmx.addedge(3, 6, 1);
gmx.addedge(6, 3, 1);
gmx.addedge(3, 4, 1);
gmx.addedge(4, 3, 1);
gmx.addedge(4, 5, 1);
gmx.addedge(5, 4, 1);
gmx.addedge(5, 7, 1);
gmx.addedge(7, 5, 1);
gmx.addedge(6, 7, 1);
gmx.addedge(7, 6, 1);
gmx.addedge(6, 4, 1);
gmx.addedge(4, 6, 1);
//gmx.BFSprint(gmx.getV().get(0));
gmx.DFSprint(gmx.getV().get(0));
//System.out.println("distents is "+gmx.mindis(gmx.getV().get(0),gmx.getV().get(2) ));
}

}