数据结构课设-教学计划安排-拓扑排序

数据结构课设-教学计划安排-拓扑排序

学院要求对每个专业的学生制定完备的教学计划，教学计划由课程组成，课程之间会有先后依赖关系（例如必须先学完《程序设计语言》后才能学习《数据结构》），假定每门课程需要一个学期学完，同一个学期可学习多门课程。请设计存储结构存储所有课程及其之间的依赖关系，并在此存储结构基础上完成如下操作：

\1. 输入并保存课程及课程之间的依赖关系。

\2. 判断课程能否顺利学完，若能，输出一个正确的学习顺序。

\3. 求学完这些课程最少需要几个学期，并给出一个初步的教学计划（每个学期学习哪几门课程）。

\4. 由于学生精力的限制，学校对每学期选课数的上限进行了约束，请判断约束后学生能够在原来的学期数内完成学习，若不能，此时最少需要几个学期学完这些课程**（选做）**。

package constant;
/**
* @author guo
*/
public interface MyConstants {
   /**
    * 最大容量
    */
   int MaxInt = 20;
   /**
    * 最多学期数限制
    */
   int maxStudy = 8;
}

package pojo;

/**
* @author guo
* 边结点
*/
public class ArcNode implements Cloneable{
   public int adjVex;
   public ArcNode nextArc;

   @Override
   public Object clone(){
       ArcNode arcNode = null;
       try {
           arcNode = (ArcNode) super.clone();
       } catch (CloneNotSupportedException e) {
           e.printStackTrace();
       }
       arcNode.nextArc = (ArcNode) nextArc.clone();
       return arcNode;
   }

   public ArcNode() {
       adjVex = 0;
       nextArc = null;
   }
}

package pojo;

/**
* 课程信息
* @author guo
*/
public class Course implements Cloneable{
   private String id;
   private String name;

   public Course() {
   }

   @Override
   public Object clone() throws CloneNotSupportedException {
       Course course = null;
       try {
           course = (Course)super.clone();
       } catch (CloneNotSupportedException e) {
           e.printStackTrace();
       }
       return course;
   }

   public String getId() {
       return id;
   }

   public void setId(String id) {
       this.id = id;
   }

   public String getName() {
       return name;
   }

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

package pojo;
import java.util.Scanner;
/**
* AOV图（课程）
* @author guo
*/
public class Graph implements Cloneable{
   /**
    * 顶点表
    */
   public Vnode[] adjList;
   /**
    * 边数
    */
   private int e;
   /**
    * 顶点数
    */
   private int n;
   public Graph(int number,int edge) {
       adjList = new Vnode[number];
       n = number;
       e = edge;
   }
   @Override
   public Object clone() {
       Graph graph = null;
       try {
           graph = (Graph) super.clone();
       } catch (CloneNotSupportedException e) {
           e.printStackTrace();
       }
       graph.adjList = (Vnode[])adjList.clone();
       return graph;
   }

   public void setN(int n) {
       this.n = n;
   }

   /**
    * 查找顶点位置
    */
   public int locateVex(Course c){
       for (int i = 0; i < n; i++) {
           if (adjList[i].getData().getId().equals(c.getId())) {
               return i;
           }
       }
       return -1;
   }

   /**
    * 建立有向图的邻接表
    */
   public void creatAdj(){
       Scanner scanner = new Scanner(System.in);
       for (int i = 0; i < n; i++) {
           //录入顶点信息
           System.out.println("请输入课程编号");
           String id = scanner.next();
           System.out.println("请输入课程名字");
           String name = scanner.next();
           Course c = new Course();
           c.setId(id);
           c.setName(name);
           adjList[i] = new Vnode();
           adjList[i].setIn(0);
           adjList[i].setData(c);
           adjList[i].setFirstArc(null);
       }
       System.out.println("输入依赖信息：");
       for (int i = 0; i < e; i++) {
           System.out.println("请输入第"+(i+1)+"条边的两个端点,端点间使用空格间隔即可");
           String str1 =  scanner.next();
           String str2 =  scanner.next();
           Course c1 = new Course();
           Course c2 = new Course();
           c1.setId(str1);
           c2.setId(str2);
           int a = locateVex(c1);
           int b = locateVex(c2);
           if (a >= 0 && b >= 0){
               ArcNode s = new ArcNode();
               s.adjVex = b;
               s.nextArc = adjList[a].getFirstArc();
               adjList[a].setFirstArc(s);
               adjList[b].setIn(adjList[b].getIn()+1);
           }
       }
   }
}

package pojo;
import static constant.MyConstants.MaxInt;
/**
* @author guo
*/
public class Stack {
   /**
    * 用于存储课程的数组
    */
   public Course[] stackArray;
   /**
    * 栈顶指针
    */
   public int top;

