有两种常用的方法可用来搜索图：即深度优先搜索和广度优先搜索。它们最终都会到达所有连通的顶点。深度优先搜索通过栈来实现，而广度优先搜索通过队列来实现。
深度优先搜索：
下面图中的数字显示了深度优先搜索顶点被访问的顺序。
为了实现深度优先搜索，首先选择一个起始顶点并需要遵守三个规则：
(1) 如果可能，访问一个邻接的未访问顶点，标记它，并把它放入栈中。
(2) 当不能执行规则1时，如果栈不空，就从栈中弹出一个顶点。
(3) 如果不能执行规则1和规则2，就完成了整个搜索过程。
广度优先搜索：
在深度优先搜索中，算法表现得好像要尽快地远离起始点似的。相反，在广度优先搜索中，算法好像要尽可能地靠近起始点。它首先访问起始顶点的所有邻接点，然后再访问较远的区域。它是用队列来实现的。
下面图中的数字显示了广度优先搜索顶点被访问的顺序。
实现广度优先搜索，也要遵守三个规则：
(1) 访问下一个未来访问的邻接点，这个顶点必须是当前顶点的邻接点，标记它，并把它插入到队列中。
(2) 如果因为已经没有未访问顶点而不能执行规则1时，那么从队列头取一个顶点，并使其成为当前顶点。
(3) 如果因为队列为空而不能执行规则2，则搜索结束。
下面是一个图类的java代码，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 j){
st[++top]=j;
}
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 j){
if(rear==SIZE-1)
rear=-1;
queArray[++rear]=j;
}
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));
}
}
//
顶点类
class
Vertex
{
public char label;
public boolean wasVisited;
public Vertex(char lab){
label=lab;
wasVisited=false;
}
}
//
图类
public
class
Graph
{
private final int MAX_VERTS=20;
private Vertex vertexList[];
private int adjMat[][];
private int nVerts;
private StackX theStack;
private Queue theQueue;
/** Creates a new instance of Graph */
public Graph() {
vertexList=new Vertex[MAX_VERTS];
adjMat=new int[MAX_VERTS][MAX_VERTS];
nVerts=0;
for (int j = 0; j < MAX_VERTS; j++) {
for (int k = 0; k < MAX_VERTS; k++) {
adjMat[j][k]=0;
}
}
theStack=new StackX();
theQueue=new Queue();
}
//增加一个顶点
public void addVertex(char lab){
vertexList[nVerts++]=new Vertex(lab);
}
//增加一条边
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);
}
//深度优先搜索
public void dfs(){
vertexList[0].wasVisited=true;
displayVertex(0);
theStack.push(0);
while(!theStack.isEmpty()){
int v=getAdjUnvisitedVertex(theStack.peek());
if(v==-1)
theStack.pop();
else{
vertexList[v].wasVisited=true;
displayVertex(v);
theStack.push(v);
}
}
for(int j=0;j<nVerts;j++)
vertexList[j].wasVisited=false;
}
//得到与v顶点邻接且未访问过的顶点标号
public int getAdjUnvisitedVertex(int v){
for (int j = 0; j < nVerts; j++) {
if(adjMat[v][j]==1&&vertexList[j].wasVisited==false)
return j;
}
return -1;
}
//广度优先搜索
public void bfs(){
vertexList[0].wasVisited=true;
displayVertex(0);
theQueue.insert(0);
int v2;
while(!theQueue.isEmpty()){
int v1=theQueue.remove();
while((v2=getAdjUnvisitedVertex(v1))!=-1){
vertexList[v2].wasVisited=true;
displayVertex(v2);
theQueue.insert(v2);
}
}
for (int j = 0; j < nVerts; j++) {
vertexList[j].wasVisited=false;
}
}
}
深度优先搜索：
下面图中的数字显示了深度优先搜索顶点被访问的顺序。
为了实现深度优先搜索，首先选择一个起始顶点并需要遵守三个规则：
(1) 如果可能，访问一个邻接的未访问顶点，标记它，并把它放入栈中。
(2) 当不能执行规则1时，如果栈不空，就从栈中弹出一个顶点。
(3) 如果不能执行规则1和规则2，就完成了整个搜索过程。
广度优先搜索：
在深度优先搜索中，算法表现得好像要尽快地远离起始点似的。相反，在广度优先搜索中，算法好像要尽可能地靠近起始点。它首先访问起始顶点的所有邻接点，然后再访问较远的区域。它是用队列来实现的。
下面图中的数字显示了广度优先搜索顶点被访问的顺序。
实现广度优先搜索，也要遵守三个规则：
(1) 访问下一个未来访问的邻接点，这个顶点必须是当前顶点的邻接点，标记它，并把它插入到队列中。
(2) 如果因为已经没有未访问顶点而不能执行规则1时，那么从队列头取一个顶点，并使其成为当前顶点。
(3) 如果因为队列为空而不能执行规则2，则搜索结束。
下面是一个图类的java代码，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 j){ st[++top]=j; } 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 j){ if(rear==SIZE-1) rear=-1; queArray[++rear]=j; } 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)); }}
//
顶点类
class
Vertex
{ public char label; public boolean wasVisited; public Vertex(char lab){ label=lab; wasVisited=false; }}
//
图类
public
class
Graph
{ private final int MAX_VERTS=20; private Vertex vertexList[]; private int adjMat[][]; private int nVerts; private StackX theStack; private Queue theQueue; /** Creates a new instance of Graph */ public Graph() { vertexList=new Vertex[MAX_VERTS]; adjMat=new int[MAX_VERTS][MAX_VERTS]; nVerts=0; for (int j = 0; j < MAX_VERTS; j++) { for (int k = 0; k < MAX_VERTS; k++) { adjMat[j][k]=0; } } theStack=new StackX(); theQueue=new Queue(); } //增加一个顶点 public void addVertex(char lab){ vertexList[nVerts++]=new Vertex(lab); } //增加一条边 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); } //深度优先搜索 public void dfs(){ vertexList[0].wasVisited=true; displayVertex(0); theStack.push(0); while(!theStack.isEmpty()){ int v=getAdjUnvisitedVertex(theStack.peek()); if(v==-1) theStack.pop(); else{ vertexList[v].wasVisited=true; displayVertex(v); theStack.push(v); } } for(int j=0;j<nVerts;j++) vertexList[j].wasVisited=false; } //得到与v顶点邻接且未访问过的顶点标号 public int getAdjUnvisitedVertex(int v){ for (int j = 0; j < nVerts; j++) { if(adjMat[v][j]==1&&vertexList[j].wasVisited==false) return j; } return -1; } //广度优先搜索 public void bfs(){ vertexList[0].wasVisited=true; displayVertex(0); theQueue.insert(0); int v2; while(!theQueue.isEmpty()){ int v1=theQueue.remove(); while((v2=getAdjUnvisitedVertex(v1))!=-1){ vertexList[v2].wasVisited=true; displayVertex(v2); theQueue.insert(v2); } } for (int j = 0; j < nVerts; j++) { vertexList[j].wasVisited=false; } } }
2117
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
