树的广度深度优先遍历

4个类，其中stack / queue 是借用的，

Stack 类

package AlgorithmGraph;

/** 
 * 栈，遵循先进后出的原则，用来保存元素 
 *  
 * @author jalo 
 *  
 */  
public class Stack {
	  
    private int[] st;  
    private int top;  
    private int count;  
  
    /** 
     * 构造一个栈 
     *  
     * @param size 
     *  栈的大小 
     */  
    public Stack(int size) {  
        st = new int[size];  
        top = -1;  
        count = 0;  
    }  
  
    /** 
     * 元素进栈 
     *  
     * @param j 
     *            要进栈的元素 
     */  
  
    public void push(int j) {  
        count++;  
        st[++top] = j;  
    }  
  
    /** 
     * 元素出栈 
     *  
     * @return 出栈的元素 
     */  
  
    public int pop() {  
  
        return st[top--];  
    }  
  
    /** 
     * 查询栈顶元素 
     *  
     * @return 栈顶元素 
     */  
  
    public int peek() {  
        return st[top];  
    }  
  
    /** 
     * 查询栈是否为空 
     *  
     * @return 栈是否为空 
     */  
  
    public boolean isEmpty() {  
        count--;  
        return (top == -1);  
    }  
  
    /** 
     * 查看栈里的所有元素 
     */  
  
    public void list() {  
  
        for (int i = 0; i < count; i++) {  
  
            System.out.print(st[i] + "   ");  
  
        }  
        System.out.println();  
    }  
  
    /** 
     * 得到栈里一共有多少元素 
     *  
     * @return 栈里的元素个数 
     */  
    public int getCount() {  
        return count;  
    }  
  
    /** 
     * 查看栈里是否包含某个元素 
     *  
     * @param i 
     *            要查询的元素 
     * @return 是否包含了要查询的元素 
     */  
  
    public boolean isContains(int i) {  
        for (int k = 0; k < st.length; k++) {  
  
            System.out.print("开始比较" + i + "此时的result:");  
            list();  
            System.out.println();  
            if (st[k] == i) {  
                return true;  
            }  
        }  
        return false;  
    }  
      
    /** 
     * 得到栈里的元素集 
     * @return 栈里的元素集合 
     */  
    public int[] getSt(){  
        return st;  
    }  
  
}

Queue 类

package AlgorithmGraph;

public class Queue {
	  
    private int[] values;  
    private int begin = -1;  
    private int end = -1;  
      
    Queue(int size){  
        values = new int[size];  
    }  
      
    void push(int value){  
        values[++begin] = value;  
    }  
      
    int pop(){  
        return values[++end];  
    }  
      
    boolean isEmpty(){  
        return begin == end;  
    }  
}

Graph 类

package AlgorithmGraph;

import java.util.Vector;

public class Graph {
	
	Stack stack ; //做中转
	Stack result;
	Queue queue ;
	int vertexNum;	//图的顶点数 
	Vector vector[];  //邻接矩阵
	int visited[];
	
	public Graph(int num) {  //顶点数
		super();
		vertexNum = num;
		vector = new Vector[num];
		visited = new int[num];
		for(int i=0;i<num;i++)
			visited[i] = 0;
		stack = new Stack(num);
		result = new Stack(num);
		queue = new Queue(num);
	}
	
	public boolean addEdge(int I, int J) {
		if(I == J) return false;
		if(I>=0 && I < vertexNum && J>=0 && J < vertexNum) {
			if(I>J) {
				int k = I;
				I = J;
				J = k;
			}
			if(isEdgeExists(I,J)) 
				return false;
			vector[I].add(new Integer(J));
			return true;
		}
		return false;
	}
	
	public boolean isEdgeExists(int I, int J) {
		if(I>=0 && I < vertexNum && J>=0 && J < vertexNum) {
			if(I>J) {
				int k = I;
				I = J;
				J = k;
			}
			if(vector[I] == null) 
				vector[I] = new Vector(9);
			for(int q=0;q<vector[I].size();q++) {
				if(((Integer)vector[I].get(q)).intValue() == J) {
					System.out.println("顶点"+I+" 和 "+J +"之间存在边");
					return true;
				}
			}
		}
		return false;
	}
	
	//深度优先遍历,思路，最开始邻接顶点一直往中转栈里面进，直到某个顶点没有邻接顶点，则栈顶(无邻接顶点的点)元素出栈，继续判断是否有邻接顶点
	public void dfs() {  
		visited[0] = 1;
		stack.push(0);
		while(!stack.isEmpty()) {
			int vertex = getAdjUnvisitedVertex(stack.peek());
			if(vertex != -1) {
				visited[vertex]=1;
				stack.push(vertex);
			} else {
				result.push(stack.peek());
				stack.pop();
			}
		}
		System.out.println("进行深度优先遍历的顺序为: ");
		while(!result.isEmpty())
			System.out.print(result.pop() + "  ");
		//result.list();
	}
	
	//广度优先遍历，思路：循环条件是队不为空，队首出队，把它的所有邻接顶点入队，循环。
	public void bsf(){  
		visited[0] = 1;
		queue.push(0);
		while(!queue.isEmpty()) {
			int vertex = queue.pop();
			result.push(vertex);
			int k;
			while((k=getAdjUnvisitedVertex(vertex))!=-1) {
				visited[k] = 1;
				queue.push(k);
			}
		}
		System.out.println("广度优先遍历：");
		result.list();
	}
	
	//得到指定节点未被访问的邻接点位置
	public int getAdjUnvisitedVertex(int v) {
		int temp;
		if(vector[v]!=null) {
			for(int j=0;j<vector[v].size();j++) {
				temp = ((Integer)vector[v].get(j)).intValue();
				if(visited[temp]==0) {
					return temp;
				}
			}
		}
		return -1;
	}
}

TestGraph 类

package AlgorithmGraph;

public class TestGraph {
	
	public static void main(String[] args) {
		Graph graph = new Graph(12);
		graph.addEdge(0, 2);
		graph.addEdge(0, 3);
		graph.addEdge(2, 4);
		graph.addEdge(2, 5);
		graph.addEdge(3, 8);
		graph.addEdge(3, 9);
		graph.addEdge(4, 6);
		graph.addEdge(4, 7);
		graph.addEdge(9, 10);
		graph.addEdge(9, 11);
		graph.dfs();
		
//		graph.addEdge(0, 1);
//		graph.addEdge(1, 2);
//		graph.addEdge(2, 3);
//		graph.addEdge(2, 4);
//		graph.addEdge(2, 5);
//		graph.addEdge(2, 6);
//		graph.addEdge(3, 7);
//		graph.bsf();
	}
}