   public Stack() {
       top = -1;
       stackArray = new Course[MaxInt];
   }
   public Stack(int n){
       top = -1;
       stackArray = new Course[n];
   }
   public void push(Course course){
       if (top == stackArray.length-1){
           Course[] p = new Course[top*2+2];
           for (int i = 0; i <= top; i++) {
               p[i] = stackArray[i];
           }
           stackArray = p;
       }
       top++;
       stackArray[top] = course;
   }

   public Course pop(){
       if (top == -1){
           System.out.println("栈已空，无法再删除元素！");
           return null;
       }
       top--;
       return stackArray[top+1];
   }
}

package pojo;

/**
 * @author guo
 * 点结点
 */
public class Vnode implements Cloneable{
    /**
     * 入度域
     */
    private int in;
    /**
     * 数据域
     */
    private Course data;
    /**
     * 指针域
     */
    private ArcNode firstArc;

    public Vnode(){
        in = -1;
        data = null;
        firstArc = null;
    }
    @Override
    public Object clone() throws CloneNotSupportedException {
        Vnode vnode = null;
        try {
            vnode = (Vnode)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        vnode.in = ((Vnode)vnode.clone()).getIn();
        vnode.data = (Course)data.clone();
        vnode.firstArc = (ArcNode)firstArc.clone();
        return vnode;
    }
    public int getIn() {
        return in;
    }

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

    public Course getData() {
        return data;
    }

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

    public ArcNode getFirstArc() {
        return firstArc;
    }

    public void setFirstArc(ArcNode firstArc) {
        this.firstArc = firstArc;
    }
}

package test;

import pojo.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import static constant.MyConstants.maxStudy;

/**
 * @author guo
 */
public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入课程总数和课程依赖边数");
        System.out.println("顶点数：");
        int number = scanner.nextInt();
        System.out.println("依赖边数：");
        int edge = scanner.nextInt();
        Graph graph = new Graph(number,edge);
        //创建AOV无环网
        graph.creatAdj();
        System.out.println("输入1：题目一：判断课程能否顺利学完，若能，输出一个正确的学习顺序");
        System.out.println("输入2：题目二：求学完这些课程最少需要几个学期，并给出一个初步的教学计划（每个学期学习哪几门课程）");
        System.out.println("输入3：题目三：由于学生精力的限制，学校对每学期选课数的上限进行了约束，请判断约束后学生能够在原来的学期数内完成学习，若不能，此时最少需要几个学期学完这些课程（选做）");
        System.out.println("请输入指令：");
        int x = scanner.nextInt();
        switch (x){
            case (1):
                topSort1(graph);
                break;
            case (2):
                topSort2(graph);
                break;
            case (3):
                topSort3(graph);
                break;
            default:
                return;
        }
        scanner.close();
    }

    /**
     * 学习顺序
     * @param graph
     */
    public static void topSort1(Graph graph){
        //建立空栈，用于存放入度为0的点
        Stack stack = new Stack();
        stack.top = 0;
        int count = 0;
        //对邻接表进行遍历，将其中度为0的点压入栈中
        for (int i = 0; i < graph.adjList.length-1; i++) {
            if (graph.adjList[i].getIn() == 0){
                stack.push(graph.adjList[i].getData());
            }
        }
        System.out.println("学习顺序为：");
        while (stack.top!=0){
            //出栈并输出一个元素
            Course course = stack.pop();
            System.out.print(course.getId()+":"+course.getName());
            count++;
            //所有与其有关系的点的入度均减一
            ArcNode p = graph.adjList[graph.locateVex(course)].getFirstArc();
            while (p != null){
                int in = graph.adjList[p.adjVex].getIn()-1;
                graph.adjList[p.adjVex].setIn(in);
                //若入度减一后存在顶点的度减少为0，便将其入栈
                if (graph.adjList[p.adjVex].getIn() == 0){
                    stack.push(graph.adjList[p.adjVex].getData());
                }
                p = p.nextArc;
            }
            if (count!=graph.adjList.length){
                System.out.print("->");
            }
        }
        //出栈的元素数量小于顶点表的长度时，则表明有环产生
        if (count < graph.adjList.length){
            System.out.println("有回路产生，即无法全部学完所有课程");
        }
        System.out.println();
    }

