数据结构：关键路径，利用DFS遍历每一条关键路径JAVA语言实现

     这是我们学校做的数据结构课设，要求分别输出关键路径，我查遍资料java版的只能找到关键路径，但是无法分别输出关键路径

     c++有可以分别输出的，所以在明白思想后自己写了一个java版的

     函数带有输入函数也有已经存进去的图

    

    如上图关键路径被分别输出（采用了DFS算法）：

     例：AOE 图如下：

  

      算法设计如下：

       1. 首先，要求关键路径，要先要先写拓扑排序，如果图中有环，就无法进行关键路径的求解，直接跳出。

   拓扑排序：利用栈stack，先将入度为0事件节点的加入栈中，然后编历后面的活动节点，每次给活动节点的入度减一，然后将入度为0的加入栈       stack中，每次出栈的加入栈stack中，stack1中的元素拓扑排序的逆序，然后根据核心算法：

    if(etv[p.getData()]+p1.getInfo()>etv[p1.getAdjvex()]){
    etv[p1.getAdjvex()]=etv[p.getData()]+p1.getInfo();
    }

计算出事件的最早发生时间的事件存入etv

    然后根据count来判断图中有没有回路。

2. 然后对拓扑排序的逆序求事件的最晚发生时间，根据核心法：

     if (ltv[p1.getAdjvex()]-p1.getInfo()<ltv[p.getData()]){
    ltv[p.getData()]=Math.abs(ltv[p1.getAdjvex()]-p1.getInfo());
        }

    算出事件的最晚发生时间存入数组ltv中。

3. 接着求活动的最晚发生时间el和活动的最早发生时间ee

     　　　　ee=etv[i];
　　　　el=ltv[pn.getAdjvex()]-pn.getInfo();

    当ee和el相等的时候，本活动就为关键活动，关键路径算出来了。

     解决输出每条关键路径：

4. 输出每一条关键路径：利用DFS算法（回溯算法），

图在遍历以前已经将关键路径用visited数组标记了，

故遍历的时候只遍历关键路径，

原理如图：

当visited为0的时候为关键节点，然后遍历此节点进入递归：

