如何改进图的深度优先遍历算法，得到所有的遍历情况？

[windlyb]

如何改进图的深度优先遍历算法，得到所有的遍历情况？ 怎么改进下面的java的算法（只是随机的得到一种遍历情况），我考虑了下好像是要用两个堆栈，不知哪位高人能悉心指教下，谢谢
package DD;


class Stack1 {
private int[] values;
private int pos = -1;

Stack1(int size) {
values = new int[size];
}
void push(int value) {
values[++pos] = value;
}
int pop() {
return values[pos--];
}
int peek() {
return values[pos];
}

boolean isEmpty() {
return pos == -1;
}
}

/*class Stack2 {
private int[] values;
private int pos = -1;

Stack2(int size) {
values = new int[size];
}

void push(int value) {
values[++pos] = value; //注意++ 和--的位置
}
int pop() {
return values[pos--];
}
int peek() {
return values[pos];
}

boolean isEmpty() {
return pos == -1;
}
}*/

class Vertex1 {
boolean isVisited;
private char value;
private int id;
char[][] array = new char[5][];

Vertex1(char value, int id) {
this.value = value;
this.id = id;
}

void visit() {
isVisited = true;
print();
}

void print() {
System.out.print(value);
System.out.print(id);
}

boolean isVisited() {
return isVisited;
}

void clean() {
isVisited = false;
}
public char getValue() {
return value;
}
public int id() {
return id;
}
}

class Graph1 {
private Vertex1[] vertexs;
private int[][] adjMat;
private int pos = -1;

Graph1(int size) {
vertexs = new Vertex1[size];
adjMat = new int[size][size];
}

void add(char value, int id) {
assert pos < vertexs.length;
vertexs[++pos] = new Vertex1(value, id);
}
void connect(int from ,int to) {
adjMat[from][to] = 1;
adjMat[to][from] = 1;
}
void disconnect(int from, int to) {
adjMat[from][to] = 0;
adjMat[to][from] = 0;
}
//关键的一步
int findNeighbor(int index) {
for(int i=0; i<=pos; i++) {
if(adjMat[index][i]==1&&!vertexs[i].isVisited()) {
return i;
}
}
return -1;
}

void dfs(int index) {
if(vertexs[index] == null) {
return;
}
Stack1 s = new Stack1(vertexs.length);
vertexs[index].visit();
s.push(index);

while(!s.isEmpty()) {
index = findNeighbor(s.peek());
if (index !=-1) {
vertexs[index].visit();
s.push(index);
}
else
s.pop();
}
clean();
}

//啥意思
void clean() {
for(Vertex1 v : vertexs)
if(v != null)
v.clean();
}

public static void main(String[] args) {
Graph1 g = new Graph1(20);

g.add('a', 0);
g.add('b', 1);
g.add('c', 2);
g.add('d', 3);
g.add('e', 4);

g.connect(0, 1);
g.connect(0, 2);
g.connect(2, 3);
g.connect(1, 3);
g.connect(3, 4);

for(int i=0; i<5; i++){
g.dfs(i);
System.out.println("");
}
}
}

[sincor]

class Stack1 { 
private int[] values; 
private int pos = -1; 

Stack1(int size) { 
values = new int[size]; 
} 
void push(int value) { 
values[++pos] = value; 
} 
int pop() { 
    return values[pos--]; 
} 
int peek()  { 
return values[pos]; 
} 

boolean isEmpty() { 
return pos == -1; 
} 
} 

/*class Stack2 { 
private int[] values; 
private int pos = -1; 

Stack2(int size) { 
values = new int[size]; 
} 

void push(int value) { 
  values[++pos] = value;    //注意++ 和--的位置 
} 
int pop() { 
return values[pos--]; 
} 
int peek() { 
return values[pos]; 
} 

boolean isEmpty() { 
return pos == -1; 
} 
}*/ 

class Vertex1 { 
boolean isVisited; 
private char value; 
private int id; 
char[][] array = new char[5][]; 

Vertex1(char value, int id) { 
this.value = value; 
this.id = id; 
} 

void visit() { 
isVisited = true; 
print(); 
} 

void print() { 
System.out.print(value); 
System.out.print(id); 
} 

boolean isVisited() { 
return isVisited; 
} 

void clean() { 
isVisited = false; 
} 
public char getValue() { 
    return value; 
} 
public int id() { 
return id; 
} 
} 

class Graph1 { 
private Vertex1[] vertexs; 
private int[][] adjMat; 
private int pos = -1; 

Graph1(int size) { 
vertexs = new Vertex1[size]; 
        adjMat = new int[size][size]; 
} 

void add(char value, int id) { 
assert pos < vertexs.length; 
vertexs[++pos] = new Vertex1(value, id); 
} 
void connect(int from ,int to) { 
adjMat[from][to] = 1; 
adjMat[to][from] = 1; 
} 
void disconnect(int from, int to) { 
adjMat[from][to] = 0; 
adjMat[to][from] = 0; 
} 
//关键的一步 
int findNeighbor(int index) { 
for(int i=0; i <=pos; i++) { 
if(adjMat[index][i]==1&&!vertexs[i].isVisited()) { 
    return i; 
} 
} 
return -1; 
} 

void dfs(int index) { 
if(vertexs[index] == null) { 
return; 
} 
Stack1 s = new Stack1(vertexs.length); 
vertexs[index].visit(); 
s.push(index); 

while(!s.isEmpty()) { 
index = findNeighbor(s.peek()); 
if (index !=-1) { 
vertexs[index].visit(); 
s.push(index); 
} 
else 
s.pop(); 
} 
clean(); 
} 

//啥意思 
void clean() { 
for(Vertex1 v : vertexs) 
if(v != null) 
v.clean(); 
} 

public static void main(String[] args) { 
Graph1 g = new Graph1(20); 

g.add('a', 0); 
g.add('b', 1); 
g.add('c', 2); 
g.add('d', 3); 
g.add('e', 4); 

g.connect(0, 1); 
g.connect(0, 2); 
g.connect(2, 3); 
g.connect(1, 3); 
g.connect(3, 4); 

for(int i=0; i <5; i++){ 
g.dfs(i); 
    System.out.println(""); 
} 
} 
} 

