dfs（深度优先搜索算法）主要是通过栈的方式来实现的，主要规则是
- 选择一个初始顶点，如果可能（若存在），访问该顶点的一个邻接顶点，标记它，并把它放入栈中。
- 当不能执行 第一步 时（原顶点不存在未访问的邻接顶点），如果栈不空，就从栈中弹出一个顶点。
- 循环执行第一步、第二步，若栈空，则已完成了整个搜索过程。
bfs（广度优先搜索算法）主要是通过队列来实现的，其主要规则为：
- 遍历起始点的所有邻接点，并标记、入队。
- 所有邻接点都已入队后，即不存在未标记的邻接点时，从队头取一个顶点，并使其成为当前顶点。重复执行第一步、第二步。
- 直至因队列为空而不能执行第二步时，搜索结束。
栈的操作类：
//---------------------栈的操作
class stackX{
private final int size = 20;
private int[] st;
private int top;
public stackX(){
st = new int[size];
top = -1;
}
public void push(int i){
st[++top] = i;
}
public int pop(){
return st[top--];
}
public int peek(){
return st[top];
}
public boolean isEmpty(){
return (top==-1);
}
}队列操作类：
//---------------队列操作类
class Queue{
private final int size = 20;
private int[] queArray;
private int front;
private int rear;
public Queue(){
queArray = new int[size];
front = 0;
rear = -1;
}
public void insert(int i){
if(rear == size-1)
rear = -1;
queArray[++rear] = i;
}
public int remove(){
int temp = queArray[front++];
if(front==size)
front = 0;
return temp;
}
public boolean isEmpty(){
return (rear+1==front || front+size-1==rear);
}
}//end class Queue【dfs、bfs】具体实现代码：
图类（包括bfs、dfs算法）
//---------------------顶点类
class Vertex{
public char label;//每一个顶点的内容
public boolean wasVisited;//记录顶点是否被访问过
public Vertex(char lab){
label = lab;
wasVisited = false;//所有顶点初始化-未被访问过
}
}
class Graph{
private final int max_verts = 20;//最大顶点数
private Vertex vertexList[];//顶点集合--Vertex类
private int adjMat[][];//邻接矩阵
private int nVerts;//vertexList[]下表，记录顶点个数
private stackX theStack;//用于dfs时存储记录过程
public Graph(){
vertexList = new Vertex[max_verts];
adjMat = new int [max_verts][max_verts];
nVerts = 0;//从0开始
for(int j=0; j<max_verts; j++)
for(int k=0;k<max_verts; k++)
adjMat[j][k] = 0;//邻接矩阵--全部初始化为0;
theStack = new stackX();//初始化 栈
}
//向顶点集合中添加新的顶点
public void addVertex(char lab){
vertexList[nVerts++] = new Vertex(lab);//利用lab初始化的新顶点（Vertex）存在顶点集合中
}
//新建边，在邻接矩阵中为各顶点建立邻接关系
public void addEdge(int start,int end){
adjMat[start][end] = 1;
adjMat[end][start] = 1;
}
//用于输出
public void displayVertex(int v){
System.out.print(vertexList[v].label);
}
//----DFS深度优先搜素算法----------------------------------------------------------------
public void dfs(){
vertexList[0].wasVisited = true;//从第一个顶点开始，并标记
displayVertex(0);//输出
theStack.push(0);//入栈-----将顶点下标入栈
while(!theStack.isEmpty()){
int v = getAdjUnvisitedVertex_dfs(theStack.peek());//取出的是栈顶的顶点下标
if(v == -1){
//不存在顶点与栈顶顶点有邻接关系，出栈
theStack.pop();
}else{
//存在顶点与其有邻接关系，标记并输出、入栈
vertexList[v].wasVisited = true;
displayVertex(v);
theStack.push(v);
}
} //end while
}
//
public int getAdjUnvisitedVertex_dfs(int v){
for(int j=0;j<nVerts;j++)//遍历已有顶点，若与栈顶顶点有邻接关系，则返回其下标
if(adjMat[v][j]==1 && vertexList[j].wasVisited == false)
return j;
return -1;//若否，则返回-1
} //end getAdjUnvisitedVertex()
//----BFS深度优先搜素算法----------------------------------------------------------------
public void bfs(){
vertexList[0].wasVisited = true;
displayVertex(0);
theQueue.insert(0);
int v2;
while(!theQueue.isEmpty()){
int v1 = theQueue.remove();
while((v2 = getAdjUnvisitedVertex_bfs(v1))!=-1){
vertexList[v2].wasVisited = true;
displayVertex(v2);
theQueue.insert(v2);
}//end while
}//end while(queue ont empty)
for(int j=0;j<nVerts;j++)
vertexList[j].wasVisited = false;
}//end bfs
public int getAdjUnvisitedVertex_bfs(int v){
for(int j=0;j<nVerts;j++)
if(adjMat[v][j]==1&&vertexList[j].wasVisited == false)
return j;
return -1;
}//end getAdjUnvisitedVertex()
} //end class Graph
测试类:
public class Main{
public static void main(String[] args){
Graph theGraph = new Graph();
theGraph.addVertex('A');
theGraph.addVertex('B');
theGraph.addVertex('C');
theGraph.addVertex('D');
theGraph.addVertex('E');
theGraph.addEdge(0, 1);
theGraph.addEdge(1, 2);
theGraph.addEdge(0, 3);
theGraph.addEdge(3, 4);
System.out.print("Visits: ");
theGraph.dfs();
System.out.println();
}//end main;
}//end class Main