while (p!=null){
     if(visited[p.getAdjvex()]!=1){
        /**
         * 是关键路径就入栈
         */
        stack2.push(p);
        DFS(p.getAdjvex());
        /**
         * 遇见死路回退的时候出栈
         */
        stack2.pop();
    }

本算法类似走迷宫，并且每走一个点，就把这个点入栈，并且将visited数组中的本节点的值存为1，代表遍历过了：

　　　　　　　　　　　　　　　　visited[k]=1;

然后递归进入下一个节点，遇见终点就先遍历并输出栈中的元素：

if(k==finall) {
     for (int i=0;i<stack2.size;i++) {
        System.out.print(stack2.peekTravel(i).getName() + "->");
        }
    } 

一边退回一边出栈：

  DFS(p.getAdjvex());
        /**
         * 遇见死路回退的时候出栈
         */
        stack2.pop();

即栈中元素只到分岔点，退回上一次的分岔点，然后递归进入下一条路，直到遍历结束，然后输出了全部的关键路径。

   　　　　　　　　　　　　　　

DFS算法全部代码：

/**
 * 为了输出每条关键路径用到DFS算法
 * @param k 起点再数组中的下标
 */
public void DFS(int k){
    visited[k]=1;
    lineNode p=new lineNode();
    p=vexList[k].getNext();
    /**
     * 终点永远是关键节点
     */
    visited[finall]=0;
    /**
     * 如果走到终点遍历栈的元素
     */
    if(k==finall) {
        for (int i=0;i<stack2.size;i++) {
            System.out.print(stack2.peekTravel(i).getName() + "->");
        }
    }
    /**
     * 遍历节点后面的链表
     */
    while (p!=null){
        if(visited[p.getAdjvex()]!=1){
            /**
             * 是关键路径就入栈
             */
            stack2.push(p);
            DFS(p.getAdjvex());
            /**
             * 遇见死路回退的时候出栈
             */
            stack2.pop();
        }
        System.out.println();
        p=p.getNext();
    }
}

DFS算法流程图：

　　　　　　　　　　　

 　　　　　　　　　　　　　　　　　　（流程图有问题，左端回退出栈少了循环）

　源代码如下：

    　　

package dataproject.importanRoad;
import dataproject.stack.myArrayStack;
import java.util.Scanner;
/**
 * @author 李正阳  17060208112
 */
public class lessonWord {
    /**
     * 顶点数组
     */
    private vertexNode[] vexList;
    /**
     * etv 事件最早发生时间(即顶点）
     * ltv 事件最晚发生时间
     */
    private int etv[], ltv[];
    /**
     * 拓扑排序所用到的栈
     */
    private myArrayStack<vertexNode> stack=new myArrayStack<>();
    private myArrayStack<vertexNode> stack1=new myArrayStack<>();
    /**
     * 为了输出关键路径，标明哪些是关键节点
     */
    static int MAX_VERTEXNUM = 100;
    static int [] visited = new int[MAX_VERTEXNUM];
    /**
     *关键路径用到的栈队，数组
     */
    private myArrayStack<lineNode> stack2=new myArrayStack<>();
    private static int finall;
    /**
     * 使用键盘输入来构建图构建图
     */
    public void createGraph(){
        vertexNode pl1=new vertexNode();
        lineNode pl=new lineNode();
        int n;
        Scanner in=new Scanner(System.in);
        System.out.println("请输入共有多少个节点：");
        n=in.nextInt();
        vexList = new vertexNode[n];
        for (int i=0;i<n;i++){
            int p;
            /**
             * 构建节点
             */
            System.out.println("节点"+(i+1)+"节点存在数组中的位置 "+"节点名字");
            vertexNode v= new vertexNode( in.nextInt(), null, in.nextLine());
            pl1=v;
            pl=v.getNext();
            System.out.println("请输入此节点后有多少个边：");
            p=in.nextInt();
            for (int j=0;j<p;j++){
                /**
                 * 构建活动即事件
                 */
                System.out.println("边"+(j+1)+"后续节点在数组中的位置 "+"权值 "+"边的名字");
                lineNode a= new lineNode(in.nextInt(),in.nextInt(), in.nextInt(), null,in.next(),false);
                if(j==0){
                    pl1.setNext(a);
                    pl=pl1.getNext();
                }else {
                    pl.setNext(a);
                    pl=pl.getNext();
                }
            }
            vexList[i]=v;
        }
    }

    /**
     * 存储下的图，和我画出的图一样，方便测试
     */
    public void craeteGraph() {
        /**
         * 所有节点即事件
         */
        vertexNode v1 = new vertexNode( 0, null, "v1");
        vertexNode v2 = new vertexNode( 1, null, "v2");
        vertexNode v3 = new vertexNode(2, null, "v3");
        vertexNode v4 = new vertexNode( 3, null, "v4");
        vertexNode v5 = new vertexNode(4, null, "v5");
        vertexNode v6 = new vertexNode(5, null, "v6");
        vertexNode v7 = new vertexNode(6, null, "v7");
        vertexNode v8 = new vertexNode(7, null, "v8");
        vertexNode v9 = new vertexNode(8, null, "v9");
        /**
         * v1节点
         * a1活动，a2活动，a3活动
         */
        lineNode v12 = new lineNode(0,1, 6, null,"a1",false);
        lineNode v13 = new lineNode(0,2, 4, null,"a2",false);
        lineNode v14 = new lineNode(0,3, 5, null,"a3",false);
        lineNode a12=new lineNode(0,9,5,null,"a12",false);
        v1.setNext(v12);
        v12.setNext(v13);
        v13.setNext(v14);
        v14.setNext(a12);
        /**
         * v2节点
         * a4活动
         */
        lineNode v25 = new lineNode(1, 4, 1, null,"a4",false);
        v2.setNext(v25);
        /**
         * v3节点
         * a5活动
         */
        lineNode v35 = new lineNode(2,4, 1, null,"a5",false);
        v3.setNext(v35);
        /**
         * v4节点
         * a6活动
         */
        lineNode v46 = new lineNode(3,5, 2, null,"a6",false);
        v4.setNext(v46);
        /**
         * v5节点
         * a7活动 a8活动
         */
        lineNode v57 = new lineNode(4,6, 9, null,"a7",false);
        lineNode v58 = new lineNode(4,7, 7, null,"a8",false);
        v5.setNext(v57);
        v57.setNext(v58);
        /**
         * v6节点
         * a9活动
         */
        lineNode v68 = new lineNode(5,7, 4, null,"a9",false);
        v6.setNext(v68);
        /**
         * v7节点
         * a10活动
         */
        lineNode v79 = new lineNode(6,8, 2, null,"a10",false);
        v7.setNext(v79);
        /**
         * v8节点
         * a11活动
         */
        lineNode v89 = new lineNode(7,8, 4, null,"a11",false);
        v8.setNext(v89);
        /**
         * v10节点
         *
         */
        vertexNode v10=new vertexNode(9,null,"西安");
        /**
         * v11节点
         */
        vertexNode v11=new vertexNode(10,null,"北京");
        lineNode a13=new lineNode(8,10,6,null,"a13",false);
        lineNode a14=new lineNode(9,8,7,null,"a14",false);
        v11.setNext(a14);
        v10.setNext(a13);

        /**
         * 对象数组：vexList，保存节点构建了图
         */
        vexList = new vertexNode[11];
        vexList[0] = v1;
        vexList[1] = v2;
        vexList[2] = v3;
        vexList[3] = v4;
        vexList[4] = v5;
        vexList[5] = v6;
        vexList[6] = v7;
        vexList[7] = v8;
        vexList[8] = v9;
        vexList[9]=v10;
        vexList[10]=v11;
    }


    /**
     * 拓扑排序
     * @return true 排序成功 false 失败
     */
    public boolean topologicalSort() {
        /**
         * 计算入度：初始化所有节点的入度
         */
        for (int i=0;i<vexList.length;i++){
            vexList[i].setIn(0);
        }
        /**
         * 遍历每个节点后面的链表，然后就给弧尾顶点加一
         */
        for (int i=0;i<vexList.length;i++){
            lineNode p=new lineNode();
            p=vexList[i].getNext();
            while (p!=null){
                vertexNode vertexNode=new vertexNode();
                vertexNode=vexList[p.getAdjvex()];
                vertexNode.setIn(vertexNode.getIn()+1);
                p=p.getNext();
            }
        }

        /**
         * 计数：用来判断是否无环
         */
        int count=0;
        vertexNode p = new vertexNode();
        lineNode p1 = new lineNode();
        System.out.println("拓扑排序：");
        /**
         * 对事件最早发生时间数组初始化
         */
        etv=new int[vexList.length];
        for (int i=0;i<etv.length;i++){
            etv[i]=0;
        }
        /**
         * 将度为0的入栈
         */
        for (int i = 0; i < vexList.length; i++) {
            if (vexList[i].in == 0) {
                stack.push(vexList[i]);
            }
        }
        /**
         * 遍历领接表里面边结点，遍历到入度就减一
         */
        while (!stack .empty()) {
            p=stack.pop();
            count++;
            /**
             * 拓扑排序的逆序加入栈2中
             */
            stack1.push(p);
            System.out.print(p.getName()+" ");
            if(p.getNext()!=null){
                p1=p.getNext();
            }
            /**
             * 核心算法计算事件最早发生时间etv
             */
            while (p1!=null){
                vexList[p1.getAdjvex()].setIn(vexList[p1.getAdjvex()].getIn()-1);
                if(vexList[p1.getAdjvex()].getIn()==0){
                    stack.push(vexList[p1.getAdjvex()]);
                }
                if(etv[p.getData()]+p1.getInfo()>etv[p1.getAdjvex()]){
                    etv[p1.getAdjvex()]=etv[p.getData()]+p1.getInfo();
                }
                p1=p1.getNext();
            }
        }
        /**
         * 计数小于节点数就有回路
         * 等于就无回路
         */
        if(count!=vexList.length){
            System.out.println();
            System.out.println("图有回路！！");
            return true;
        }else {
            System.out.println();
            System.out.println("图无回路！！");
        }
        return false;
    }

    /**
     * 关键路径的方法
     */
    public void criticalPath() {
        /**
         * 活动的最早发生时间 ee
         * 活动发生的最晚时间 el
         * p 指针扫描事件节点
         * p1 扫描活动节点
         */
        int ee,el;
        vertexNode p = new vertexNode();
        lineNode p1 = new lineNode();
        /**
         * 先进行拓扑排序判断图有没有环
         */
        if (topologicalSort()){
            return;
        }
        /**
         * 初始化ltv数组
         */
         finall=stack1.peek().getData();
        ltv=new int[vexList.length];
        for (int i=0;i<vexList.length;i++){
            ltv[i]=etv[finall];
        }
        /**
         * 已经获得了拓扑排序的逆序stack2，所以对逆序求最晚发生时间
         */
        while (!stack1.empty()){
            p=stack1.pop();
            if(p.getNext()!=null){
                p1=p.getNext();
            }
            while (p1!=null){
                if (ltv[p1.getAdjvex()]-p1.getInfo()<ltv[p.getData()]){
                    ltv[p.getData()]=ltv[p1.getAdjvex()]-p1.getInfo();
                }
                p1=p1.getNext();
            }
        }

        for (int i=0;i<visited.length;i++){
            visited[i]=1;
        }
        System.out.print("关键活动为：");
        /**
         * 求ee,el和关键路径 count1表示关键活动的数量
         */
        int count1=0;
        for (int i=0;i<vexList.length;i++){
            lineNode pn=new lineNode();
            pn=vexList[i].getNext();
            while (pn!=null){
                ee=etv[i];
                el=ltv[pn.getAdjvex()]-pn.getInfo();
                if(ee==el){
                    count1++;
                   visited[vexList[i].getData()]= 0;
                    System.out.print(pn.getName()+",");
                }
                pn=pn.getNext();
            }

        }
        System.out.println();
        System.out.println("最大时间："+ltv[finall]);
           System.out.println();
    }

    /**
     * 为了输出每条关键路径用到DFS算法
     * @param k 起点再数组中的下标
     */
    public void DFS(int k){
        visited[k]=1;
        lineNode p=new lineNode();
        p=vexList[k].getNext();
        /**
         * 终点永远是关键节点
         */
        visited[finall]=0;
        /**
         * 如果走到终点遍历栈的元素
         */
        if(k==finall) {
            for (int i=0;i<stack2.size;i++) {
                System.out.print(stack2.peekTravel(i).getName() + "->");
            }
        }
        /**
         * 遍历节点后面的链表
         */
        while (p!=null){
            if(visited[p.getAdjvex()]!=1){
                /**
                 * 是关键路径就入栈
                 */
                stack2.push(p);
                DFS(p.getAdjvex());
                /**
                 * 遇见死路回退的时候出栈
                 */
                stack2.pop();
            }
            System.out.println();
            p=p.getNext();
        }
    }

    /**
     * 活动节点
     */
    class lineNode {
        /**
         * 存储该顶点对应的下标
         */
        private int adjvex;
        /**
         * 存储权值
         */
        private int info;
        /**
         * 指向下一个节点
         */
        private lineNode next;
        /**
         * 活动的名字
         */
        private String name;

        public boolean isMark() {
            return mark;
        }

        public void setMark(boolean mark) {
            this.mark = mark;
        }

        /**
         * 标识位：标识有没有遍历过
         */
        private boolean mark;

        /**
         * 弧头
         *
         */
        private int head;

        public int getHead() {
            return head;
        }

        public void setHead(int head) {
            this.head = head;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public lineNode(int head,int adjvex, int info, lineNode next, String name,boolean mark) {
            this.adjvex = adjvex;
            this.info = info;
            this.next = next;
            this.name=name;
            this.mark=mark;
            this.head=head;
        }
        public lineNode() {

        }

        public int getAdjvex() {
            return adjvex;
        }

        public void setAdjvex(int adjvex) {
            this.adjvex = adjvex;
        }

        public int getInfo() {
            return info;
        }

        public void setInfo(int info) {
            this.info = info;
        }

        public lineNode getNext() {
            return next;
        }

        public void setNext(lineNode next) {
            this.next = next;
        }
    }

    /**
     * 事件节点
     */
    class vertexNode {


        /**
         * 节点的名字
         */
        private String name;
        /**
         * 入度
         */
        private int in;
        /**
         * 储存顶点数组的下标
         */
        private int data;
        /**
         * 边的节点的头指针
         */

        private lineNode next;

        public int getIn() {
            return in;
        }

        public int getData() {
            return data;
        }

        public lineNode getNext() {
            return next;
        }

        public void setIn(int in) {
            this.in = in;
        }

        public void setData(int data) {
            this.data = data;
        }

        public void setNext(lineNode next) {
            this.next = next;
        }


        public vertexNode( int data, lineNode next, String name) {

            this.data = data;
            this.next = next;
            this.name = name;
        }

        public vertexNode() {

        }
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
    public static void main(String[] args) {
        lessonWord a=new lessonWord();
        a.craeteGraph();
//        a.createGraph();
        a.criticalPath();
        a.DFS(0);
    }
}
栈：
package dataproject.stack;
import dataproject.importanRoad.lessonWord;
import java.util.Arrays;
/**
 * @author 李正阳  17060208112
 * @param <E> 泛型
 */
public class myArrayStack<E> {
    private int DEFAULT_SIZE = 16;//定义栈的初始默认长度
    private int capacity;//保存顺序栈的长度
    public int size;//保存顺序栈中元素的个数
    private Object[] elementData;//定义一个数组用于保存顺序栈中的元素

    public myArrayStack() {
        capacity = DEFAULT_SIZE;
        elementData = new Object[capacity];
    }

    //以指定的大小来创建栈
    public myArrayStack(int initSize){
        capacity = 1;
        while(capacity < initSize) {
            capacity <<= 1;//将capacity设置成大于initSize的最小2次方
            elementData = new Object[capacity];
        }
    }

    //返回当前顺序栈中元素的个数
    public int length() {
        return size;
    }

    public E pop() {
        if(empty()) {
            throw new IndexOutOfBoundsException("栈空，不能出栈");
        }
        E oldValue = (E)elementData[size - 1];
        elementData[--size] = null;//让垃圾回收器及时回收，避免内存泄露
        return oldValue;
    }

    public void push(E element) {
        ensureCapacity(size + 1);
        elementData[size++] = element;
    }


    private void ensureCapacity(int minCapacity){
        if(minCapacity > capacity){
            while(capacity < minCapacity) {
                capacity <<= 1;
                elementData = Arrays.copyOf(elementData, capacity);
            }
        }
    }

    //获取栈顶元素，不会将栈顶元素删除
    public E peek() {
        if(size == 0) {
            throw new ArrayIndexOutOfBoundsException("栈为空");
        }
        return (E)elementData[size - 1];
    }

    /**
     * @param d 这个元素的位置
     * @return 返回d所处的元素
     */
    public E peekTravel(int d) {
        if(size == 0) {
            throw new ArrayIndexOutOfBoundsException("栈为空");
        }
        return (E)elementData[d];
    }
    public boolean empty() {
        return size == 0;
    }
    public void clear() {
        for(int i = 0; i < size; i++) {
            elementData[i] = null;
        }
        size = 0;
    }

    public static void main(String[] args) {

    }

}

流程图：