Java数据结构--图

深度优先使用栈

广度优先使用队列

/**
 * 	顶点类
 * 
 * @author Mona
 *
 */
public class Vertex {
	private String  value;
	public boolean visited;//标记是否遍历过

	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
	}

	public Vertex(String value) {
		super();
		this.value = value;
	}

	@Override
	public String toString() {
		return value;
	}
}

import algorithm.MyStack;

/**
 * 	图
 * 
 * @author Mona
 *
 */
public class Gragh {
	//顶点数组
	private Vertex[] vertex;
	private int currentsize;
	public int[][] addjMat;   //邻接矩阵--二维数组
	private MyStack stack = new MyStack();
	//当前遍历的下标
	private int currentIndex;
	
	public Gragh(int size) {
		vertex = new Vertex[size];
		addjMat = new int[size][size];
	}
	
	/**
	 * 	向图中加入一个顶点
	 * 
	 * @param v
	 */
	public void addVertex(Vertex v) {
		vertex[currentsize++] = v;
	}
	
	public void addEdge(String v1,String v2) {
		//找出两个顶点的下标
		int index1=0;
		for(int i=0;i<vertex.length;i++) {
			if(vertex[i].getValue().equals(v1)) {
				index1 = i;
				break;
			}
		}
		
		int index2=0;
		for(int i=0;i<vertex.length;i++) {
			if(vertex[i].getValue().equals(v2)) {
				index2 = i;
				break;
			}
		}
		
		addjMat[index1][index2]=1;   //1代表连通
		addjMat[index2][index1]=1;
	}
	
	/*
	 * 	深度优先搜索算法遍历图
	 * 
	 */
	public void dfs() {
		//把第0个顶点标记为已访问节点
		vertex[0].visited = true;
		//把第0个顶点的下标
		stack.push(0);
		//打印顶点的值
		System.out.println(vertex[0].getValue());
		//遍历
		out:while(!stack.isEmpty()) {
			for(int i=currentIndex+1;i<vertex.length;i++) {
				//如果和下一个遍历的元素是通的
				if(addjMat[currentIndex][i]==1 && vertex[i].visited==false) {
					//把下一个元素压入栈 中
					stack.push(i);
					vertex[i].visited=true;
					System.out.println(vertex[i].getValue());
					continue out;
				}
			}
			//弹出栈顶元素
			stack.pop();
			//修改当前位置为栈顶元素的位置
			if(!stack.isEmpty()) {
				currentIndex = stack.peek();
			}
		}
		
	}

}

前面博客中写的栈：

/**
 * 栈
 * 
 * @author Mona
 *
 */
public class MyStack {
	
	int[] elements;
	
	public MyStack() {
		elements = new int[10];
	}
	
	//压入元素
	public void push(int element) {
		//创建一个新数组
		int[] newArr = new int[elements.length+1];
		for(int i=0;i<elements.length;i++) {
			newArr[i] = elements[i];
		}
		newArr[elements.length] = element;
		//使用新数组替换旧数组
		elements = newArr;
	}
	
	//取出栈顶元素
	public int pop() {
		if(elements.length == 0) {
			throw new RuntimeException("Stack is empty!");
		}
		
		//取出最后一个元素
		int element = elements[elements.length-1];
		int[] newArr = new int[elements.length-1];
		for(int i=0;i<elements.length-1;i++) {
			newArr[i] = elements[i];
		}
		elements = newArr;
		return element;
	}
	
	//查看栈顶元素
	public int peek() {
		return elements[elements.length-1];
	}
	
	//判断栈是否为空
	public boolean isEmpty() {
		return elements.length==0;
	}
}

package vertex;

import java.util.Arrays;

public class TestGragh {
	public static void main(String[] args) {
		Vertex v1 = new Vertex("A");
		Vertex v2 = new Vertex("B");
		Vertex v3 = new Vertex("C");
		Vertex v4 = new Vertex("D");
		Vertex v5 = new Vertex("E");
		
		Gragh g = new Gragh(5);
		g.addVertex(v1);
		g.addVertex(v2);
		g.addVertex(v3);
		g.addVertex(v4);
		g.addVertex(v5);
		
		//增加边
		g.addEdge("A", "C");
		g.addEdge("B", "C");
		g.addEdge("A", "B");
		g.addEdge("B", "D");
		g.addEdge("B", "E");
		
		for(int[] a:g.addjMat) {
			System.out.println(Arrays.toString(a));
		}
		
		//深度优先遍历
		g.dfs();
	}
}