图是一种比树更宽泛和复杂的数据结构,树只是图的一种特殊形式。
图有很多种划分方式,针对不同的划分方式可以分为连通图/非连通图、有向图/无向图、带权图/非带权图等。
图与树不同,树一般都有固定的结构,如二叉树,一个节点最多有两个子节点,因此可以通过在节点对象中添加两个属性用来存储子节点的引用(类似于边),以此方式实现二叉树。或者是用数组的方式实现数(也就是堆结构)。但是对于图来说,它的邻接顶点的个数是不确定的,因此无法像树那样通过增加邻接顶点的引用之类的方式表示。为了更好的用算法对图进行操作,需要用一种更合适的方式表示图以便计算机能够对其进行操作。
目前一般采用两种方式表示图:①邻接矩阵;②邻接表
(注意:邻接表中的->并不表示路径的意思,其实可以忽略掉它,如第一行,表示的意思是顶点A分别与B、C、D相邻)
对图进行搜索主要有两种方式,一种是深度优先搜索(DFS,通过栈实现),一种是广度优先搜索(BFS,通过队列实现)。
搜索的意思是,从指定顶点出发,找到它能到达的所有顶点。
深度优先搜索算法的思想
在无向图中进行深度优先搜索:首先选定一个顶点作为起始顶点,将起始顶点放入栈首(此时也是栈尾)作为当前顶点,并做标记表示已读,然后寻找一个当前顶点(此时是起始顶点)的邻接顶点,如果存在一个当前顶点的未被标记的邻接顶点,则将此邻接顶点放入栈尾,并把其当做新的当前顶点继续寻找与其相邻接的未被标记的顶点,直到当前顶点不存在邻接顶点或其邻接顶点全被标记为已读,则将当前顶点从栈尾弹出,然后以新的栈尾顶点为当前顶点寻找其未被标记的邻接顶点,如此迭代,直到栈中元素全被弹出时搜索完成。
下面是针对无向无权图的深度优先搜索算法的java实现
public class DFSGraph {
private int[][] adjMat;
//private int size;
private Vertex[] vertexArr;
private int num;
private StackGraph sg;
public static void main(String[] args) {
DFSGraph g = new DFSGraph(5);
g.addVertex('A');
g.addVertex('B');
g.addVertex('C');
g.addVertex('D');
g.addVertex('E');
g.addVertex('F');
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 3);
g.addEdge(2, 3);
g.addEdge(0, 4);
g.showGraph();
System.out.print("visits:");
g.dfs();
//System.out.println();
}
public DFSGraph(int s){
//size = s;
num = 0;
adjMat = new int[s][s];
vertexArr = new Vertex[s];
for(int i=0;i<s;i++){
for(int j=0;j<s;j++){
adjMat[i][j] = 0;
}
}
sg = new StackGraph(s);
}
public void addVertex(char c){
if(num<5){
Vertex nVertex = new Vertex();
nVertex.setName(c);
vertexArr[num] = nVertex;
System.out.println("添加顶点:"+c+",所处数组下标为:"+num);
num++;
}else{
System.out.println("数组已满!");
}
}
public void addEdge(int from,int to){
adjMat[from][to] = 1;
adjMat[to][from] = 1;
}
public void showGraph(){
for(int i=0;i<num;i++){
for(int j=0;j<num;j++){
int v = adjMat[i][j];
System.out.print(v+" ");
}
System.out.println();
}
}
public void showVertex(int index){
System.out.print(vertexArr[index].getName());
}
/**
* 深度优先搜索算法
*
*/
public void dfs(){
vertexArr[0].wasVisited = true;
showVertex(0);
sg.push(0);
while(!sg.isEmpty()){
int v = getAdjUnvisitedVertex(sg.peek());
if(v==-1){
sg.pop();//当当前节点找不到未被访问的临近节点时,将其从栈顶弹出
}else{
vertexArr[v].wasVisited = true;
showVertex(v);
sg.push(v);
}
}
for(int j=0;j<num;j++){
vertexArr[j].wasVisited = false;
}
}
/**
* 此方法根据传入的值查找对应的节点是否有未被访问过的临近节点,如果有,则将找到的第一个符合条件的临近节点的下标返回
* 否则返回-1
* @param v
* @return
*/
public int getAdjUnvisitedVertex(int v){
for(int i=0;i<num;i++){
if(adjMat[v][i]==1&&vertexArr[i].wasVisited==false){
return i;//找到一个就返回
}
}
return -1;
}
}
class Vertex{
private char name;
private int index;
public boolean wasVisited;
public Vertex(){
wasVisited = false;
}
public void setName(char c){
this.name = c;
}
public char getName(){
return this.name;
}
public boolean wasVisited(){
return this.wasVisited;
}
}
class StackGraph{
private int[] st;
private int top;
public StackGraph(int size){
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;
}
}
运行结果为:
下面的代码是第二天自己独立写的,虽然不够好,很粗糙,但写一遍的过程让自己对dfs理解更深了。
/**
* 在使用邻接矩阵来表示图的情况下,深度优先搜索使用栈来实现!
* 程序结构:
* ①首先应该有个顶点类用于生成顶点对象,里面应该包括一些属性,比如顶点数据项、用于检查是否被读的标记
* ②然后应该有个图类,这个图类能够在构造器中生成邻接矩阵,并包含一些方法,比如生成顶点,设置边,最重要的是有dfs算法
* ③其次应该有个栈类,用于在执行dfs算法时,将相应访问的顶点压入栈和弹出栈
* ④最后应该有个主类用于测试
* @author ht
*
*/
//主类
public class DFSGraph {
public static void main(String[] args) {
Graph g = new Graph(5);
g.generateVertex('A');
g.generateVertex('B');
g.generateVertex('C');
g.generateVertex('D');
g.generateVertex('E');
g.generateVertex('F');
g.showAdjMatrix();
g.generateEdge(0, 1);
g.generateEdge(0, 2);
g.generateEdge(1, 3);
g.generateEdge(2, 3);
g.generateEdge(0, 4);
g.showAdjMatrix();
g.dfs();
}
}
//顶点类
class Vertex{
//数据项
private char elem;
public boolean isRead;
public Vertex(char e){
this.elem = e;
isRead = false;
}
public char getElem(){
return this.elem;
}
}
//图类
class Graph{
private int graphSize;
private int[][] adjMatrix;
private Vertex newVertex;
private int countVertex;
private Vertex[] vertexArr;
private VertexStack vs;
//构造器,根据传入的参数初始化一个指定大小的邻接矩阵,并将矩阵中的元素全部设为0
public Graph(int size){
graphSize = size;
countVertex = 0;
vertexArr = new Vertex[size];
adjMatrix = new int[size][size];
vs = new VertexStack(size);
for(int i=0;i<graphSize;i++){
for(int j=0;j<graphSize;j++){
adjMatrix[i][j] = 0;
}
}
}
//生成新顶点,并将顶点对象插入数组中
public void generateVertex(char vertex_elem){
if(countVertex<graphSize){
newVertex = new Vertex(vertex_elem);
vertexArr[countVertex] = newVertex;
countVertex++;
System.out.println("生成新顶点:"+newVertex.getElem());
}else{
System.out.println("顶点个数已超出范围!无法生成新顶点:"+vertex_elem);
}
}
//设置邻接顶点,也就是生成边
public void generateEdge(int from,int to){
adjMatrix[from][to] = 1;
adjMatrix[to][from] = 1;
}
//显示邻接矩阵
public void showAdjMatrix(){
System.out.println("当前邻接矩阵显示如下:");
for(int i=0;i<graphSize;i++){
for(int j=0;j<graphSize;j++){
System.out.print(adjMatrix[i][j]+" ");
}
System.out.println();
}
}
//dfs算法,这是最重要的部分,需要跟栈配合使用。
public void dfs(){
int index = 0;
vs.push(vertexArr[0].getElem());
System.out.print("深度优先搜索结果为:");
vs.showStack(vertexArr[0].getElem());
vertexArr[0].isRead = true;
int i = 0;
while(vs.cursor!=-1){
//for(int i=0;i<graphSize;i++){
for(int j=0;j<graphSize;j++){
if(adjMatrix[i][j] == 1 && vertexArr[j].isRead == false){
vs.push(vertexArr[j].getElem());
vs.showStack(vertexArr[j].getElem());
vertexArr[j].isRead = true;
index = j;
break;
}
}
if(index == 0){
index = vs.pop()-1;
}
i = index;
index = 0;
//}
}
}
}
//用来存储dfs过程中遍历的顶点
class VertexStack{
private char[] size;
public int cursor;
public VertexStack(int stackSize){
size = new char[stackSize];
cursor = -1;
}
public void push(char elem){
size[++cursor] = elem;
}
public int pop(){
return cursor--;
}
public void showStack(char e){
System.out.print(e);
}
}
①首先应该有个顶点类用于生成顶点对象,里面应该包括一些属性,比如顶点数据项、用于检查是否被读的标记
* ②然后应该有个图类,这个图类能够在构造器中生成邻接矩阵,并包含一些方法,比如生成顶点,设置边,最重要的是有dfs算法
* ③其次应该有个栈类,用于在执行dfs算法时,将相应访问的顶点压入栈和弹出栈
* ④最后应该有个主类用于测试
* @author ht
*
*/
//主类
public class DFSGraph {
public static void main(String[] args) {
Graph g = new Graph(5);
g.generateVertex('A');
g.generateVertex('B');
g.generateVertex('C');
g.generateVertex('D');
g.generateVertex('E');
g.generateVertex('F');
g.showAdjMatrix();
g.generateEdge(0, 1);
g.generateEdge(0, 2);
g.generateEdge(1, 3);
g.generateEdge(2, 3);
g.generateEdge(0, 4);
g.showAdjMatrix();
g.dfs();
}
}
//顶点类
class Vertex{
//数据项
private char elem;
public boolean isRead;
public Vertex(char e){
this.elem = e;
isRead = false;
}
public char getElem(){
return this.elem;
}
}
//图类
class Graph{
private int graphSize;
private int[][] adjMatrix;
private Vertex newVertex;
private int countVertex;
private Vertex[] vertexArr;
private VertexStack vs;
//构造器,根据传入的参数初始化一个指定大小的邻接矩阵,并将矩阵中的元素全部设为0
public Graph(int size){
graphSize = size;
countVertex = 0;
vertexArr = new Vertex[size];
adjMatrix = new int[size][size];
vs = new VertexStack(size);
for(int i=0;i<graphSize;i++){
for(int j=0;j<graphSize;j++){
adjMatrix[i][j] = 0;
}
}
}
//生成新顶点,并将顶点对象插入数组中
public void generateVertex(char vertex_elem){
if(countVertex<graphSize){
newVertex = new Vertex(vertex_elem);
vertexArr[countVertex] = newVertex;
countVertex++;
System.out.println("生成新顶点:"+newVertex.getElem());
}else{
System.out.println("顶点个数已超出范围!无法生成新顶点:"+vertex_elem);
}
}
//设置邻接顶点,也就是生成边
public void generateEdge(int from,int to){
adjMatrix[from][to] = 1;
adjMatrix[to][from] = 1;
}
//显示邻接矩阵
public void showAdjMatrix(){
System.out.println("当前邻接矩阵显示如下:");
for(int i=0;i<graphSize;i++){
for(int j=0;j<graphSize;j++){
System.out.print(adjMatrix[i][j]+" ");
}
System.out.println();
}
}
//dfs算法,这是最重要的部分,需要跟栈配合使用。
public void dfs(){
int index = 0;
vs.push(vertexArr[0].getElem());
System.out.print("深度优先搜索结果为:");
vs.showStack(vertexArr[0].getElem());
vertexArr[0].isRead = true;
int i = 0;
while(vs.cursor!=-1){
//for(int i=0;i<graphSize;i++){
for(int j=0;j<graphSize;j++){
if(adjMatrix[i][j] == 1 && vertexArr[j].isRead == false){
vs.push(vertexArr[j].getElem());
vs.showStack(vertexArr[j].getElem());
vertexArr[j].isRead = true;
index = j;
break;
}
}
if(index == 0){
index = vs.pop()-1;
}
i = index;
index = 0;
//}
}
}
}
//用来存储dfs过程中遍历的顶点
class VertexStack{
private char[] size;
public int cursor;
public VertexStack(int stackSize){
size = new char[stackSize];
cursor = -1;
}
public void push(char elem){
size[++cursor] = elem;
}
public int pop(){
return cursor--;
}
public void showStack(char e){
System.out.print(e);
}
}
运行结果: