package test_kepler;
import java.util.*;
import test_kepler.Treeandgraph.Node;
public class MyGraph {
//In this class we assume we focus on the node in a graph;
ArrayList<ArrayList<EdgeNode>> G = new ArrayList<ArrayList<EdgeNode>>();
int nodeNumber;
public MyGraph(int nodeNm)
{
nodeNumber=nodeNm;
for(int i = 0;i<nodeNumber;++i)
{
G.add(new ArrayList<EdgeNode>());
}
}
public void set(int fromNode,int inNode,int edgeValue)
{
//fromNode--;
//inNode--;
//edgeValue--;
EdgeNode newedgeNode = null;
if(fromNode<nodeNumber && inNode < nodeNumber)
{
newedgeNode = new EdgeNode(fromNode,inNode,edgeValue);
G.get(fromNode).add(newedgeNode);
}
else
{
System.out.println("set number is wrong");
}
}
public void MakeGraph()
{
set(0,1,5);
set(1,3,1);
set(1,2,3);
set(0,2,2);
set(2,3,6);
set(3,4,8);
set(0,4,15);
set(2,0,19);
}
public ArrayList<EdgeNode> getNeighbor(int i)
{
if(i<nodeNumber)
{
return G.get(i);
}
else
{
System.out.println("query wrong");
return null;
}
}
public void BFS(int startNode)
{
qbytwostc testq = new qbytwostc<EdgeNode>();
//start from 1;
//EdgeNode dnd = G.get(0).get(0);//perfect point ~~~
System.out.println("this is from "+ startNode);
if(G.get(startNode).size() == 0)
{
System.out.println(startNode+" is a bad point ");
return ;
}
EdgeNode dnd = G.get(startNode).get(0);
// dnd.print();
testq.enQueue(dnd);
// System.out.println("after enqueue");
while(!testq.isEmpty())
{
EdgeNode headfrmQueue = (EdgeNode) testq.dequeue();
if(headfrmQueue.isVisted == false)
{
headfrmQueue.isVisted = true;
headfrmQueue.print();
}
Iterator<EdgeNode> it = G.get(headfrmQueue.inNode).iterator();
while(it.hasNext())
{
EdgeNode x = it.next();
if(x.isVisted == false)
{
x.isDiscovered = true;
testq.enQueue(x);
}
}
Iterator<EdgeNode> it2 = G.get(headfrmQueue.fromNode).iterator();
while(it2.hasNext())
{
// System.out.println("2??");
EdgeNode x2 = it2.next();
if(x2.isVisted == false)// && x2.isDiscovered == false)
{
x2.isDiscovered = true;
testq.enQueue(x2);
}
}
}
clear();
}
// dfs - recursive
public void DFS(EdgeNode startNode)
{
if(startNode.isVisted == false)
{
startNode.print();
startNode.isVisted = true;
}
Iterator<EdgeNode> it = G.get(startNode.inNode).iterator();
while(it.hasNext())
{
EdgeNode x = it.next();
if(x.isVisted == false)
{
DFS(x);
}
}
Iterator<EdgeNode> it2 = G.get(startNode.fromNode).iterator();
while(it2.hasNext())
{
// System.out.println("2??");
EdgeNode x2 = it2.next();
if(x2.isVisted == false)// && x2.isDiscovered == false)
{
this.DFS(x2);
}
}
}
// wrap for DFS
public void DFS_wrap(int startNode)
{
if(G.get(startNode).size() == 0)
{
System.out.println(startNode+" is a bad point ");
return ;
}
EdgeNode BGNd = G.get(startNode).get(0);
// dnd.print();
System.out.println("this is from" + startNode+"====");
// DFS(BGNd);
DFS_Estack(BGNd);
this.clear();
}
public void print()
{
for(int index = 0;index<nodeNumber;++index)
{
Iterator<EdgeNode> it = G.get(index).iterator();
while(it.hasNext())
{
EdgeNode x = it.next();
x.print();
}
System.out.println("in the next line");
}
}
// CLEAR ALL THE node as un-visited
void clear()
{
for(int index = 0;index<nodeNumber;++index)
{
Iterator<EdgeNode> it = G.get(index).iterator();
while(it.hasNext())
{
EdgeNode x = it.next();
x.isVisted = false;
x.isDiscovered = false;
}
//System.out.println("in the next line");
}
}
// bfs seems easy so ; we will use dfs;
boolean isconnected(EdgeNode e1,EdgeNode e2)// the first node connected to the node 1 and node 2;
{
return false;
}
// test whether from the s->e->s;
public boolean iscyccnct(int startNd,int endNd)
{
return false;
}
// dfs with explicit stack
// the call the function itself is a kind of push stack;
// it can even get back ~~~ because the stack will pop to the ; changing-to-another-place across corneer ``
public void DFS_Estack(EdgeNode startNd1)
{
Stack<EdgeNode> dfs_stack = new Stack<EdgeNode>();
dfs_stack.push(startNd1);
while(!dfs_stack.isEmpty())
{
EdgeNode startNd = dfs_stack.pop();
if(startNd.isVisted == false)
{
startNd.print();
startNd.isVisted = true;
}
Iterator<EdgeNode> it = G.get(startNd.fromNode).iterator();
while(it.hasNext())
{
EdgeNode newNode = it.next();
if(newNode.isVisted == false)
dfs_stack.push(newNode);
}
Iterator<EdgeNode> it2 = G.get(startNd.inNode).iterator();
while(it2.hasNext())
{
EdgeNode newNode = it2.next();
if(newNode.isVisted == false)
dfs_stack.push(newNode);
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
MyGraph mg= new MyGraph(5);
mg.MakeGraph();
mg.print();
System.out.println("==== BFS RESULT ==== ");
//mg.BFS(4);
for(int i = 0;i<5;++i)
{
mg.DFS_wrap(i);
}
}
}
fw - dfs: stack/recursive ; bfs : stack/recursive- java version - 2013年12月20日18:37:18
最新推荐文章于 2022-10-30 08:00:00 发布