    /**
     * 教学顺序
     * @param graph
     */
    public static void topSort2(Graph graph){
        //建立空栈，用于存放入度为0的点
        Stack stack = new Stack();
        stack.top = 0;
        int count = 0;
        int day = 0;
        //对邻接表进行遍历，将其中度为0的点压入栈中
        for (int i = 0; i < graph.adjList.length-1; i++) {
            if (graph.adjList[i].getIn() == 0){
                stack.push(graph.adjList[i].getData());
            }
        }
        while (stack.top!=0){
            //使用ArrayList集合来存储每次栈中的元素
            List<Course> list = new ArrayList<Course>();
            //将所有度为零的元素全部出栈
            while (stack.top!=0){
                Course course = stack.pop();
                list.add(course);
                count++;
            }
            day++;
            System.out.println("第"+day+"个学期的学习：");
            for (Course c : list) {
                System.out.print(c.getId()+" "+c.getName()+" ");
            }
            System.out.println();
            for (int i = 0; i < list.size(); i++) {
                ArcNode p = graph.adjList[graph.locateVex(list.get(i))].getFirstArc();
                //所有与其有关系的点的入度均减一
                while (p != null){
                    graph.adjList[p.adjVex].setIn(graph.adjList[p.adjVex].getIn()-1);
                    //若入度减一后存在顶点的度减少为0，便将其入栈
                    if (graph.adjList[p.adjVex].getIn() == 0){
                        stack.push(graph.adjList[p.adjVex].getData());
                    }
                    p = p.nextArc;
                }
            }
        }
        //若循环结束后day值大于学期最大值常数，则表明无法再大学期间学完所有课程
        if (day>maxStudy){
            System.out.println("不能在大学四年8个学期内学完");
        }else {
            System.out.println("以上为初步教学顺序");
        }
    }

    /**
     * 选课上限限制
     * @param graph
     */
    public static void topSort3(Graph graph){
        Stack stack = new Stack();
        int limit = 0;
        stack.top = 0;
        int day = 0;
        Scanner scanner = new Scanner(System.in);
        System.out.println("请设置选课上限：");
        limit = scanner.nextInt();
        //对邻接表进行遍历，将其中度为0的点压入栈中
        for (int i = 0; i < graph.adjList.length-1; i++) {
            if (graph.adjList[i].getIn() == 0){
                stack.push(graph.adjList[i].getData());
            }
        }
        while (stack.top!=0){
            int count = 0;
            List<Course> list = new ArrayList<Course>();
            //使用集合存储出栈的元素，但出栈和加入集合的元素数量应小于limit且栈不为空
            while (stack.top!=0 && count < limit){
                Course course = stack.pop();
                list.add(course);
                count++;
            }

            day++;
            System.out.println("第"+day+"个学期的学习：");
            for (Course c : list) {
                System.out.print(c.getId()+" "+c.getName()+" ");
            }
            System.out.println();
            for (int i = 0; i < list.size(); i++) {
                ArcNode p = graph.adjList[graph.locateVex(list.get(i))].getFirstArc();
                //所有与其有关系的点的入度均减一
                while (p != null){
                    graph.adjList[p.adjVex].setIn(graph.adjList[p.adjVex].getIn()-1);
                    //若入度减一后存在顶点的度减少为0，便将其入栈
                    if (graph.adjList[p.adjVex].getIn() == 0){
                        stack.push(graph.adjList[p.adjVex].getData());
                    }
                    p = p.nextArc;
                }
            }
        }
        //若学期数大于学期最大值常数，则表明无法在学完所有课程，并输出所有的学期以及所上的课程
        if (day>maxStudy){
            System.out.println("需要"+day+"个学期才能学完"+"不能在大学四年8个学期内学完");
        }else {
            System.out.println("以上为限制选课教学顺序");
        }
    }
}