(1)、有向图，边是有方向的。

邻接矩阵表示方法上下三角形是不对称的。在添加一条边是只需要一条语句，

    //添加一个边

    public void addEdge(int start,int end){

   
adjMat[start][end] = 1;

    }

(2)、有向图的算法-拓扑排序

有向图的应用，某些项目或者事件必须按照特定的顺序排序或发生。

比如大学课程安排，要想得到学位需要必修那些课程。每年的课程都按先后关系排序，全部必修完毕，最后才能答辩，拿到学位。

拓扑排序的步骤：

(1)、找到一个没有后继的顶点(如果有一条边从A指向B,那么B是A的后继)。

(2)、从图中删除这个顶点，在列表的前面插入顶点的标记。

(3)、重复步骤1和2.直到所有的顶点都从图中删除。这时列表显示的顶点顺序就是拓扑排序的结果。

环：环图是不能进行拓扑排序的，如果有N个顶点的有向图有超过N-1条边，那么必定存在环。

Graph_topo.java

package com.mapbar.structure;

/**
 * 
 * Class Graph_topo
 * 
 * Description 有向图的拓扑排序
 * 
 * Company mapbar
 * 
 * author Chenll E-mail: Chenll@mapbar.com
 * 
 * Version 1.0
 * 
 * Date 2011-11-17 下午03:38:27
 */

//定义节点
class Vertex{
	public char label;
	
	public boolean isVisited;
	
	public Vertex(char label){
		this.label = label;
		this.isVisited = false;
	}
}

public class Graph_topo {
	//顶点数组
	private Vertex[] vArr;
	
	//定义邻接矩阵
	private int[][] adjMat;
	
	 //顶点的最大数目 
    private int maxSize; 
    
     //当前顶点 下标
    private int currVertex;
    
    private char[] sortedArr;
    
    //构造方法
    public Graph_topo(int maxSize){
    	sortedArr = new char[maxSize];
    	this.maxSize = maxSize;
    	vArr = new Vertex[maxSize];
    	adjMat = new int[maxSize][maxSize];
    	for (int i = 0; i<adjMat.length; i++){
    		for(int j = 0; j<adjMat.length; j++){
    			adjMat[i][j] = 0;
    		}
    	}
    	currVertex = 0;
    }
    
    //添加一个顶点
    public void addVertex(char label){
    	vArr[currVertex++] = new Vertex(label);
    }
    
    //添加一个边
    public void addEdge(int start,int end){
    	adjMat[start][end] = 1;
    }
    
    //显示一个顶点
    public void disVertex(int v){
    	System.out.print(vArr[v].label+",");
    }
    
    //拓扑排序
   public void topo(){
	   int orig_nVert = currVertex;
	   while(currVertex>0){
		   int cuVertex = noSuc();
		   if(currVertex==-1){
			   System.out.println("图中有环路，不能进行拓扑排序");
			   return;
		   }
		   sortedArr[currVertex-1] = vArr[cuVertex].label;
		   deleteVertex(cuVertex);
	   }
	   disAllVertex(orig_nVert);
   }
   
   //找一个没有后继结点
   public int noSuc(){
	   boolean isEdge;
	   for(int i = 0; i<currVertex; i++){
		   isEdge = false;
		   for(int j = 0; j<currVertex; j++){
			   if(adjMat[i][j]>0){
				   isEdge = true;
				   break;
			   }
		   }
		   if(!isEdge){
			   return i;
		   }
	   }
	   return -1;
   }
   
   //删除顶点，后面的顶点向前移动，同时行和列从矩阵中删除，下面的行和右边的列
   public void deleteVertex(int delV){
	   if(delV != currVertex-1){
		   //删除顶点
		   for(int j = delV; j<currVertex; j++){
			   vArr[j] = vArr[j+1];
		   }
		   
		   //删除顶点所在的邻接矩阵
		   //上移
		   for(int row = delV; row<currVertex-1; row++){
			   for(int col = 0; col<currVertex;col++){
				   adjMat[row][col] = adjMat[row+1][col];
			   }
		   }
		   
		   //左移
		   for(int col = delV; col<currVertex-1; col++){
			   for(int row = 0; row<currVertex;row++){
				   adjMat[row][col] = adjMat[row][col+1];
			   }
		   }
		   
	   }
	   currVertex--;
   }
   
	//显示拓扑排序的结果
	public void disAllVertex(int org_length){
		for(int j = 0; j<org_length; j++){
			System.out.print(sortedArr[j]+",");
		}
	}
	   
    //主调函数
    public static void main(String[] args){
    	Graph_topo g = new Graph_topo(10);
    	g.addVertex('a');
    	g.addVertex('b');
    	g.addVertex('c');
    	g.addVertex('d');
    	g.addVertex('e');
    	g.addVertex('f');   	
    	g.addEdge(0,1);
    	g.addEdge(0,2);
    	g.addEdge(1,3);
    	g.addEdge(4,5);
    	g.addEdge(5,1);
    	g.topo();
    }
}

output:

e,f,a,b,d,c,