数据结构算法系列2-图

图是由顶点（vertex）和边（edge）组成的一种结构。顶点的集合V，边的集合是E，所以图记为G = （V，E）。

有向图是边有方向，无向图是边之间没有方向。无向图顶点的边数叫度，有向图顶点的边数叫出度和入度
。连通图是图的任意两个顶点都有路径可达。如果图的边有值，成为权值。图一般在程序中用矩阵，也就是数组表示。

1.图的深度优先遍历

访问顺序是： A -> C -> B -> D -> F -> G -> E

public class GraphList {
	 //节点数目
    protected int size;
    //定义数组，保存顶点信息
    protected String[] nodes;

    //定义矩阵保存顶点信息
    protected int[][] edges;
    private int[] visit;
    public GraphList() {
		super();
		 //初始化顶点
        nodes = new String[]{"A","B","C","D","E","F","G"};
        size=nodes.length;

        //初始化边---- 为了直观，做一个常量定义
        final int A=0,B=1,C=2,D=3,E=4,F=5,G=6;
        edges = new int[size][size];
        edges[A][C] = 1;
        edges[A][D] = 1;
        edges[A][F] = 1;
        edges[B][C] = 1;
        edges[C][A] = 1;
        edges[C][D] = 1;
        edges[C][B] = 1;
        edges[D][A] = 1;
        edges[D][C] = 1;
        edges[E][G] = 1;
        edges[F][A] = 1;
        edges[F][G] = 1;
        edges[G][F] = 1;
        edges[G][E] = 1;
        visit = new int[size];     //遍历标志，防止死环遍历
	}

   public  void deepList(int index){
	   System.out.print(nodes[index]+"->");
	   visit[index]=1;
	   for (int i = 0; i < size; i++) {
		if (edges[index][i]==1&&visit[i]!=1) {
			  deepList(i);
		}
	}
	   
   }

    public static void main(String[] args) {
        GraphList graph = new GraphList();
        graph.deepList(0);
    }
}

2.图的广度优先遍历

访问顺序是： A -> C -> D -> F -> B -> G -> E

public class GraphList {
	 //节点数目
    protected int size;
    //定义数组，保存顶点信息
    protected String[] nodes;

    //定义矩阵保存顶点信息
    protected int[][] edges;
    private int[] visit;
    private int[] quene;

    public GraphList() {
		super();
		 //初始化顶点
        nodes = new String[]{"A","B","C","D","E","F","G"};
        size=nodes.length;

        //初始化边---- 为了直观，做一个常量定义
        final int A=0,B=1,C=2,D=3,E=4,F=5,G=6;
        edges = new int[size][size];
        edges[A][C] = 1;
        edges[A][D] = 1;
        edges[A][F] = 1;
        edges[B][C] = 1;
        edges[C][A] = 1;
        edges[C][D] = 1;
        edges[C][B] = 1;
        edges[D][A] = 1;
        edges[D][C] = 1;
        edges[E][G] = 1;
        edges[F][A] = 1;
        edges[F][G] = 1;
        edges[G][F] = 1;
        edges[G][E] = 1;
        visit = new int[size];     //遍历标志，防止死环遍历
        quene = new int[size]; 
	}

   public  void BreadthList(int start,int end){
	   int last = end;
	   for (int i = start; i <=end; i++) {
			System.out.print(nodes[quene[i]]+"->");
		   for (int j = 0; j < size; j++) {
				if (edges[quene[i]][j]==1&&visit[j]!=1) {
					visit[j]=1;
					quene[++last]=j;
				}
			}
	}
	   
	 if (end<last) {
		 BreadthList(end+1, last);
	}  
   }

    public static void main(String[] args) {
        GraphList graph = new GraphList();
        graph.quene[0] = 0;
        graph.visit[0] = 1;
        graph.BreadthList(0,0);
    }
}

3.图的最短路径算法（Dijkstra）

1、扫描AA邻接点，记录邻接点权重值
2、找出邻接点里最小的那个值

public class Dijkstra {
	//节点数目
	protected int size;
	//定义数组，保存顶点信息
	protected String[] nodes;

	//定义矩阵保存顶点信息
	protected int[][] edges;

	private int[] isMarked;//节点确认--中心标识
	private String[] path;//源到节点的路径信息
	private int[] distances;//源到节点的距离

	public Dijkstra2(){
		init();

		isMarked = new int[size];
		path = new String[size];
		distances = new int[size];

		for (int i=0;i<size;i++){
			path[i] = "";
			distances[i] = Integer.MAX_VALUE;
		}
	}

	public static void main(String[] args) {
		Dijkstra2 dijkstra = new Dijkstra2();
		dijkstra.search(0);
	}

	public void search(int node){
		path[node] = nodes[node];
		distances[node] = 0;

		do {
			flushlast(node);
			node = getShort();
		}while (node != -1);
	}

	//1、扫描AA邻接点，记录邻接点权重值
	private void flushlast(int node){
		isMarked[node] = 1;
		System.out.println(path[node]);
		//扫描邻接点
		for (int i=0;i<size;i++){
			if (this.edges[node][i] > 0){
				//计算AA节点到 i节点的权重值
				int distant = distances[node] + this.edges[node][i];
				if (distant < distances[i]){
					distances[i] = distant;
					path[i] = path[node] +"-->"+ nodes[i];
				}
			}
		}
	}

//	2、找出邻接点里最小的那个值
	private int getShort(){
		int last = -1;

		int min = Integer.MAX_VALUE;
		for (int i=0;i<size;i++){

			if (isMarked[i] == 1){
				continue;
			}

			if (distances[i] < min){
				min = distances[i];
				last = i;
			}
		}

		return last;
	}


	public void init(){
		//初始化顶点
		nodes = new String[]{"AA","A","B","C","D","E","F","G","H","M","K","N"};
		//节点编号-常量
		final int AA=0,A=1,B=2,C=3,D=4,E=5,F=6,G=7,H=8,M=9,K=10,N=11;
		size=nodes.length;

		edges = new int[size][size];
		edges[AA][A] = 3;
		edges[AA][B] = 2;
		edges[AA][C] = 5;
		edges[A][AA] = 3;
		edges[A][D] = 4;
		edges[B][AA] = 2;
		edges[B][C] = 2;
		edges[B][G] = 2;
		edges[B][E] = 3;
		edges[C][AA] = 5;
		edges[C][E] = 2;
		edges[C][B] = 2;
		edges[C][F] = 3;
		edges[D][A] = 4;
		edges[D][G] = 1;
		edges[E][B] = 3;
		edges[E][C] = 2;
		edges[E][F] = 2;
		edges[E][K] = 1;
		edges[E][H] = 3;
		edges[E][M] = 1;
		edges[F][C] = 3;
		edges[F][E] = 2;
		edges[F][K] = 4;
		edges[G][B] = 2;
		edges[G][D] = 1;
		edges[G][H] = 2;
		edges[H][G] = 2;
		edges[H][E] = 3;
		edges[K][E] = 1;
		edges[K][F] = 4;
		edges[K][N] = 2;
		edges[M][E] = 1;
		edges[M][N] = 3;
		edges[N][K] = 2;
		edges[N][M] = 3;
	}


}