图---邻接矩阵的深度搜索与广度搜索测试一
目前这里没有考虑，路径权值与方向
简单的图的深度搜索与广度搜索，备忘
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
class Point {
String name;
boolean isVisit;
public Point(String name) {
this.name = name;
}
}
/**
* @author pc
*
*/
public class Graph {
final static int LENGTH = 20;
Point[] points;
int line[][];
int curLength;
public Graph() {
points = new Point[LENGTH];
line = new int[LENGTH][LENGTH];
}
public void addLine(int x, int y) {
line[x][y] = 1;
line[y][x] = 1;
}
public void addPoint(Point v) {
points[curLength++] = v;
}
public void showName(int index) {
System.out.print(points[index].name);
}
public void showNbsp() {
System.out.print(" ");
}
private int getNextPi(Integer x) {
for (int i = 0; i < curLength; i++) {
if (!points[i].isVisit && line[x][i] > 0) {
return i;
}
}
return -1;
}
private void initPoints() {
for (int i = 0; i < curLength; i++) {
points[i].isVisit = false;
}
}
/**
* 深度搜索
* 起始点A，压入堆栈
* 1、A与B存在连线，却 B 未被访问，把B压入堆栈，
* 2、检查B与下一个节点 C 是否存在 ，像条件1的情况，不存在，将B弹出；存在将 C 压入堆栈
* 不存在时：
* 3、检查A与下一个节点关系，重复 1、2、3步，直到堆栈为空。
*/
public void dfs() {
Stack<Integer> stack = new Stack<Integer>();
showName(0);
showNbsp();
stack.push(0);
points[0].isVisit = true;
while (!stack.isEmpty()) {
int i = getNextPi(stack.peek());
if (i < 0) {
stack.pop();
} else {
stack.push(i);
showName(i);
showNbsp();
points[i].isVisit = true;
}
}
initPoints();
}
/**
* 广度搜索
* 起始点A，加入队列
* 1、A与B, C, F 存在连线，却 B, C, F 未被访问，把B, C, F 加入队列，直到没有与A有连接的节点，将A移出队列！
* 2、再从队列头中取出B，循环 条件1的操作。 直到队列为空
*
*/
public void bfs() {
Queue<Integer> queue = new LinkedList<Integer>();
showName(0);
showNbsp();
queue.add(0);
points[0].isVisit = true;
while (!queue.isEmpty()) {
int i = getNextPi(queue.peek());
if (i < 0) {
queue.poll();
} else {
queue.add(i);
showName(i);
showNbsp();
points[i].isVisit = true;
}
}
initPoints();
}
/**
* 最小生成树
* 区别是打印当前节点
*/
public void mfs() {
Stack<Integer> stack = new Stack<Integer>();
stack.push(0);
points[0].isVisit = true;
while (!stack.isEmpty()) {
Integer curIndex = stack.peek();
int i = getNextPi(curIndex);
if (i < 0) {
stack.pop();
} else {
stack.push(i);
showName(curIndex);
showName(i);
showNbsp();
points[i].isVisit = true;
}
}
initPoints();
}
/**
* 拓扑排序：
* 不能为一有向环型图
* 找到没有后继节点，加入到序列数据中
*/
public void topo(){
String sortName[] = new String[LENGTH];
int oldCur = curLength;
while(curLength > 0){
int i = noNextPi();
if(i < 0)
throw new RuntimeException("图是一个有向环");
sortName[curLength-1] = points[i].name;
deletePoint(i); //删除 这个节点
}
for(int i = 0; i < oldCur; i++){
System.out.print(sortName[i]);
showNbsp();
}
initPoints();
}
private void deletePoint(int di) {
if(di != curLength - 1){
for(int i = di; i < curLength - 1; i++){
points[i] = points[i+1];
}
for(int row = di; row < curLength - 1; row++){
moveRowUp(row, curLength);
}
for(int col = di; col < curLength - 1; col++){
moveColLeft(col, curLength);
}
}
curLength--;
}
private void moveColLeft(int col, int length) {
for (int j = 0; j < length; j++) {
line[j][col] = line[j][col + 1];
}
}
private void moveRowUp(int row, int length) {
for (int j = 0; j < length; j++) {
line[row][j] = line[row + 1][j];
}
}
private int noNextPi() {
// 找出没有子节点的
for (int i = 0; i < curLength; i++) {
boolean hasNext = false;
for (int j = 0; j < curLength; j++) {
if (line[i][j] > 0) {
hasNext = true;
}
}
if (!hasNext) {
return i;
}
}
return -1;
}
public static void printLn(String name){
System.out.println("");
System.out.println(name);
}
public static void main(String[] args) {
Graph g = new Graph();
for (int i = 65; i <= 70; i++) {
char c = (char) i;
Point point = new Point(c + "");
g.addPoint(point);
}
g.addLine(0, 1); // ab
g.addLine(0, 2); // ac
g.addLine(0, 5); // af
g.addLine(1, 3); // bd
g.addLine(2, 3); // cd
g.addLine(2, 4); // ce
g.addLine(3, 4); // de
printLn("深度搜索：");
g.dfs();
printLn("广度搜索：");
g.bfs();
printLn("最小生成树：");
g.mfs();
//printLn("拓扑排序：");
//g.topo();
}
}