[绿色夹克衫]

这段Java真的挺晕的,没看出来两个栈的类有什么不同!

当前这段程序应该可以遍历到所有节点吧!不知道lz要求的是不是输出所有遍历情况?

那样的话，计算量可能会非常大，确实可以实现，但需要用栈记录每次遍历的初次选择路径，感觉没什么意义。

[绿色夹克衫]

遍历情况的数量恐怕是指数级的，光是计算数量，不具体考虑遍历的过程，恐怕都不会有效率太高的方法。

[Quote=引用 3 楼 windlyb 的回复:]
是的，这段代码是可以遍历到所以的节点，

不过并不能输出该节点开始所有的遍历情况，而是只是输出其中一种

因为最近正在研究图的数据挖掘的内容和项目，希望能够得到所有的遍历情况，运用字典排序的规则来挖掘出最小DFS子树

查了很多相关深度优先的资料，发现求所有遍历方法提的极少，希望大家给小弟指点迷津，如果能够参考上面并给出代码，必
将感激涕零...
[/Quote]

[windlyb]

是的，这段代码是可以遍历到所以的节点，

不过并不能输出该节点开始所有的遍历情况，而是只是输出其中一种

因为最近正在研究图的数据挖掘的内容和项目，希望能够得到所有的遍历情况，运用字典排序的规则来挖掘出最小DFS子树

查了很多相关深度优先的资料，发现求所有遍历方法提的极少，希望大家给小弟指点迷津，如果能够参考上面并给出代码，必
将感激涕零...

[windlyb]

如果先不考虑任意图，就代码上那5个点的图而言，不知能否给出改进呢？

[ZJ159]

难啊 顶顶

[绿色夹克衫]

改进的方法有,但要获取全部遍历情况,会比较麻烦,lz可以考虑在每一次需要进行分支选择的时候,使用random来获取一条路径,
而不是按照编号的顺序.

不太清楚什么叫最小dfs子树,感觉lz的要求可以用别的方法替代实现,

[Quote=引用 5 楼 windlyb 的回复:]
如果先不考虑任意图，就代码上那5个点的图而言，不知能否给出改进呢？
[/Quote]

[genius_tong]

不懂，友情UP~

[windlyb]

能够就针对所示5个点的图，愿闻其详

[windlyb]

兄弟，能否针对所示5个点的图，愿闻其详

[Quote=引用 7 楼 litaoye 的回复:]
改进的方法有,但要获取全部遍历情况,会比较麻烦,lz可以考虑在每一次需要进行分支选择的时候,使用random来获取一条路径,
而不是按照编号的顺序.

不太清楚什么叫最小dfs子树,感觉lz的要求可以用别的方法替代实现,

引用 5 楼 windlyb 的回复:
如果先不考虑任意图，就代码上那5个点的图而言，不知能否给出改进呢？
[/Quote]

[绿色夹克衫]

5个点的dfs情况如下,又想了一下这个问题,其实LZ要的东西更像BFS的,
只不过BFS的每一种情况都可以遍历到最后。

abdce
abdec
acdbe
acdeb

bacde
bdcae
bdeca

cabde
cdbae
cdeba

dbace
dcabe
debac
decab

edbac
edcab

[Quote=引用 10 楼 windlyb 的回复:]
兄弟，能否针对所示5个点的图，愿闻其详

引用 7 楼 litaoye 的回复:
改进的方法有,但要获取全部遍历情况,会比较麻烦,lz可以考虑在每一次需要进行分支选择的时候,使用random来获取一条路径,
而不是按照编号的顺序.

不太清楚什么叫最小dfs子树,感觉lz的要求可以用别的方法替代实现,

引用 5 楼 windlyb 的回复:
如果先不考虑任意图，就代码上那5个点的图而言，不知能否给出改进呢？
[/Quote]

[windlyb]

你说的对，现在发现只有利用两个堆栈才能实现这样的要求，递归都不行。还好最终可以了，谢谢，可以结贴了
[Quote=引用 11 楼 litaoye 的回复:]
5个点的dfs情况如下,又想了一下这个问题,其实LZ要的东西更像BFS的,
只不过BFS的每一种情况都可以遍历到最后。

abdce
abdec
acdbe
acdeb

bacde
bdcae
bdeca

cabde
cdbae
cdeba

dbace
dcabe
debac
decab

edbac
edcab

引用 10 楼 windlyb 的回复:
兄弟，能否针对所示5个点的图，愿闻其详

引用 7 楼 litaoye 的回复:
改进的方法有,但要获取全部遍历情况,会比较麻烦,lz可以考…
[/Quote]

[ycsqz]

我尽管看不懂程序，还是为作者的辛苦付出顶一下！

[ycsqz]

我有一个图论的问题：图的分解与子图同构问题，不知道哪位同事帮忙讨论一下！
可是我不知道怎么才能粘贴图片，请先指导一下，谢谢