Java 图的建立及DFS深度优先遍历

最新推荐文章于 2024-02-21 17:55:54 发布

原创最新推荐文章于 2024-02-21 17:55:54 发布 · 1.1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构与Java

Java与数据结构专栏收录该内容

10 篇文章

订阅专栏

本文介绍了一种使用深度优先搜索（DFS）算法遍历图的方法，并提供了详细的Java实现代码。通过栈结构辅助DFS过程，文章展示了如何添加顶点、边及执行DFS遍历。

图作为一种重要的数据结构，在实际中是非常有用的。

package num;
import java.util.*;
import java.io.*;

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 Vertex
{
   public char label;
   public boolean wasVisited;
   public Vertex(char lab)
   {
       this.label = lab;
       wasVisited = false;      //初始的时候，表示这个图的这个点未被访问过
   }
}

class G               //表示图
{
   private final int MAX_VERTS = 20;
   private Vertex[] vertexList;
   private int adjMat[][];         //邻接矩阵
   private int nVerts;
   private StackX theStack;        //栈类型
   public G()
   {
       vertexList = new Vertex[MAX_VERTS];
       adjMat = new int[MAX_VERTS][MAX_VERTS];
       nVerts = 0;
       for(int i = 0; i < MAX_VERTS; i++)
       {
           for(int j = 0; j < MAX_VERTS; j++)
               adjMat[i][j] = 0;
       }
       theStack = new StackX();
   }
   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 int getAdjUnvisitedVertex(int v)                                 //这个方法是用来将图中的某一个点是否有与其他节点关联的边以及这个节点本身是否被访问过了
   {
       for(int i = 0; i < nVerts; i++)
           if(adjMat[v][i] == 1 && vertexList[i].wasVisited == false)
           {
               return i;
           }
       return -1;
   }
   public void dfs()              //注意，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 i = 0; i < nVerts; i++)
       {
           vertexList[i].wasVisited = false;
       }
   }
}

public class Graph
{
   public static void main(String args[])
   {
       G graph = new G();
       graph.addVertex('A');
       graph.addVertex('B');
       graph.addVertex('C');
       graph.addVertex('D');
       graph.addVertex('E');
       graph.addEdge(0, 1);
       graph.addEdge(1, 2);
       graph.addEdge(0, 3);
       graph.addEdge(3, 4);
       System.out.print("Visits: ");
       graph.dfs();
       System.out.println();
   }
}

以上是采用DFS，也就是深度优先遍历算法来执行的对图中所有节点进行的扫描。