久久久日韩精品一区二区三区,人妻aⅴ中文字幕无码,舔高中女生奶头内射视频

第一篇：java教學計劃編制的全部代碼

package curriculumProject;

//非連通圖的深度優先搜索遍歷和廣度優先搜索遍歷

import linearList.Queue.SeqQueue;

//順序循環隊列類

public abstract class AbstractGraph implements GGraph//抽象圖類

{

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;

{

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;

{

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(vertexCount());

//創建順序隊列

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 implements GGraph

//鄰接表表示的圖類

public class AdjListGraph extends AbstractGraph implements GGraph //鄰接表表示的圖類

{

protected SeqList> vertexlist;

//頂點表

public AdjListGraph(int n)

//構造方法，n指定頂點數

{

this.vertexlist = new SeqList>(n);

}

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(vertex));//在順序表最后插入一個元素

}

public boolean insertEdge(int i, int j)

//插入一條權值為weight的邊〈vi,vj〉

{

if(i>=0 && i=0 && j

{

//SortedHSLinkedList 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=0 && j

{

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=-1 && w

{

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 list = new ArrayList();System.out.println(“比如：C01是C02的先修課，則輸入 01 02”);for(int i = 0;i < bian;i++){

}

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(vertices,edges);

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 adjlink;

//該頂點的邊單鏈表

public Vertex(E data, SortedHSLinkedList adjlink)

{

this.data = data;

this.adjlink = adjlink;

}

public Vertex(E data)

{

this(data, new SortedHSLinkedList());

//構造結點時創建空單鏈表

}

public String toString()

{

return this.data.toString();

} }

第二篇：JAVA代碼注釋規范

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.模塊的注釋

/** *模塊名稱

*模塊的用處

第三篇：java流實驗內容及代碼

實驗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表示，等等）?？傮w功能與數據結構設計

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='1'){ b[i]=a[i]-48;} else { 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;} }

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='1')b[i]=a[i]-48;else { 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;} }

13.void X_D()：十六進制轉換為十進制

for(i=0;i='1'){ b[i]=a[i]-48;} else { 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;} }

14.void X_O()：十六進制轉換為八進制

其他進制間的轉換：調試與測試

4.1 教學計劃編制問題調試結果

輸入學期總數，輸入學期學分的上限，輸入教學計劃的課程數，輸入先修關系的邊數，輸入課程的代表值，輸入課程的學分值（如圖）

輸入每條弧的弧尾和弧頭（如圖）：

顯示的課程計劃如下：

4.2 進制轉換問題調試結果

進入系統時的界面：

二進制轉換為八進制：

十進制轉換為十六進制：

十六進制轉換為十進制：設計總結我的收獲

雖然在高中我們已經學了C語言，大一我們已經學習了C++語言，但是，直到本期我們才開設了數據結構這一門課程。這門課程讓我們對程序的原理有了系統的認識。對以往模糊的經驗，起了總結提升的作用。在學習了這門課程后，我們進行了一個星期的課程設計，以實踐我們的學習內容。

在這次課程設計中，我被分配到了教學計劃課程編制問題，開始感覺很難，因為我從未編寫過如此復雜的程序。在多方查找資料并參考類似程序后，我大體將程序的構架描繪好了。一邊對照著網上的資料，一邊對程序進行修改補充，然后根據擬好的大綱進行編制。期間，我與其它同學進行了討論和探究，對程序的細節問題和應用方面進行了探索，并解決了主要的問題，于是便著手寫具體的程序。

由于老師要求我們編寫600多行的代碼，但是教學計劃課程編制問題的代碼不足，所以我又選擇了一個課題——進制轉換問題，我會選擇這個課題是因為我覺得作為學計算機的我，應該要能更好的了解關于計算機方面的知識。

這次實驗，我進行了大量的資料查閱，對所學知識進行復習。通過這些努力，我對算法有了更深入的理解，對編程的步驟，有了具體的體會。通過和同學的廣泛交流，我體會到了合作的必要性及合作的優勢。更重要的是，這個課題完全脫胎于實際問題，讓我對計算機行業，充滿了信心和自豪。

以往我們學的計算機知識一般停留在理論上，這讓我們不太理解計算機的應用和前景，而較少注重我們對算法的實踐鍛煉。而這一次的實習既需要我們去聯系理論，又需要我們去實踐方法，很多東西看上去都學過，但是和實際聯系才知道變通的艱難。紙上得來終覺淺，這是我這次實習的最大收獲。這次的實驗讓我們知道該如何跨過實際和理論之間的鴻溝。

存在的問題

由于程序十分的復雜，遇到了很多常見的語法錯誤，及邏輯錯誤。這需要我們不斷的調試分析。符號的格式之類，指針的用法，判斷輸入輸出的條件都是十分容易出錯的地方。在逐條排除，程序終于得以完成。這讓我明白了，解決問題，要細心認真，集思廣益，這樣才能把問題解決。

雖然程序變出來了，但是我大量借鑒了別人的程序，中間有很多的程序段都是一知半解，雖然查閱了資料，但是畢竟不是自己思考出來的程序，又無法當面詢問寫出編程的人，所以對部分程序還存在問題，我會繼續查詢資料將目前不懂的內容弄清楚。

參考資料：數據結構（C++語言描述）吉根林陳波主編 C++語言教材程序代碼

教學計劃編制問題：

#include #include #include // malloc()等 #include // INT_MAX等 #include // EOF(=^Z或F6),NULL #include // atoi()52 #include // eof()#include // floor(),ceil(),abs()#include

// exit()#include // cout,cin // 函數結果狀態代碼 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE-1 typedef int Status;// Status是函數的類型,其值是函數結果狀態代碼，如OK等 typedef int Boolean;// Boolean是布爾類型,其值是TRUE或FALSE #define MAX_NAME 10 /* 頂點字符串的最大長度*/ #define MAXCLASS 100 int Z=0;int X=0;int xqzs,q=1,xfsx;typedef int InfoType;typedef char VertexType[MAX_NAME];/* 字符串類型*/ /* 圖的鄰接表存儲表示*/

#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 #include #include void D_B(int);void D_O(int);void D_X(int);void B_D(int);void B_O(int);void B_X(int);void O_B(int);void O_D(int);void O_X(int);void X_B(char r[],int k);void X_D(char r[],int k);void X_O(char r[],int k);void main(){ int i,j,k=0;int q;char r[10];

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]=='

久久99精品久久久久久琪琪,久久人人爽人人爽人人片亞洲,熟妇人妻无码中文字幕,亚洲精品无码久久久久久久

java教學計劃編制的全部代碼

第一篇：java教學計劃編制的全部代碼

第二篇：JAVA代碼注釋規范

第三篇：java流實驗內容及代碼

第四篇：教學計劃編制問題