图---邻接矩阵的深度搜索与广度搜索测试一

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();

}

}