图的广度优先历遍和深度优先历遍

今天介绍图（森林）的深度优先历遍和广度优先历遍

1、以下算法是用java实现的，但核心的步骤跟C语言差不多，先介绍必要的数据结构

1.1、图（当取定图中某个顶点为树根时，可依次把图划分为一棵树或若干棵树即森林

import java.util.ArrayList;
/*
 * 图的数据结构，由顶点数组和图的类型组成
 */
public class Graph
{
	ArrayList<Point> points = new ArrayList(); //顶点数组
	String graphKind; //图的类型，此处没用到，一概假定为无向图
	
	//添加顶点
	public void addPoint(Point p){
		points.add(p);
	}
	
	//移除顶点，连与顶点有关的边都移除
	public void removePoint(Point removePoint){
		for(Point p : points)
			for(AdjacentEdge edge : p.adjcentEdges){
				if(edge.adjacentPointIndex == removePoint.pointIndex)
					p.adjcentEdges.remove(edge);
					
		}
		
		points.remove(removePoint);
	}
}

1.2、点

import java.util.LinkedList;
/*
 * 点的数据结构
 */
public class Point
{
	boolean isVisited = false; //该点是否被访问过
	int pointIndex; //点的下标
	String data;  //点代表的数据
	LinkedList<AdjacentEdge> adjcentEdges = new LinkedList(); //点的邻接边数组
	
	public Point(int pointIndex, String data){
		this.pointIndex = pointIndex;
		this.data = data;
	}
	
	//添加邻接边
	public void addAdjacentEdge(AdjacentEdge adjacentEdge){
		adjcentEdges.add(adjacentEdge);
	}
	
	//删除邻接边
	public void removeAdjacentEdge(AdjacentEdge adjacentEdge){
		adjcentEdges.remove(adjacentEdge);
	}
	
	@Override
	public String toString()
	{
		// TODO Auto-generated method stub
		return "[" + pointIndex + "]" + data + "  ";
	}
}

1.3、邻接边

/*
 * 此类代表邻接边的信息
 */
public class AdjacentEdge
{
	int adjacentPointIndex; //邻接边顶点的编号，此处的编号是顶点数组中对应的下标
	int edgeInfo;//邻接边的信息，即权值，若无则为0
	
	public AdjacentEdge(int adjacentPointIndex,int edgeInfo){
		this.adjacentPointIndex = adjacentPointIndex;
		this.edgeInfo = edgeInfo;
	}
	
	public AdjacentEdge(int adjacentPointIndex){
		this(adjacentPointIndex, 0);
	}
}

2、深度优先历遍

2.1、思路：

1）假定图的顶点数组中某顶点（第一次假定为第一个顶点）为树的根，进行访问

2）访问点后，看点是否有邻接边，有则对每一邻接边进行递归深度优先历遍

3）查看顶点数组中有没有没被访问的顶点，若有，则返回

2.2、算法实现：

public class DepthFirstSerch
{
 /* 采用递归的思想 */	
	
	//对图中某个点的访问
	public static void dfsOne(Graph graph, Point startPoint){
		System.out.print(startPoint);
		startPoint.isVisited = true;
		
		//访问顶点有无邻接边，有则进行递归，深度优先的思想，一直深入到尽头
		for(AdjacentEdge edge : startPoint.adjcentEdges)
			if(!graph.points.get(edge.adjacentPointIndex).isVisited)
				dfsOne(graph, graph.points.get(edge.adjacentPointIndex));
	}
	
	//对整个图进行深度优先历遍，对没访问过的结点逐一进行深度历遍
	public static void dfsAll(Graph graph){
		for(Point p : graph.points)
			if(!p.isVisited)
				dfsOne(graph, p);
	}
	
	//测试算法正确性
	public static void main(String[] args){
		Graph graph = new Graph(); //创建图
		//初始化顶点数组
		for(int i = 0 ; i < 10 ; i++){
			graph.addPoint(new Point(i, "point" + i));
		}
		
		//给顶点添加邻接边
		graph.points.get(0).addAdjacentEdge(new AdjacentEdge(1));
		graph.points.get(0).addAdjacentEdge(new AdjacentEdge(2));
		graph.points.get(1).addAdjacentEdge(new AdjacentEdge(3));
		graph.points.get(3).addAdjacentEdge(new AdjacentEdge(4));
		graph.points.get(2).addAdjacentEdge(new AdjacentEdge(5));
		
		//进行深度优先历遍
		dfsAll(graph);
	}
}

3、广度优先历遍
3.1、思路：

1）假定图的顶点数组中某顶点（第一次假定为第一个顶点）为树的根，该顶点未被访问，则访问后入队

2）从队列中出队一个顶点进行访问，有邻接边则且邻接边顶点未被访问，则对邻接顶点逐一访问（不递归），并按序入队

3）查看顶点数组中有没有没被访问的顶点，若有，则返回 1）

3.2、算法实现：

import java.util.LinkedList;
import java.util.Queue;

/*
 * 广度优先历遍
 */
public class BreadthFirstSearch
{
	//广度优先历遍步骤：从队列中出队一个顶点进行访问，有邻接边则对邻接边顶点逐一访问（不递归），并按序入队
	public static void bfs(Graph graph){
		Queue<Point> queue = new LinkedList<Point>(); //定义顶点队列 
		Point temp; //队列出队顶点
		for(Point p : graph.points){
			//若顶点未被访问，则访问并入队
			if(!p.isVisited){
				System.out.print(p);
				p.isVisited = true;
				queue.offer(p); //入队
			}
			//对出队顶点进行邻接顶点的访问，有未被访问到的则访问并入队
			while((temp = queue.poll()) != null)
				for(AdjacentEdge edge : temp.adjcentEdges){
					Point adjacentPoint = graph.points.get(edge.adjacentPointIndex);
					if(!adjacentPoint.isVisited){
						System.out.print(adjacentPoint);
						adjacentPoint.isVisited = true;
						queue.offer(adjacentPoint); //入队
					}
				}
		}
	}
	
	//对算法进行测试
	public static void main(String[] args){
		Graph graph = new Graph(); //初始化图
		//初始化图的顶点数组
		for(int i = 0 ; i < 10 ; i++){
			graph.addPoint(new Point(i, "point" + i));
		}
		
		//为顶点添加邻接边
		graph.points.get(0).addAdjacentEdge(new AdjacentEdge(9));
		graph.points.get(0).addAdjacentEdge(new AdjacentEdge(2));
		graph.points.get(9).addAdjacentEdge(new AdjacentEdge(3));
		graph.points.get(3).addAdjacentEdge(new AdjacentEdge(4));
		graph.points.get(2).addAdjacentEdge(new AdjacentEdge(5));
		
		//广度优先历遍
		bfs(graph);
	}
}