第一篇：java教学计划编制的全部代码
package curriculumProject;
//非连通图的深度优先搜索遍历和广度优先搜索遍历
import linearList.Queue.SeqQueue;
//顺序循环队列类
public abstract class AbstractGraph
{
public abstract int vertexCount();
//返回顶点数，方法由子类实现
public abstract E get(int i);
//返回顶点vi的数据域
public abstract int getFirstNeighbor(int i);
//返回顶点vi的第一个邻接顶点的序号
public abstract int getNextNeighbor(int i, int j);
//返回vi在vj后的下一个邻接顶点的序号
//
public abstract AbstractGraph prim();
public void DFSTraverse(int v)
//从顶点v出发对非连通图的一次深度优先搜索遍历
{
boolean[] visited = new boolean[vertexCount()];
//访问标记数组，元素初值为false，表示未被访问
int i=v;
do
{
if(!visited[i])
点vi未被访问
{
System.out.print(“{ ”);
depthfs(i, visited);
点vi出发的一次深度优先搜索遍历
System.out.print(“} ”);
}
i =(i+1)% vertexCount();
他连通分量中寻找未被访问顶点
} while(i!=v);
System.out.println();
}
private void depthfs(int v, boolean[] visited)
//若顶
//从顶
//在其//从顶点v开
始发的一次深度优先搜索遍历
{
//遍历一个连通分量
System.out.print(this.get(v)+“ ”);
//访问该顶点
visited[v] = true;
已访问标记
int w = getFirstNeighbor(v);
第一个邻接顶点
while(w!=-1)
若存在邻接顶点
{
if(!visited[w])
邻接顶点w未被访问
depthfs(w, visited);
w出发的深度优先搜索遍历，递归调用
w = getNextNeighbor(v, w);
回v在w后的下一个邻接顶点的序号
}
}
//置
//获得
//
//若
//从
//返
public void BFSTraverse(int v)
//从顶点v出发对非连通图进行一次广度优先搜索遍历
{
boolean[] visited = new boolean[vertexCount()];
//访问标记数组
int i=v;
do
{
if(!visited[i])
点vi未被访问
{
System.out.print(“{ ”);
breadthfs(i, visited);
点vi出发的广度优先搜索遍历
System.out.print(“} ”);
}
i =(i+1)% vertexCount();
他连通分量中寻找未被访问顶点
} while(i!=v);
System.out.println();
}
//若顶//从顶//在其
private void breadthfs(int v, boolean[] visited)
//从顶点v出发的广度优先搜索遍历
{
//遍历一个连通分量
System.out.print(this.get(v)+“ ”);
visited[v] = true;
SeqQueue
que
= SeqQueue
//创建顺序队列
que.enqueue(new Integer(v));
问过的顶点v的序号入队
while(!que.isEmpty())
队列不空时循环
{
v = que.dequeue().intValue();
int w = getFirstNeighbor(v);
顶点v的第一个邻接顶点序号
while(w!=-1)
当邻接顶点存在时循环
{
if(!visited[w])
该顶点未访问过
new
//访
//当//出队 //获得
//
//若
{
System.out.print(this.get(w)+“ ”);
//访问顶点
visited[w] = true;
que.enqueue(new Integer(w));
//访问过的顶点w的序号入队
}
w = getNextNeighbor(v, w);
回v在w后的下一个邻接顶点的序号
}
}
}
}
//返 package curriculumProject;
//图的邻接表
import dataStructure.linearList.SeqList;
//顺序表类 import linearList.linkedList.SortedHSLinkedList;
//排序的带头结点的单链表类
//public class AdjListGraph
//邻接表表示的图类
public class AdjListGraph
{
protected SeqList
//顶点表
public AdjListGraph(int n)
//构造方法，n指定顶点数
{
this.vertexlist = new SeqList
}
public AdjListGraph(E[] vertices, Edge[] edges)
//以顶点集合和边集合构造一个图
{
this(vertices.length);
for(int i=0;i insertVertex(vertices[i]); //插入一个顶点 for(int j=0;j insertEdge(edges[j]); 边 } public int vertexCount() 数 { return this.vertexlist.length(); } public E get(int i) vi的数据元素 { return this.vertexlist.get(i).data; } //插入一条 //返回顶点 //返回顶点 public boolean insertVertex(E vertex) //插入一个顶点，若插入成功，返回true { return this.vertexlist.add(new Vertex } public boolean insertEdge(int i, int j) //插入一条权值为weight的边〈vi,vj〉 { if(i>=0 && i { //SortedHSLinkedList SortedHSLinkedList slink = this.vertexlist.get(i).adjlink;// slink = this.vertexlist.get(i).adjlink;// System.out.println(this.vertexlist.get(i)); return slink.add(new Edge(i,j));//在第i条单链表最后增加边结点 } slink = new return false; } public boolean insertEdge(Edge edge) //插入一条边 { if(edge!=null) return insertEdge(edge.start, edge.dest); return false; } public String toString() //获得图的顶点集合和邻接表 { String str= “顶点集合：”+vertexlist.toString()+“n”; str += “出边表：n ”; //+edgeCount+“条边 n”; for(int i=0;i str += this.vertexlist.get(i).adjlink.toString()+“n”; //遍历第i条单链表 return str; } public boolean removeEdge(int i, int j) //删除边〈vi,vj〉，i、j指定顶点序号 { if(i>=0 && i { SortedHSLinkedList slink = this.vertexlist.get(i).adjlink;//获得第i条边单链表 return slink.remove(new Edge(i,j)); } return false; } public boolean removeVertex(int v) //删除序号为v的顶点及其关联的边 { //若删除成功，返回true int n=vertexCount(); //删除之前的顶点数 if(v>=0 && v { SortedHSLinkedList slink = this.vertexlist.get(v).adjlink;//获得欲删除的第v条边单链表 int i=0; Edge edge = slink.get(i); while(edge!=null) { this.removeEdge(edge.dest, edge.start); //删除对称的边 i++; edge = slink.get(i); } this.vertexlist.remove(v); //删除顺序表的第i个元素，顶点数已减一 for(i=0;i //未删除的边结点更改某些顶点序号 { slink = this.vertexlist.get(i).adjlink; //获得第i条边单链表 int j=0; edge = slink.get(j); while(edge!=null) { if(edge.start>v) edge.start--; //顶点序号减一 if(edge.dest>v) edge.dest--; j++; edge = slink.get(j); } } return true; } return false; } public int getFirstNeighbor(int v) 第一个邻接顶点的序号 { 存在第一个邻接顶点，则返回-1 return getNextNeighbor(v,-1); } //返回顶点v的 //若不 public int getNextNeighbor(int v, int w) //返回v在w后的下一个邻接顶点的序号 { //若不存在下一个邻接顶点，则返回-1 if(v>=0 && v { SortedHSLinkedList slink = this.vertexlist.get(v).adjlink;//获得第v条边单链表 Edge edge = slink.get(0); //返回单链表的第一个结点表示的边 int i=0; while(edge!=null) //寻找下一个邻接顶点 { if(edge.dest>w) return edge.dest; //返回下一个邻接顶点的序号 i++; edge = slink.get(i); //返回单链表的第一个结点表示的边 } } return-1; } } package curriculumProject; //带权图的边类 public class Edge implements Comparable //带权值的边类 public int start; //边的起点序号 public int dest; //边的终点序号 //public int weight; //边的权值 public Edge(int start, int dest) { this.start = start; this.dest = dest; //this.weight = weight; } public String toString() { return “(”+start+“,”+dest+“)”; } public int compareTo(Edge e) 较大小的规则 { if(this.start!=e.start) return this.starte.dest; } } package curriculumProject;//图接口 public interface GGraph //图接口 { int vertexCount(); //返回顶点数 E get(int i); //返回顶点vi的数据元素 boolean insertVertex(E vertex);顶点 boolean insertEdge(int i, int j); 〈vi,vj〉 boolean removeVertex(int v); 为v的顶点及其关联的边 boolean removeEdge(int i, int j); int getFirstNeighbor(int v); 的第一个邻接顶点的序号 int getNextNeighbor(int v, int w);后的下一个邻接顶点的序号 } //插入一个//插入一条权值为weight的边 //删除序号 //删除边〈vi,vj〉 //返回顶点v //返回v在w package curriculumProject; import java.util.*; import linearList.Queue.SeqQueue;; public class Graph_Main2 { /** * @param args */ int bian;// 定义边数 HashSet array = new HashSet();// 定义一个集合保存顶点的值 ArrayList list2 = new ArrayList();// 保存优先关系顶点的值 ArrayList listrudu = new ArrayList();// 保存顶点的入度 ArrayList result = new ArrayList();// 保存拓扑排序的结果 ArrayList credit2 = new ArrayList();// 保存学分信息 ArrayList credit3 = new ArrayList();// 保存学分信息 int[][] relation;// 保存输入优先关系的所有值 int[][] c_relation;Scanner scanner = new Scanner(System.in); public void input(){ System.out.println(“请输入课程总数,按回车确认”);Scanner reader=new Scanner(System.in);int Input=reader.nextInt();System.out.println(“请依次输入各个课程的学分:”);int[] credit = new int[Input];for(int i = 0;i < Input;i++){ } String[] vertices = new String[Input];for(int n = 0;n < Input;n++){ } Scanner reader2=new Scanner(System.in);System.out.println(“请输入课程之间的关系总和，即有多少条if(n < 9){ vertices[n] = ”C0“ +(n + 1);credit[i] = reader.nextInt();credit2.add(credit[i]);} else { } vertices[n] = ”C“ +(n + 1);边？,按回车确认”); bian = reader2.nextInt();relation = new int[bian][2];List } Edge[] edges = list.toArray(new Edge[0]); AdjListGraph graph = new System.out.print(“请输入第” +(i + 1)+ “条边的优先关系”);for(int j = 0;j < 2;j++){ } list.add(new Edge(relation[i][0],relation[i][1]));relation[i][j] = reader.nextInt();AdjListGraph System.out.println(“带权有向图，”+graph.toString());System.out.println(“深度优先搜索遍历”);for(int i=0;i System.out.println(“广度优先搜索遍历”); for(int i=0;i graph.BFSTraverse(i); } } public void sort(){ for(int i = 0;i < bian;i++){ for(int j = 0;j < 2;j++){ array.add(relation[i][j]); } } Iterator iter = array.iterator(); while(iter.hasNext()){ Object s = iter.next();list2.add(s);// 将各顶点的值保存在list里，方便后面查找入度时使用 } int count = 0;// 定义一个记入度的计数器 for(int i = 0;i < list2.size();i++){ } for(int j = 0;j < bian;j++){ } listrudu.add(list2.get(i));listrudu.add(count);count = 0;if(list2.get(i).equals(relation[j][1])){ } count++;System.out.println();boolean flag = true;while(flag){ int check = 0;// 检查有没有入度为0 for(int i = 0;i < listrudu.size();i = i + 2){ if(listrudu.get((i + 1)).equals(0)){ result.add(listrudu.get(i)); for(int j=0;j credit3.add(credit2.get(j));// // // //credit3.add(credit2.get(i));for(int j = 0;j < list2.size();j++){ if(listrudu.get(i).equals(list2.get(j))){ for(int j2 = 0;j2 < bian;j2++){ if(list2.get(j).equals(relation[j2][0])){ relation[j2][1] =-9999;// 如果这个前驱是要被删除的话，那么把他的后继改值 “); } flag = false; } if(check == listrudu.size()/2){ System.out.println(”课程关系输入错误，有环,无法排序 } } } list2.remove(j);} } else { } check++; int count1 = 0;// 定义一个记入度的计数器 for(int i = 0;i < list2.size();i++){ } if(list2.size()== 0){ } System.out.println(“存在拓扑排序”);flag = false;for(int j = 0;j < bian;j++){ } listrudu.add(list2.get(i));listrudu.add(count1);count1 = 0;if(list2.get(i).equals(relation[j][1])){ } count1++;}// while循环结束 } public void print(){ /* * 这个for循环的作用是：因为我上面做的是根据listrudu来找的，* 所以它每进行一次循环就把前面的入度为0的值再保存了一遍，其实最后的结果是最后一次循环所得的值，打印的时候要把前面重复的去掉 */ for(int i = result.size()-1;i >= 0;i--){ } for(int i = 0;i < result.size();i++){ for(int j = 0;j < i;j++){ } if(result.get(j).equals(result.get(i))){ } result.remove(j); System.out.print(result.get(i)+ “-->”); } System.out.println();System.out.println();System.out.println(“请输入你的总学期数”);Scanner reader3=new Scanner(System.in); 为：“); int term = reader3.nextInt();System.out.println(”请输入学期学分上线“);int sum_credit = reader3.nextInt();System.out.println(”如果要使课程均匀分布在各个学期，则int sum=0;int sum2=0;for(int i = 0;i < result.size();i++){ for(int j=0;j Object res2 = result.get(j); Integer r2 = Integer.parseInt(res2.toString()); Object obj = credit2.get(r2-1);Integer a = Integer.parseInt(obj.toString());sum += a;j=j+2;break;} double value =(double)credit2.size()/(double)term;int value2=0;if(value<=1.0) value=1.0; if((int)value==value)value2=(int)value;else value2 =(int)value+1;if((i+1)%(value2)==0){ System.out.print(result.get(i)+ “-->”);System.out.println();}else{ if(sum<=sum_credit){ for(int j3=0;j3 Integer r = Integer.parseInt(res.toString());Object obj2 = credit2.get(r-1); Integer a2 = Integer.parseInt(obj2.toString());sum += a2;break;} if(sum<=sum_credit) System.out.print(result.get(i)+ “-->”);//System.out.print(result.get(i)+ “-->”);else{ sum = 0; “); } } } System.out.print(result.get(i)+ ”-->“);}else{ } System.out.println();sum = 0; System.out.print(result.get(i)+ ”-->“);System.out.println();System.out.println();System.out.println(”如果要使课程分布在前几个学期，则为： int j_=0;int j=0; for(int i = 0;i < result.size();i++){ //for(int j=0;j Object res4 = result.get(j);Integer r4 = Integer.parseInt(res4.toString()); // // Object obj4 = credit2.get(r4-1);Integer a4 = Integer.parseInt(obj4.toString());sum += a4;j=j+1;//break;//} if(sum<=sum_credit){ //for(int j=0;j System.out.print(result.get(i)+ “-->”);if(sum<=sum_credit&&) System.out.print(result.get(i)+ “-->”);else{ sum = 0; System.out.print(result.get(i)+ “-->”); } } }else{ } if(sum<=sum_credit){ System.out.print(result.get(i)+ “-->”);System.out.print(result.get(i)+ “-->”);System.out.println();sum = 0;// // // // // // // } }else{ } System.out.println();sum = 0; System.out.print(result.get(i)+ “-->”);public static void main(String[] args){ // TODO Auto-generated method stub Graph_Main2 s = new Graph_Main2();s.input(); s.sort();s.print(); } } package curriculumProject; import linearList.linkedList.SortedHSLinkedList;单链表类 public class Vertex //排序的带头结点的//顶点表 元素 { public E data; //顶点数据域 public SortedHSLinkedList //该顶点的边单链表 public Vertex(E data, SortedHSLinkedList { this.data = data; this.adjlink = adjlink; } public Vertex(E data) { this(data, new SortedHSLinkedList //构造结点时创建空单链表 } public String toString() { return this.data.toString(); } } JAVA代码注释规范 一、规范存在的意义 1.好的注释规范可以让人一眼看明白这是干什么的，特别是对于我们这种行业；共同合作完成一个项目需要分工明确，所以也需要有明了的注释规范。 2.正确的应用注释规范可以增加代码的可读性、理解性。3.好的代码规范可以提高团队的开发效率，从而节省时间。4.长期的坚持代码规范可以让程序员养成一个良好的习惯，甚至锻炼出思维。 二、命名规范 1.一般概念 1)尽量使用完整的英文描述。2)采用相对好理解的术语。 3)采用骆驼命名的规范使名字增加可读性。4)尽量少用缩写提高可读性。5)避免名字过长。 6)避免使用类似的名字。7)避免使用特殊符号。2.主要的运用 1)类（class）的命名 2)接口(interface)的命名 +方法(method)的命名 3)参数(param)的命名 三、注释规范 1.一般概念 1)注释应该增加代码的清晰度 2)保持代码的整洁 3)在写代码之前或同时注意写上注释 4)注释出为什么做这件事，做这件事的结果 2.注释那些部分 1)java文件：版权信息、创建时间、创建人 2)类：目的、所完成功能、版权信息、创建人 3)方法：参数含义、返回值 4)属性：字段描述 5)接口：目的、创建人、版本号、创建时间 四、代码格式规范 1.单行注释://注释内容，一般与代码后空4-8格，注释必须对齐 2.块状注释：/*注释内容*/，一般是注释从以/*开始，以*/结束中的所有内容。3.文档注释：/**......*/所以注释文 档必须书写在类、域、构造函数、方法，以及字段(field)定义之前.注释文档由两部分组成——描述、块标记。4.javadoc注释标签 @author 对类的说明 标明开发该类模块的作者 @version 对类的说明 标明该类模块的版本 @see 对类、属性、方法的说明 参考转向，也就是相关主题 @param 对方法的说明 对方法中某参数的说明 @return 对方法的说明 对方法返回值的说明 @exception 对方法的说明 对方法可能抛出的异常进行说明 五、java注释具体实现 1.源文件注释 /** *文件名 *创建人 *创建时间 *修改人 *描述 *版本号 */ 2.类注释 /** *对此类的描述信息 *创建人 *版本号 *创建时间 */ 3.方法的注释 /** *方法的用处 *该方法的参数列 *该方法返回的值 */ 4.属性的注释 /** *字段的描述 */ 5.接口注释 /** *对此接口的描述 *创建人 *创建时间 *版本号 */ 6.构造方法注释 /** *描述该构造方法的用处 *该构造方法的参数列 *参数的类型 */ 六、Jsp代码格式规范 1.多行注释:,一般是注释从以结束中的所有内容。 2.文本注释:<%--内容--%>,主要是对该页面的一些描述，目的、创建人、创建时间、版本号、文件名、备注、修改人等.例如: <%---创建人-创建时间-版本号-文件名-备注-修改人--%> 3.伪劣标签注释:<% java语句块 %> 例如： <% JAVA代码块 %> 4.单行注释：//注释内容，一般与代码后空4-8格，注释必须对齐 七、JS代码格式规范 1.文本注释:/** 注释内容 **/，主要是对该页面的一些描述，目的、创建人、创建时间、版本号、文件名、备注、修改人等.也可以用于注释代码块。例如: /** *创建人 *创建时间 *版本号 *文件名 *备注 *修改人 **/ 2.文本注释:/** 内容 */ ,主要是对该页面的一些描述，目的、创建人、创建时间、版本号、文件名、备注、修改人等.也可以用于注释代码块。例如: /** *创建人 *创建时间 *版本号 *文件名 *备注 *修改人 */ 3.单行注释: //注释内容，一般与代码后空4-8格，注释必须对齐 4.多行注释: /* 注释内容 */,一般是注释从以/* 开始，以*/结束中的所有内容。 八、JS注释具体实现 1.文件注释 /** *对此文件的描述信息 *创建人 *版本号 *创建时间 */ 2.方法的注释 /** *方法的用处 *该方法的参数列 *该方法返回的值 */ 3.模块的注释 /** *模块名称 *模块的用处 */ 实验7 流（2学时） 一、实验目的1.熟悉流类库中各种常用流的使用方法。 2.能够使用流类实现基本的文件读写。 二、实验内容 1.编写程序，在控制台窗口提示输入两个整数，然后接收这两个整数，并输出它们的和。（要求：键盘输入通过流封装System.in获取，不要使用Scanner类） import java.io.*;System.out.println(x);System.out.println(“y”);public class Num1 {n=in.readLine();public static void main(String []args)y=Integer.parseInt(n);{System.out.println(y);int x=0,y=0;}catch(IOException e)BufferedReader in=new BufferedReader({ newSystem.out.println(“error”);InputStreamReader(System.in));} String n;int s=x+y; try{System.out.println(s);System.out.println(“x”);} n=in.readLine();} x=Integer.parseInt(n); 2.设计学生类Student，属性：编号（整型）；姓名（字符串），成绩（整型）。编写一个程序：要求：（1）输入3个学生的姓名和成绩，将其姓名和成绩保存到data.txt中；（2）然后从该文件中读取数据，求得这三个学生的平均成绩。 import java.io.*;DataOutputStream dout = newDataOutputStream（public class num2 {newpublic static void main(String[]args)FileOutputStream(“D:data.txt”));{String n; BufferedReader in=new BufferedReader(for(int i=0;i<5;i++)new{ InputStreamReader(System.in));n=in.readLine(); int num=Integer.parseInt(n);try{String name=in.readLine(); n=in.readLine();int grade=Integer.parseInt(n);dout.writeBytes(num+“rn”);dout.writeBytes(name+“rn”);dout.writeBytes(grade+“rn”);}dout.close();}catch(IOException e1){int num=Integer.parseInt(n); n=din.readLine();String name=n;n=din.readLine();int grade=Integer.parseInt(n);ave+=grade;}System.out.println(“平均成绩”+ave*1.0/5);System.out.println(“文件写入失败”);}try{DataInputStream din =new DataInputStream(new FileInputStream(“D:data.txt”));int ave=0;String n;for(int i=0;i<5;i++){n=din.readLine(); 三、实验要求 完成程序设计并提交实验报告。 在“);失败”);} } }catch(FileNotFoundException e){System.out.println(“文件不存}catch(IOException e2){System.out.println(”文件读取} 目 录 课题需求描述..........................................2 1.1 教学计划编制问题..................................2 1.2 进制转换..........................................2 2 总体功能与数据结构设计.................................3 2.1 总体功能结构......................................3 2.2 数据结构设计......................................4 3 算法设计和程序设计....................................6 3.1 教学计划编制问题..................................6 3.2 进制转换问题......................................9 4 调试与测试...........................................23 4.1 教学计划编制问题调试结果.........................23 4.2 进制转换问题调试结果.............................25 5 设计总结.............................................27 6 程序代码.............................................29 课题需求描述 1.1 教学计划编制问题 大学的每个专业都要制订教学计划。假设任何专业都有固定的学习年限，每学年含两学期，每学期的时间长度和学分上限均相等。每个专业开设的课程都是确定的，而且课程在开设时间的安排必须满足先修关系。每门课程有哪些先修课程是确定的，可以有任意多门，也可以没有。每门课恰好占一个学期。在这样的前提下设计一个教学计划编制程序。通过输入实际的课程及先后关系。结合每学期的学分及课程数，制定好学习计划。在输入相关数据后，程序会安排好每学期的课程。 1.2 进制转换 进制数制是人们利用符号进行计数的科学方法。数制有很多种，在计算机中常用的数制有：十进制，二进制，八进制和十六进制。十六进制数有两个基本特点：它由十六个字符0~9以及A,B,C,D,E,F组成（它们分别表示十进制0~15），十六进制数运算规律逢十六进一。 要求：（1）输入一个十进制数N,将它转换成R进制数输出，并可以进行你转换。 （2）输入数据包含多个测试实例，每个测试实例包含两个整数N(32位整数)和R（2<=R<=16）。 （3）为每个测试实例输出转换后的数，每个输出占一行。如果R大于10，则对应的数字规则参考16进制（比如，10用A表示，等等）。总体功能与数据结构设计 1．教学计划编制问题 根据问题描述及要求，可知设计中需要定义先修关系的AOV网图中的顶点及弧边的结构体，在运行结果中将图的信息显示出来，利用先修关系将课程排序，最后解决问题——输出每学期的课程。 2.进制转换问题 由于计算机只能识别二进制，所以当我们从键盘输入其他进制数的时候，计算机内部的系统会利用自带的程序代码自动转换成二进制，我们是学计算机的，所以我们需要弄懂这种机制转换的原理并且能计算出来。 2.1 总体功能结构 2.1.1 教学计划编制问题 教学计划是学校保证教学质量和人才培养的关键，也是组织教学过程、安排教学过程、安排教学任务、确定教学编制的基本依据和课程安排的具体形式。是稳定教学秩序、提高教学质量的重要保证。从教学计划的设计、实施等方面，阐明了如何搞好教学管理，从而为提高教学质量提供保证。随着教育改革的不断深入和社会发展的需要，原旧的教学计划在定位上的方向性偏差，已经不再适应社会的需求。因此，应重视教学计划的改革和修订工作，以确保教育教学质量，提高教育教学水平。教学计划编制中的思路:一是明确培养目标;二是注重学科设置的整体性、统一性和灵活性、全面性;三是与学分制改革有机结合.教学计划是高校实施常规教学活动的基本管理文档,由于传统的手工编制方式存在诸多弊端,开发基于Web应用程序形式的教学计划编制系统具有很好的应用价值。使用C程序设计语言,研究开发教学计划编制系统Web应用系统。 2.1.2 进制转换问题 1.十进制数与非十进制数之间的转换 (1)十进制数转换成非十进制数 把一个十进制数转换成非十进制数（基数记作R）分成两步.整数部分转换时采用“除R取余法”；小数部分转换时采用“乘R取整法”。 (2)非十进制数转换成十进制数 非十进制数(基数记作R，第j个数位的位权记作Rj)转换成十进制数的方法：按权展开求其和。 2.非十进制数之间的转换 (1)二进制数与八进制数之间的转换 ①二进制数转换成八进制数的方法.以小数点分界，整数部分自右向左、小数部分自左向右，每三位一组，不足三位时，整数部分在高位左边补0，小数部分在低位右边补0，然后写出对应的八进制数码。②八进制数转换成二进制数的方法：用八进制数码对应的三位二进制数代替八进制数码本身即可。 (2)二进制数与十六进制数之间的转换 ①二进制数转换成十六进制数的方法：以小数点分界，整数部分自右向左、小数部分自左向右，每四位一组，不足四位时，整数部分在高位左边补0，小数部分在低位右边补0，然后写出对应的十六进制数码。②十六进制数转换成二进制数的方法：用十六进制数码对应的四位二进制数代替十六进制数码本身即可。 2.2 数据结构设计 2.2.1 教学计划编制问题 LocateVex（）：图的邻接表存储的基本操作 CreateGraph（）：构造生成树 Display（）：输出图的邻接矩阵 FindInDegree（）：求顶点的入度 InitStack（）：构造一个空栈 ClearStack（）：清空栈 StackEmpty（）：判断是否为空栈 Pop（）：出栈 Push（）：入栈 TopologicalSort（）：输出G顶点的拓扑排序结果 2.2.2 进制转换问题 void D_B()： 十进制转换为二进制 void D_O()： 十进制转换为八进制 void D_X()： 十进制转换为十六进制 void B_D()： 二进制转换为十进制 void B_O()： 二进制转换为八进制 void B_X()： 二进制转换为十六进制 void O_B()： 八进制转换为二进制 void O_D()： 八进制转换为十进制 void O_X()： 八进制转换为十六进制 void X_B()： 十六进制转换为二进制 void X_D()： 十六进制转换为十进制 void X_O()： 十六进制转换为八进制 算法设计和程序设计 3.1 教学计划编制问题 3.1.1采用C语言定义相关的数据类型。 其中包括字符常量，整型，字符型，字符串型，typedef 定义的类型，结构体型，单链表节点类型，结构体数组。 3.1.2主要函数的流程图 1.LocateVex（）：图的邻接表存储的基本操作。由初始条件G存在,u和G中顶点有相同特征转而进行判断，若G中存在顶点u,则返回该顶点在图中位置;否则返回-1。 2.CreateGraph（）：构造生成图。采用邻接表存储结构,构造没有相关信息的图G(用一个函数构造种图)。 3.Display（）：输出图的邻接矩阵。采用循环设置输出图的邻接矩阵。4.FindInDegree（）：求顶点的入度。 5.InitStack（）：构造一个空栈。6.ClearStack（）：清空栈。 7.StackEmpty（）：判断栈是否为空。若栈S为空栈，则返回TRUE，否则返回FALSE。 8.Pop（）：出栈。若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR。 9.Push（）：入栈。插入元素e为新的栈顶元素。 10.TopologicalSort（）：输出G顶点的拓扑排序结果。有向图G采用邻接表存储结构。若G无回路,则输出G的顶点的一个拓扑序列并返回OK, 否则返回ERROR。 3.2 进制转换问题 主要流程图： 进制转换菜单： 1.void D_B()： 十进制转换为二进制 for(j=0;a!=0;j++){ p[j]=a%2;a=a/2;} printf(“n转换后的数为：”);for(k=j-1;k>=0;k--){printf(“%d”,p[k]);} printf(“n”); 2.void D_O()： 十进制转换为八进制 for(j=0;a!=0;j++){ p[j]=a%8;a=a/8;} printf(“n转换后的数为：”);for(k=j-1;k>=0;k--){printf(“%d”,p[k]);} printf(“n”); 3.void D_X()： 十进制转换为十六进制 for(j=0;a!=0;j++){p[j]=a%16;a=a/16;if(p[j]<10)p[j]+=48;else { switch(p[j]){ case 10: p[j]='A';break;case 11: p[j]='B';break;case 12: p[j]='C';break;case 13: p[j]='D';break;case 14: p[j]='E';break;case 15: p[j]='F';break;} } 十进制转换为任意进制： 4.void B_D()： 二进制转换为十进制 for(i=1;a!=0;i*=2){ if(a%10>1) {s=1;break;} else {result+=(a%10)*i;a=a/10;} } if(s==1) printf(“您的输入有误！请重新输入n”);else printf(“n转换后的数为：%dn”,result);5.void O_D()： 八进制转换为十进制 for(i=1;a!=0;i*=8){ if(a%10>7){ s=1;break;} else {result+=(a%10)*i;a=a/10;} } if(s==1)printf(“您的输入有误！请重新输入n”);else { printf(“n转换后的数为：%dn”,result);} 任意进制转换为十进制： 6.void B_O()： 二进制转换为八进制 for(i=1;a!=0;i*=2){if(a%10>1){s=1;break;} else{result+=(a%10)*i;a=a/10;} } for(j=0;result!=0;j++){p[j]=result%8;result=result/8;} if(s==1) printf(“您的输入有误！请重新输入n”);else {printf(“n转换后的数为：”); for(k=j-1;k>=0;k--) {printf(“%d”,p[k]);} printf(“n”);} 7.void B_X()： 二进制转换为十六进制 for(i=1;a!=0;i*=2){if(a%10>1){s=1;break;} else{result+=(a%10)*i;a=a/10;} } for(j=0;result!=0;j++){p[j]=result%16;result=result/16;if(p[j]>10){switch(p[j]){ case 10: p[j]='A';break;case 11: p[j]='B';break;case 12: p[j]='C';break; case 13: p[j]='D';break;case 14: p[j]='E';break;case 15: p[j]='F';break;} } else p[j]+=48;} if(s==1)printf(“您的输入有误！请重新输入n”);else { printf(“n转换后的数为：”);for(k=j-1;k>=0;k--){printf(“%c”,p[k]);} printf(“n”);} 8.void O_B()： 八进制转换为二进制 for(i=1;a!=0;i*=8){if(a%10>7){ s=1;break;} else {result+=(a%10)*i;a=a/10;} } for(j=0;result!=0;j++){p[j]=result%2;result=result/2;} if(s==1)printf(“您的输入有误！请重新输入n”); else {printf(“n转换后的数为：”);for(k=j-1;k>=0;k--){printf(“%d”,p[k]);} printf(“n”);} 9.void O_D()： 八进制转换为十进制 for(i=1;a!=0;i*=8){ if(a%10>7){ s=1;break;} else {result+=(a%10)*i;a=a/10;} } if(s==1)printf(“您的输入有误！请重新输入n”);else { printf(“n转换后的数为：%dn”,result);} 10.void X_D()： 十六进制转换为十进制 for(i=0;i case 'A': b[i]=10;break;case 'B': b[i]=11;break;case 'C': b[i]=12;break;case 'D': b[i]=13;break;case 'E': b[i]=14;break;case 'F': b[i]=15;break;case 'a': b[i]=10;break;case 'b': b[i]=11;break;case 'c': b[i]=12;break;case 'd': b[i]=13;break;case 'e': b[i]=14;break;case 'f': b[i]=15;break;default: s=1;} } 11.void O_X()： 八进制转换为十六进制 for(i=1;a!=0;i*=8){if(a%10>7){s=1;break;} else{result+=(a%10)*i;a=a/10;} } for(j=0;result!=0;j++){p[j]=result%16;result=result/16;if(p[j]<10)p[j]+=48;else { switch(p[j]){ case 10: p[j]='A';break;case 11: p[j]='B';break;case 12: p[j]='C';break;case 13: p[j]='D';break;case 14: p[j]='E';break;case 15: p[j]='F';break;} } 12.void X_B()： 十六进制转换为二进制 for(i=0;i default: s=1;} } 13.void X_D()： 十六进制转换为十进制 for(i=0;i 14.void X_O()： 十六进制转换为八进制 for(i=0;i 其他进制间的转换： 调试与测试 4.1 教学计划编制问题调试结果 输入学期总数，输入学期学分的上限，输入教学计划的课程数，输入先修关系的边数，输入课程的代表值，输入课程的学分值（如图） 输入每条弧的弧尾和弧头（如图）： 显示的课程计划如下： 4.2 进制转换问题调试结果 进入系统时的界面： 二进制转换为八进制： 十进制转换为十六进制： 十六进制转换为十进制： 设计总结 我的收获 虽然在高中我们已经学了C语言，大一我们已经学习了C++语言，但是，直到本期我们才开设了数据结构这一门课程。这门课程让我们对程序的原理有了系统的认识。对以往模糊的经验，起了总结提升的作用。在学习了这门课程后，我们进行了一个星期的课程设计，以实践我们的学习内容。 在这次课程设计中，我被分配到了教学计划课程编制问题，开始感觉很难，因为我从未编写过如此复杂的程序。在多方查找资料并参考类似程序后，我大体将程序的构架描绘好了。一边对照着网上的资料，一边对程序进行修改补充，然后根据拟好的大纲进行编制。期间，我与其它同学进行了讨论和探究，对程序的细节问题和应用方面进行了探索，并解决了主要的问题，于是便着手写具体的程序。 由于老师要求我们编写600多行的代码，但是教学计划课程编制问题的代码不足，所以我又选择了一个课题——进制转换问题，我会选择这个课题是因为我觉得作为学计算机的我，应该要能更好的了解关于计算机方面的知识。 这次实验，我进行了大量的资料查阅，对所学知识进行复习。通过这些努力，我对算法有了更深入的理解，对编程的步骤，有了具体的体会。通过和同学的广泛交流，我体会到了合作的必要性及合作的优势。更重要的是，这个课题完全脱胎于实际问题，让我对计算机行业，充满了信心和自豪。 以往我们学的计算机知识一般停留在理论上，这让我们不太理解计算机的应用和前景，而较少注重我们对算法的实践锻炼。而这一次的实习既需要我们去联系理论，又需要我们去实践方法，很多东西看上去都学过，但是和实际联系才知道变通的艰难。纸上得来终觉浅，这是我这次实习的最大收获。这次的实验让我们知道该如何跨过实际和理论之间的鸿沟。 存在的问题 由于程序十分的复杂，遇到了很多常见的语法错误，及逻辑错误。这需要我们不断的调试分析。符号的格式之类，指针的用法，判断输入输出的条件都是十分容易出错的地方。在逐条排除，程序终于得以完成。这让我明白了，解决问题，要细心认真，集思广益，这样才能把问题解决。 虽然程序变出来了，但是我大量借鉴了别人的程序，中间有很多的程序段都是一知半解，虽然查阅了资料，但是毕竟不是自己思考出来的程序，又无法当面询问写出编程的人，所以对部分程序还存在问题，我会继续查询资料将目前不懂的内容弄清楚。 参考资料：数据结构（C++语言描述）吉根林 陈波主编 C++语言教材 程序代码 教学计划编制问题： #include // exit()#include #define MAX_VERTEX_NUM 100 typedef enum{DG}GraphKind;/* {有向图,有向网,无向图,无向网} */ typedef struct ArcNode { int adjvex;/* 该弧所指向的顶点的位置*/ struct ArcNode *nextarc;/* 指向下一条弧的指针*/ InfoType *info;/* 网的权值指针）*/ }ArcNode;/* 表结点*/ typedef struct { VertexType data;/* 顶点信息*/ ArcNode *firstarc;/* 第一个表结点的地址,指向第一条依附该顶点的弧的指针*/ }VNode,AdjList[MAX_VERTEX_NUM];/* 头结点*/ typedef struct { AdjList vertices,verticestwo;int vexnum,arcnum;/* 图的当前顶点数和弧数*/ int kind;/* 图的种类标志*/ }ALGraph;/* 图的邻接表存储的基本操作*/ int LocateVex(ALGraph G,VertexType u){ /* 初始条件: 图G存在,u和G中顶点有相同特征*/ /* 操作结果: 若G中存在顶点u,则返回该顶点在图中位置;否则返回-1 */ int i;for(i=0;i { /* 采用邻接表存储结构,构造没有相关信息的图G(用一个函数构造种图)*/ int i,j,k;VertexType va,vb;ArcNode *p;printf(“请输入教学计划的课程数: ”);scanf(“%d”,&(*G).vexnum);printf(“请输入拓扑排序所形成的课程先修关系的边数: ”);scanf(“%d”,&(*G).arcnum);printf(“请输入%d个课程的代表值(<%d个字符):n”,(*G).vexnum,MAX_NAME);for(i=0;i<(*G).vexnum;++i)/* 构造顶点向量*/ { } printf(“请输入%d个课程的学分值(<%d个字符):n”,(*G).vexnum,MAX_NAME);for(i=0;i<(*G).vexnum;++i)/* 构造顶点向量*/ { } printf(“请顺序输入每条弧(边)的弧尾和弧头(以空格作为间隔):n”);for(k=0;k<(*G).arcnum;++k)/* 构造表结点链表*/ { } scanf(“%s”,(*G).vertices[i].data);(*G).vertices[i].firstarc=NULL;scanf(“%s”,(*G).verticestwo[i].data);scanf(“%s%s”,va,vb);i=LocateVex(*G,va);/* 弧尾*/ j=LocateVex(*G,vb);/* 弧头*/ p=(ArcNode*)malloc(sizeof(ArcNode));p->adjvex=j;p->info=NULL;/* 图*/ p->nextarc=(*G).vertices[i].firstarc;/* 插在表头*/(*G).vertices[i].firstarc=p; return OK;} void Display(ALGraph G){ /* 输出图的邻接矩阵G */ int i;ArcNode *p;switch(G.kind){ case DG: printf(“有向图n”);} printf(“%d个顶点：n”,G.vexnum);for(i=0;i } printf(“n”);} } void FindInDegree(ALGraph G,int indegree[]){ /* 求顶点的入度，算法调用*/ int i;ArcNode *p;for(i=0;i printf(“%s→%s ”,G.vertices[i].data,G.vertices[p->adjvex].data);p=p->nextarc; indegree[i]=0;/* 赋初值*/ for(i=0;i } } } typedef int SElemType;/* 栈类型*/ /*栈的顺序存储表示*/ #define STACK_INIT_SIZE 10 /* 存储空间初始分配量*/ #define STACKINCREMENT 2 /* 存储空间分配增量*/ typedef struct SqStack { SElemType *base;/* 在栈构造之前和销毁之后，base的值为NULL */ SElemType *top;/* 栈顶指针*/ int stacksize;/* 当前已分配的存储空间，以元素为单位*/ }SqStack;/* 顺序栈*/ /* 顺序栈的基本操作*/ Status InitStack(SqStack *S){ /* 构造一个空栈S */(*S).base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!(*S).base)exit(OVERFLOW);/* 存储分配失败*/(*S).top=(*S).base;(*S).stacksize=STACK_INIT_SIZE; indegree[p->adjvex]++;p=p->nextarc; return OK;} void ClearStack(SqStack *S)//清空栈的操作 { S->top=S->base;} Status StackEmpty(SqStack S){ /* 若栈S为空栈，则返回TRUE，否则返回FALSE */ } Status Pop(SqStack *S,SElemType *e){ /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */ if((*S).top==(*S).base)return ERROR;if(S.top==S.base)else return FALSE;return TRUE;*e=*--(*S).top;return OK;} Status Push(SqStack *S,SElemType e){ /* 插入元素e为新的栈顶元素*/ if((*S).top-(*S).base>=(*S).stacksize)/* 栈满，追加存储空间*/ {(*S).base=(SElemType*)realloc((*S).base,((*S).stacksize+STACKINCREMENT)*sizeof(SElemType));if(!(*S).base)exit(OVERFLOW);/* 存储分配失败*/(*S).top=(*S).base+(*S).stacksize;(*S).stacksize+=STACKINCREMENT; } *((*S).top)++=e;return OK;} typedef int pathone[MAXCLASS];typedef int pathtwo[MAXCLASS];Status TopologicalSort(ALGraph G){ /* 有向图G采用邻接表存储结构。若G无回路,则输出G的顶点的一个拓扑序列并返回OK, */ /* 否则返回ERROR。*/ int i,k,j=0,count,indegree[MAX_VERTEX_NUM];bool has=false;SqStack S;pathone a;pathtwo b;ArcNode *p;FindInDegree(G,indegree);/* 对各顶点求入度indegree[0..vernum-1] */ InitStack(&S);/* 初始化栈*/ for(i=0;i Pop(&S,&i);a[i]=*G.vertices[i].data; b[i]=*G.verticestwo[i].data;printf(“课程%s→学分%s ”,G.vertices[i].data,G.verticestwo[i].data);/* 输出i号顶点并计数*/ ++count;for(p=G.vertices[i].firstarc;p;p=p->nextarc){ /* 对i号顶点的每个邻接点的入度减*/ k=p->adjvex;if(!(--indegree[k]))/* 若入度减为,则入栈*/ { Push(&S,k);//cout<<*G.vertices[i].data< 课 程 计 划===============================”< 如 下 while(qq<=xqzs){ int result[20];int rtop=0;int nn=0;//int ccount=0;// 学期学分计算 xxf=0;for(i=0;i } if(0==indegree[i]){ } Push(&S,i);while(!StackEmpty(S)){ int bb;Pop(&S,&i);bb=atoi(G.verticestwo[i].data);xxf=xxf+bb;if(xxf>xfsx){ } indegree[i]--;for(p=G.vertices[i].firstarc;p;p=p->nextarc){ /* 对i号顶点的每个邻接点的入度减*/ k=p->adjvex;indegree[k]--; break; /* if(!(--indegree[k]))若入度减为,则入栈 { Push(&S,k);}*/ } result[rtop]=i;rtop++;} cout<<“第”< } cout<<“课程”< ALGraph f;printf(“以下为教学计划编制问题的求解过程:n”);printf(“请输入学期总数:”);scanf(“%d”,&xqzs);printf(“请输入学期的学分上限:”);scanf(“%d”,&xfsx);CreateGraph(&f);Display(f);TopologicalSort(f); 进制转换问题： #include printf(“+===============+n”);printf(“| 欢 迎 使 用 进 制 转 换 程 序 |n”); printf(“+===============+n”); printf(“ 本 版 本 只 做 正 整 数 的 进 制 转 换！”);do { q=0;//fflush(stdin);printf(“n请选择需要被转换的进制:n1、二进制n2、八进制n3、十进制n4、十六进制n0、退出n”);printf(“请输入0~4:”);scanf(“%d”,&i);switch(i){ case 1: printf(“n请选择转换后的进制:n1、二进制n2、八进制n3、十进制n4、十六进制n0、退出n”);printf(“请输入0~4:”);scanf(“%d”,&j);switch(j){ case 1: printf(“n同进制之间不用转化！n”);q=1;break;case 2: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);B_O(k);q=1;break;case 3: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);B_D(k);q=1;break;case 4: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);B_X(k);q=1;break;case 0: printf(“谢谢使用！”);} break;case 2: printf(“n请选择转换后的进制:n1、二进制n2、八进制n3、十进制n4、十六进制n0、退出n”);printf(“请输入0~4:”);scanf(“%d”,&j);switch(j){ case 2: printf(“n同进制之间不用转化！n”);q=1;break;case 1: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);O_B(k);q=1;break;case 3: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);O_D(k);q=1;break;case 4: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);O_X(k);q=1;break;case 0: printf(“谢谢使用！”);} break;case 3: printf(“n请选择转换后的进制:n1、二进制n2、八进制n3、十进制n4、十六进制n0、退出n”);printf(“请输入0~4:”);scanf(“%d”,&j);switch(j){ case 3: printf(“n同进制之间不用转化！n”);q=1;break;case 1: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);D_B(k);q=1;break; case 2: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);D_O(k);q=1;break;case 4: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);D_X(k);q=1;break;case 0: printf(“谢谢使用！”);} break;case 4: printf(“n请选择转换后的进制:n1、二进制n2、八进制n3、十进制n4、十六进制n0、退出n”);printf(“请输入0~4:”);scanf(“%d”,&j);switch(j){ case 4: printf(“n同进制之间不用转化！n”);q=1;break;case 1: printf(“n请输入您想要转化的数:”);fflush(stdin);gets(r);for(k=0;;k++){if(r[k]==' ')break;} X_B(r,k);q=1;break;case 2: printf(“n请输入您想要转化的数:”);fflush(stdin);gets(r);for(k=0;;k++){if(r[k]==' ')break;X_O(r,k);q=1;break;case 3: printf(“n请输入您想要转化的数:”);fflush(stdin);gets(r); for(k=0;;k++){if(r[k]==' ')break;} X_D(r,k);q=1;break;case 0: printf(“谢谢使用！”);} break;case 0: printf(“n谢谢使用！n”);} }while(q==1);} void B_D(int a)///////以下为: 二进制转换为十进制,八进制,十六进制.{ int i,s=0;int result=0;for(i=1;a!=0;i*=2){ if(a%10>1){s=1;break;} else {result+=(a%10)*i;a=a/10;} } if(s==1)printf(“您的输入有误！请重新输入n”);else printf(“n转换后的数为：%dn”,result);} void B_O(int a){ int i,j,k,s=0;int p[30];int result=0;for(i=1;a!=0;i*=2){if(a%10>1){s=1;break;} else{result+=(a%10)*i;a=a/10;} } for(j=0;result!=0;j++){p[j]=result%8;result=result/8;} if(s==1)printf(“您的输入有误！请重新输入n”);else {printf(“n转换后的数为：”);for(k=j-1;k>=0;k--){printf(“%d”,p[k]);} printf(“n”);} } void B_X(int a){ int i,j,k,s=0;char p[30];int result=0;for(i=1;a!=0;i*=2){if(a%10>1){s=1;break;} else{result+=(a%10)*i;a=a/10;} } for(j=0;result!=0;j++){p[j]=result%16;result=result/16; if(p[j]>10){switch(p[j]){ case 10: p[j]='A';break;case 11: p[j]='B';break;case 12: p[j]='C';break;case 13: p[j]='D';break;case 14: p[j]='E';break;case 15: p[j]='F';break;} } else p[j]+=48;} if(s==1)printf(“您的输入有误！请重新输入n”);else { printf(“n转换后的数为：”);for(k=j-1;k>=0;k--){printf(“%c”,p[k]);} printf(“n”);} } void O_B(int a)///////以下为: 八进制转换为二进制,十进制,十六进制.{ int i,j,k,s=0;int result=0;int p[30];for(i=1;a!=0;i*=8) {if(a%10>7){ s=1;break;} else {result+=(a%10)*i;a=a/10;} } for(j=0;result!=0;j++){p[j]=result%2;result=result/2;} if(s==1)printf(“您的输入有误！请重新输入n”);else {printf(“n转换后的数为：”);for(k=j-1;k>=0;k--){printf(“%d”,p[k]);} printf(“n”);} } void O_D(int a){ int i,s=0;int result=0;for(i=1;a!=0;i*=8){ if(a%10>7){ s=1;break;} else {result+=(a%10)*i;a=a/10;} } if(s==1) printf(“您的输入有误！请重新输入n”);else { printf(“n转换后的数为：%dn”,result);} } void O_X(int a){ int i,j,k,s=0;char p[30];int result=0;for(i=1;a!=0;i*=8){if(a%10>7){s=1;break;} else{result+=(a%10)*i;a=a/10;} } for(j=0;result!=0;j++){p[j]=result%16;result=result/16;if(p[j]<10)p[j]+=48;else { switch(p[j]){ case 10: p[j]='A';break;case 11: p[j]='B';break;case 12: p[j]='C';break;case 13: p[j]='D';break;case 14: p[j]='E';break;case 15: p[j]='F';break; } } } if(s==1)printf(“您的输入有误！请重新输入n”);else { printf(“n转换后的数为：”);for(k=j-1;k>=0;k--){printf(“%c”,p[k]);} printf(“n”);} } void X_D(char a[],int k)///////以下为: 十六进制转换为十进制,二进制,八进制.{ int i,j,s=0;int result=0;int b[50];for(i=0;i case 'E': b[i]=14;break;case 'F': b[i]=15;break;case 'a': b[i]=10;break;case 'b': b[i]=11;break;case 'c': b[i]=12;break;case 'd': b[i]=13;break;case 'e': b[i]=14;break;case 'f': b[i]=15;break;default: s=1;} } } for(i=1,j=k-1;j>=0;j--,i*=16){result+=b[j]*i;} if(s==1)printf(“您的输入有误！请重新输入n”);else {printf(“n转换后的数为：%d”,result);} } void X_B(char a[],int k){ int i,j,s=0;int result=0;int b[50];int p[30];for(i=0;i { switch(a[i]){ case 'A': b[i]=10;break;case 'B': b[i]=11;break;case 'C': b[i]=12;break;case 'D': b[i]=13;break;case 'E': b[i]=14;break;case 'F': b[i]=15;break;case 'a': b[i]=10;break;case 'b': b[i]=11;break;case 'c': b[i]=12;break;case 'd': b[i]=13;break;case 'e': b[i]=14;break;case 'f': b[i]=15;break;default: s=1;} } } for(j=k-1,i=1;j>=0;j--,i*=16){result+=b[j]*i;} for(j=0;result!=0;j++){ p[j]=result%2;result=result/2;} if(s==1)printf(“您的输入有误！请重新输入n”);else { printf(“n转换后的数为：”);for(k=j-1;k>=0;k--) 背景 大学的每个专业都要制定教学计划。假设任何专业都有固定的学习年限，每学年含两学期，每学期的时间长度和学分上限值均相等。每个专业开设的课程都是确定的，而且课程在开设时间的安排必须满足先修关系。每门课程有哪些先修课程是确定的，可以有任意多门，也可以没有。每门课恰好占一个学期。试在这样的前提下设计一个教学计划编制程序。 问题描述 若用有向网表示教学计划，其中顶点表示某门课程，有向边表示课程之间的先修关系（如果A课程是B课程的先修课程，那么A到B之间有一条有向边从A指向B）。试设计一个教学计划编制程序，获取一个不冲突的线性的课程教学流程。（课程线性排列，每门课上课时其先修课程已经被安排）。 一． 需求分析 1.顶点表示课程名称（包含学分信息），有向边表示课程之间的先修关系，用有向图实现这个教学计划编制问题。 2.采用广度优先的方法搜索每个节点是否有边通向该节点。3.对有向图实行拓扑排序 4.程序输出的拓扑排序就是其教学修读课程的序列 5.测试数据： 输入：请输入课程的数量和课程先后关系：6 每门课程的编号：001 002 003 004 005 006 先修课程编号（课程 课程） 001 002 001 003 002 003 002 004 003 005 004 006 005 006 输出：001 002 003 004 005 006 二． 概要设计 1.抽象数据类型： 由于课程之间存在明显的先后关系，采用拓扑排序进行教学计划的排序，而拓扑排序不直接输出课程信息，而采用队列实现课程信息的输出 拓扑图的ADT的定义： ADT Graph{ 数据对象：Subject是课程编号，是类型为char的二维数组 数据关系R：点a，b∈Graph，若点a到b有一条边，则arcs[a][b]=1;否则=0； 基本操作P： void Adj(Graph &G,char *c1,char *c2)//建立邻接矩阵 int Locate(Graph G,char *c){//图G中查找元素c的位置 int Indegree(Graph G,int pos)//计算入度 void DeleteDegree(Graph &G,int pos)//删除一条边 队列的抽象数据类型定义： ADT Queue{ 数据对象：D={ai|ai∈ElemSet,i=1,2,…,n,n≥0} 数据关系：Rl={ 约定其中ai端为队列头，an端为队列尾。基本操作 void InitQueue(Queue &Q){//初始化队列 void EnQueue(Queue &Q,int e){//入队列 void DeQueue(Queue &Q,int &e){//出队列 bool EmptyQueue(Queue Q)//判断是否为空 void InitQueue(Queue &Q)操作结果：构造一个空队列Q void EnQueue(Queue &Q,Node e)初始条件：队列Q已存在 操作结果：插入元素e为Q的新的队尾元素 void DeQueue(Queue &Q,Node &e)初始条件：Q为非空队列 操作结果：删除Q的队头元素，并用e返回其值 } 2.算法的基本思想： a.在有向图中选取一个入度为零的顶点并输出 b.删除该顶点及所有以它为尾的弧 c.重复a,b两步，知道所有节点均输出或者无度为零的节点结束。3.程序的流程 程序由四个模块组成： （1）输入模块：从键盘键入课程编号和课程之间的先修关系（2）建立Graph模块：构建符合课程关系的有向图（3）排序模块：对有向图图进行拓扑排序（4）输出模块：输出拓扑序列 三、详细设计 物理数据类型 由于课程与课程之间存在先修关系，可以采用有向图来构建课程与课程之间的关系，用邻接矩阵来实现图，采用入度为零的广度优先搜索来实现拓扑排序，用队列的方式来实现广度优先搜索 typedef struct{ char Subject[MAX_VEX][5];//顶点向量 int arcs[MAX_VEX][MAX_VEX];//邻接矩阵 int vexnum,arcnum;//图的当前顶点数和弧数 }Graph;图的伪代码： class Graph{ //图类 private: int numVertex;int numEdge;Line* line;public: Graph(int v,int e){numVertex=v;numEdge=e;line =new Line[v];} void pushVertex(){ //读入点 string ch; for(int i=0;i cout<<“请输入课程”< cin>>ch; line[i].head->node=ch; line[i].head->position=i; } } void pushEdge(){ //读入边 string ch1,ch2; int pos1,pos2; for(int i=0;i { cout<<“请输入课程关系”< cin>>ch1>>ch2; for(int j=0;j if(line[j].head->node==ch1) pos1=j; //找到该字母对应的位置 if(line[j].head->node==ch2){ pos2=line[j].head->position; break; } } line[pos1].insert(pos2,ch2); } } typedef struct{ int *base; int front; int rear; }Queue;拓扑排序的伪代码为： void topsort(){ //拓扑排序 int i; int *d=new int[numVertex]; for(i=0;i d[i]=0; //数组初始化 for(i=0;i Node* p=line[i].head; while(p->next!=NULL){ d[p->next->position]++;//计算每个点的入度 p=p->next; } 用队列实现拓扑排序的伪代码： int top=-1,m=0,j,k; for(i=0;i if(d[i]==0){ d[i]=top; //找到第一个入度为0的点 top=i; } while(top!=-1){ j=top; top=d[top]; cout< m++; Node* p=line[j].head; while(p->next!=NULL){ k=p->next->position; d[k]--; //当起点被删除，时后面的点的入度-1 if(d[k]==0){ d[k]=top; top=k; } p=p->next; } 算法的具体步骤 void CreateUDN(Graph &G){//建立一个有向图 //输入课程总数 //输入每门课程的编号 //输入课程的先修关系 } bool TopSort(Graph &G){ //有向图G采用邻接表储存结构 //若G无回路，则输出G的顶点的一个top序列并返回ture，否则返回false //队列实现top序列的存储和输出 } 算法的时空分析 Top排序： 对有n个顶点和e条弧的有向图而言，将建立求各顶点的入度的时间复杂度为O(e)；建零入度定点站的时间复杂度为O(n)，在top排序过程中，若有向图无环，则每个顶点近义词栈，出一次栈，入度减1的操作在while语句中总共执行e次，所以，总的时间复 杂度为O(n+e)。输入输出格式： 输入：请输入课程的数量和课程先后关系的个数：6 课程先后关系课程：7 每门课程的编号：001 002 003 004 005 006 输入课程关系（课程 课程）001 002 001 003 002 003 002 004 003 005 004 006 005 006 输出：教学计划为001 002 003 004 005 006 实验结果截图： 附录（代码）#include string node; int position;//位置 Node* next; bool visit;//是否被访问 Node(){visit=false;next=NULL;position=0;node=' ';} };class Line{ //线性表类 public: int num;Node* head;Node* rear;Node* fence;Line(){num=0;head=fence=rear=new Node();} void insert(int v,string ch){ //插入元素 Node* current=new Node(); current->node=ch; current->position=v; fence->next=current; fence=current; num++;} };class Graph{ //图类 private: int numVertex;int numEdge;Line* line;public: Graph(int v,int e){numVertex=v;numEdge=e;line =new Line[v];} void pushVertex(){ //读入点 string ch; for(int i=0;i cout<<“请输入课程”< cin>>ch; line[i].head->node=ch; line[i].head->position=i; } } void pushEdge(){ //读入边 string ch1,ch2; int pos1,pos2; for(int i=0;i { cout<<“请输入课程关系”< cin>>ch1>>ch2; for(int j=0;j if(line[j].head->node==ch1) pos1=j; //找到该字母对应的位置 if(line[j].head->node==ch2){ pos2=line[j].head->position; break; } } line[pos1].insert(pos2,ch2); } } void topsort(){ //拓扑排序 int i; int *d=new int[numVertex]; for(i=0;i d[i]=0; //数组初始化 for(i=0;i Node* p=line[i].head; while(p->next!=NULL){ d[p->next->position]++;//计算每个点的入度 p=p->next; } } int top=-1,m=0,j,k; for(i=0;i if(d[i]==0){ d[i]=top; //找到第一个入度为0的点 top=i; } while(top!=-1){ j=top; top=d[top]; cout< m++; Node* p=line[j].head; while(p->next!=NULL){ k=p->next->position; d[k]--; //当起点被删除，时后面的点的入度-1 if(d[k]==0){ d[k]=top; top=k; } p=p->next; } } } cout< if(m //输出点的个数小于输入点的个数，不能完全遍历 cout<<“网络存在回路”< delete []d;} };int main(){ int n,m;cout<<“请输入课程总数和课程先后关系的个数”< G.pushVertex();G.pushEdge();G.topsort();system(“pause”); return 0;} }第二篇：JAVA代码注释规范
第三篇：java流实验内容及代码
第四篇：教学计划编制问题
第五篇：教学计划编制问题
点击咨询 