数据结构课设教学计划编制问题Java-创新互联
[问题描述]
大学的每个专业都要制定教学计划。假设任何专业都有固定的学习年限，每学年含两学期，每学期的时间长度和学分上限值均相等。每个专业开设的课程都是确定的，而且课程在开设时间的安排必须满足先修关系。每门课程有哪些先修课程是确定的，可以有任意多门，也可以没有。每门课恰好占一个学期。试在这样的前提下设计一个教学计划编制程序。
[基本要求]
(1) 输入参数：学期总数，一学期的学分上限，每门课的课程号(固定占3位的字母数字串)、学分和直接先修课的课程号。
(2) 允许用户指定下列两种编排策略之一：一是使学生在各学期中的学习负担尽量均匀；二是使课程尽可能地集中在前几个学期中。
(3) 若根据给定的条件问题无解，则报告适当的信息；否则将教学计划输出到用户指定的文件中。计划的表格格式自行设计。
[实现提醒]
可设学期总数不超过12，课程总数不超过100。如果输入的先修课程号不在该专业开设的课程序列中，则作为错误处理。同时还应建立课程号与课程号之间的对应关系。
[测试数据]
学期总数：6；学分上限：10；该专业共开设12门课，课程号从C01到C12，学分顺序为2，3，4，3，2，3，4，4，7，5，2，3，先修关系如下图。
图13 课程先修关系
一、逻辑结构设计
利用课程之间存在先修关系，让所有的课程形成一个AOV网，各门课程看作AOV网的节点，满足课程之间的先修关系，利用图的拓扑排序来进行学期之间的课程排序安排，并按照每学期的课程学分和学习负担来输出。
二、存储结构设计
课程采用数组的方式存储方式，通过栈从AOV网当中去获取，最后通过动态的数组存储输出，AOV网的存储方式为邻接表的方式。
三、设计思路
四、主要操作设计
类图：
1.Course类，作为课程类，存放和获取课程的名字和学分。
2.ArcNode类,主要是图邻接表中边的结点类，有指向下一条边的指针域和下一个结点的位置。
3.Vnode类，主要图中点的结点类，有入度域，数据域，指针域，指向第一条边的相邻顶点。
4.Graph类，调用Vnode类建立邻接表adjList，locateVex()方法用来获取AOV网中顶点的位置，creatAdj()方法用来创建AOV网，creatConverse()方法创建反向的AOV网，用来后面Test类调用输出课程之间的先修关系。
5.Stack类，重写栈，调用Course类建立数组stackArray来存储课程信息，并将栈定指针top=-1。重写其中的push()入栈和pop()出栈方法。
6.Test类，print()方法通过对AOV网中邻接表的遍历，将其课程信息存放到栈中，再调用前面创建的反向AOV网的邻接表来输出课程的先修关系。最后在main函数里面调用该方法输出课程之间的信息关系。topSort1()方法用来判断课程能否顺利学完，若能，输出一个正确的学习顺序通过对邻接表的遍历，将其中入度为0的点压入栈中，当栈中不是空的时候，就出栈并输出一个元素，然后更新与顶点的邻接点的入度使其为0，接着重复上面的操作。当其中出栈的元素数量小于顶点表的长度使就表示有环路产生，不能学完所有课程。topSort2()方法用来实现使课程尽可能的集中在前几个学期中排课，topSort3()方法用来实现使学生在各学期中的学习负担尽量均匀排课
五、技术难点与解决方法
①怎样通过拓扑排序实现将课程尽可能集中在前几学期的教学。
解决方法：通过对AOV网邻接表的遍历，将入度为0的元素入栈，当栈不为空时，就出栈，并将出栈的元素存放到链表当中，不断重复这样的操作，直到遍历完毕，接着将链表当中课程的名字和学分分别存放到两个动态的数组，在通过for循环遍历，满足每学期的课程的学分之和不超过其上限，当剩下的课程和剩下的学期数相等时就结束循环。再创建两个数组分别存储课程名字和学分通过for循环遍历将每学期的课程不超过其学分上限存储后，最后输出剩下学期的课程。
②怎样通过拓扑排序实现使学生在各学期中的学习负担尽量均匀排课。
解决方法：将链表当中课程的名字和学分分别存储到两个动态的数组，通过一个大的for循环遍历，在里面写上一个小的for循环，循环条件j< number / semester，再通过每学期课程不超过其学分上限的条件循环输出，当I< number % semester时输出该学期的课程。
③怎样才能够获取到AOV网当中课程之间的先修关系。
解决方法：在Graph类中，创建AOV网的同时，再创建一个AOV网的反向图，然后通过for循环，循环条件：调用反向图当中邻接表的边的指向下一条边的指针，当该指针不为null，就依次指向下一个遍历输出该邻接表中的信息。
六、功能模块图
七、实现与展示
图7.1课程信息展示
图7.2课程的学习顺序可以排课
图7.4当存在先修课程不在规定的课程表当中
图7.5均匀排课
图7.6是课程集中在前几个学期
建立边结点类
package project4;
//边结点
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 = -1;
nextArc = null;
}
}
建立点结点类
package project4;
//点节点
public class Vnode {
//入度域
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 project4;
//课程信息
public class Course implements Cloneable {
private String name;
private int score;
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 getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
}重写栈类用来实现存入课程类
package project4;
public class Stack {
//用来存储课程的数组
public Course[] stackArray;
public int top;//栈顶指针
public Stack() {
top = -1;
stackArray = new Course[100];
}
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];
}
}建立AOV网实现课程先修网
package project4;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class Graph implements Cloneable { //AOV图（课程）
// 顶点表
public Vnode[] adjList;
//顶点数
private int n;
public Graph(int number) {
adjList = new Vnode[number];
n = number;
}
@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().getName().equals(c.getName())) {
return i;
}
}
return -1;
}
// 建立有向图的邻接表
public void creatAdj() throws FileNotFoundException {
System.setIn(new FileInputStream("课程"));
Scanner scanner = new Scanner(System.in);
for (int i = 0; i< n; i++) {
String name = scanner.next();
int score = scanner.nextInt();
Course c = new Course();
c.setName(name);
c.setScore(score);
adjList[i] = new Vnode();
adjList[i].setIn(0);
adjList[i].setData(c);
adjList[i].setFirstArc(null);
}
while (true) {
String str1 = scanner.next();
if (str1.equals("end")){
break;
}
String str2 = scanner.next();
int k = Integer.parseInt(str1.substring(1, 3));
if (0 >k || k >12) {
System.out.println(str1 + "先修课程号不在该专业开设的课程序列中");
System.exit(1);
}
int m = Integer.parseInt(str2.substring(1, 3));
if (0 >m || m >12) {
System.out.println(str2 + "先修课程号不在该专业开设的课程序列中");
System.exit(1);
}
Course c1 = new Course();
Course c2 = new Course();
c1.setName(str1);
c2.setName(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);
}
}
}
public void creatConverse() throws FileNotFoundException {
System.setIn(new FileInputStream("课程"));
Scanner scanner = new Scanner(System.in);
for (int i = 0; i< n; i++) {
String name = scanner.next();
int score = scanner.nextInt();
Course c = new Course();
c.setName(name);
c.setScore(score);
adjList[i] = new Vnode();
adjList[i].setIn(0);
adjList[i].setData(c);
adjList[i].setFirstArc(null);
}
while (true) {
String str1 = scanner.next();
if (str1.equals("end")){
break;
}
String str2 = scanner.next();
int k = Integer.parseInt(str1.substring(1, 3));
if (0 >k || k >12) {
System.out.println(str1 + "先修课程号不在该专业开设的课程序列中");
System.exit(1);
}
int m = Integer.parseInt(str2.substring(1, 3));
if (0 >m || m >12) {
System.out.println(str2 + "先修课程号不在该专业开设的课程序列中");
System.exit(1);
}
Course c1 = new Course();
Course c2 = new Course();
c1.setName(str2);
c2.setName(str1);
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 project4;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Test {
public static void main(String[] args) throws FileNotFoundException {
Scanner scanner = new Scanner(System.in);
System.out.println("学期总数： 每学期大学分： 必须课程数量：");
int semester = scanner.nextInt();
int score = scanner.nextInt();
int number = scanner.nextInt();
// System.out.println();
System.out.println("-------------------1.查看课程信息---------------------------------");
System.out.println("-------------------2：判断课程能否顺利学完，若能，输出一个正确的学习顺序----");
System.out.println("-------------------3：使课程尽可能的集中在前几个学期中排课---------------");
System.out.println("-------------------4：使学生在各学期中的学习负担尽量均匀排课---------------");
System.out.println("-------------------5：关闭程序---------------：");
while (true) {
int x = scanner.nextInt();
if (x == 1) {
Graph graph1 = new Graph(number);
//创建AOV无环网
graph1.creatConverse();
print(graph1, semester, score, number);
} else if (x == 2) {
Graph graph = new Graph(number);
//创建AOV无环网
graph.creatAdj();
topSort1(graph);
} else if (x == 3) {
Graph graph = new Graph(number);
//创建AOV无环网
graph.creatAdj();
topSort2(graph, semester, score, number);
} else if (x == 4) {
Graph graph = new Graph(number);
//创建AOV无环网
graph.creatAdj();
topSort3(graph, semester, score, number);
} else {
break;
}
}
scanner.close();
}
public static void print(Graph graph, int semester, int score, int number) {
Stack stack = new Stack();
stack.top = 0;
//对邻接表进行遍历，将其中度为0的点压入栈中
for (int i = graph.adjList.length - 1; i >= 0; i--) {
stack.push(graph.adjList[i].getData());
}
System.out.print("学期总数: " + semester + "\t" + "每学期大学分: " + score + "\t" + "必修课程的数量: " + number + "\n");
System.out.println("----------------专业提供的课程-----------------：");
for (int i = 0; i< number; i++) {
Course course = stack.pop();
System.out.println("----------------------------------------------");
System.out.print("课程号: " + course.getName() + "\t学分" + course.getScore() + "\t先修课程");
ArcNode p1 = new ArcNode();
for (p1 = graph.adjList[i].getFirstArc(); p1 != null; p1 = p1.nextArc) {
System.out.print(" " + graph.adjList[p1.adjVex].getData().getName());
}
System.out.println();
}
}
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.getName() + ":" + course.getScore());
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();
}
public static void topSort2(Graph graph, int semester, int score, int number) throws FileNotFoundException {
System.setOut(new PrintStream("尽可能集中在前几学期的教学计划表"));
//建立空栈，用于存放入度为0的点
ArrayListlist2 = new ArrayList<>();
ArrayListlist3 = new ArrayList<>();
ArrayListlist4 = new ArrayList<>();
ArrayListlist5 = new ArrayList<>();
Listlist = new ArrayList();
Stack stack = new Stack();
stack.top = 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集合来存储每次栈中的元素
//将所有度为零的元素全部出栈
while (stack.top != 0) {
Course course = stack.pop();
list.add(course);
}
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;
}
}
}
for (Course c : list) {
list2.add(c.getName());
list3.add(c.getScore());
}
int c = 0;
int day = 0;
for (int i = 0; i< semester - 1; i++) {
int sum1 = 0;
System.out.println("第" + (i + 1) + "学期的课程");
day++;
while (sum1 + list3.get(c)<= score) {
System.out.print(list2.get(c) + ":" + "学分：" + list3.get(c) + " ");
sum1 += list3.get(c);
if (number - 1 - c == semester - 1 - i) break;
c++;
}
System.out.println();
}
int n = 0;
for (int i = 0; i< semester - 1; i++) {
int sum = 0;
while (sum + list3.get(n)<= score) {
list4.add(list2.get(n));
list5.add(list3.get(n));
sum += list3.get(n);
if (n == number - 1) break;
n++;
}
}
for (int i = c + 1; i< number; i++) {
int sum = 0;
System.out.println("第" + (day + 1) + "学期的课程");
day++;
while (sum + list5.get(i)<= 10) {
System.out.print(list4.get(i) + ":" + "学分：" + list5.get(i));
sum += list5.get(i);
if (i == number - 1) break;
}
}
}
public static void topSort3(Graph graph, int semester, int score, int number) throws FileNotFoundException {
System.setOut(new PrintStream("均匀排课的教学计划表"));
Stack stack = new Stack();
ArrayListlist2 = new ArrayList<>();
ArrayListlist3 = new ArrayList<>();
Listlist = new ArrayList<>();
stack.top = 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) {
while (stack.top != 0) {
Course course = stack.pop();
list.add(course);
}
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;
}
}
}
for (Course c : list) {
list2.add(c.getName());
list3.add(c.getScore());
}
int n = 0;
for (int i = 0; i< semester; i++) {
int sum = 0;
System.out.println("第" + (i + 1) + "学期的课程");
for (int j = 0; j< number / semester; j++) {
if (sum + list3.get(n)<= score) {
System.out.print(list2.get(n));
System.out.print(":" + "学分：" + list3.get(n) + " ");
sum += list3.get(n);
if (n == number - 1) break;
n++;
}
}
if (i< number % semester) {
System.out.print(list2.get(n));
System.out.print("：学分：" + list3.get(n) + " ");
sum += list3.get(n);
if (n == number - 1) break;
n++;
}
System.out.println();
}
}
} 你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
网站标题：数据结构课设教学计划编制问题Java-创新互联
网站链接：http://scyanting.com/article/iooog.html
