⑴ 數據結構課程設計報告
1、一元稀疏多項式相加
詳細設計
4.1 程序頭的設計:
#include<stdio.h>
#include<malloc.h>
typedef struct pnode
{int coef;/*系數 */
int exp;/*指數 */
struct pnode *next;/*下一個指針*/
}pnode;
4.2 用頭插法生成一個多項式，系數和指數輸入0時退出輸入
pnode * creat()
{int m,n; pnode *head,*rear,*s;
/*head為頭指針，rear和s為臨時指針*/
head=(pnode *)malloc(sizeof(pnode));
rear=head;
/*指向頭*/
printf("input coef:");/*輸入系數*/
scanf("%d",&n);
printf("input exp:");/*輸入指數*/
scanf("%d",&m);
while(n!=0)/*輸入0就退出*/
{s=(pnode *)malloc(sizeof(pnode));
s->coef=n;
s->exp=m;
s->next=NULL;
rear->next=s;/*頭插法*/
rear=s;
printf("input coef:");/*輸入系數*/
scanf("%d",&n);
printf("input exp:");/*輸入指數*/
scanf("%d",&m);
}
head=head->next;/*第一個頭沒有用到*/
return head;
}
4.3 顯示一個多項式
void display(pnode *head)
{pnode *p;int one_time=1; p=head;
while(p!=NULL)/*不為空的話*/
{
if(one_time==1)
{if(p->exp==0)/*如果指數為0的話，直接輸出系數*/
printf("%d",p->coef); /*如果系數是正的話前面就要加+號*/
else if(p->coef==1||p->coef==-1)
printf("x^%d",p->exp);/*如果系數是1的話就直接輸出+x*/
/*如果系數是-1的話就直接輸出-x號*/
else if(p->coef>0)/*如果系數是大於0的話就輸出+系數x^指數的形式*/
printf("%dx^%d",p->coef,p->exp);
else if(p->coef<0)/*如果系數是小於0的話就輸出系數x^指數的形式*/
printf("%dx^%d",p->coef,p->exp);
one_time=0;
}
else{
if(p->exp==0)/*如果指數為0的話，直接輸出系數*/
{if(p->coef>0)
printf("+%d",p->coef); /*如果系數是正的話前面就要加+號*/
}
else if(p->coef==1)
printf("+x^%d",p->exp);
else if(p->coef==-1)
printf("x^%d",p->exp);/*如果系數是1的話就直接輸出+x號*/
else if(p->coef>0)/*如果系數是大於0的話就輸出+系數x^指數的形式*/
printf("+%dx^%d",p->coef,p->exp);
else if(p->coef<0)/*如果系數是小於0的話就輸出系數x^指數的形式*/
printf("%dx^%d",p->coef,p->exp);
}
p=p->next;/*指向下一個指針*/
}
printf("\n");
4.4 兩個多項式的加法運算
pnode * add(pnode *heada,pnode *headb)
{pnode *headc,*p,*q,*s,*r;
/*headc為頭指針，r,s為臨時指針，p指向第1個多項式並向右移動，q指向第2個多項式並並向右移動*/
int x;
/*x為系數的求和*/
p=heada;
/*指向第一個多項式的頭*/
q=headb;
/*指向第二個多項式的頭*/
headc=(pnode *)malloc(sizeof(pnode));
r=headc;
/*開辟空間*/
while(p!=NULL&&q!=NULL)
/*2個多項式的某一項都不為空時*/
{if(p->exp==q->exp)/*指數相等的話*/
{x=p->coef+q->coef;/*系數就應該相加*/
if(x!=0)/*相加的和不為0的話*/
{s=(pnode *)malloc(sizeof(pnode));/*用頭插法建立一個新的節點*/
s->coef=x;
s->exp=p->exp;
r->next=s;
r=s;
}
q=q->next;p=p->next;
/*2個多項式都向右移*/
}
else if(p->exp<q->exp)/*p的系數小於q的系數的話，就應該復制q接點到多項式中*/
{s=(pnode *)malloc(sizeof(pnode));
s->coef=q->coef;
s->exp=q->exp;
r->next=s;
r=s;
q=q->next;/*q向右移動*/
}
else/*p的系數大於q的系數的話，就應該復制p接點到多項式中*/
{s=(pnode *)malloc(sizeof(pnode));
s->coef=p->coef;
s->exp=p->exp;
r->next=s;
r=s;
p=p->next;/*p向右移動*/
}
}
當第2個多項式空，第1個數不為空時，將第一個數剩下的全用新節點產生
while(p!=NULL)
{s=(pnode *)malloc(sizeof(pnode));
s->coef=p->coef;
s->exp=p->exp;
r->next=s;
r=s;
p=p->next;
}
當第1個多項式空，第1個數不為空時，將第2個數剩下的全用新節點產生
while(q!=NULL)
{s=(pnode *)malloc(sizeof(pnode));
s->coef=q->coef;
s->exp=q->exp;
r->next=s;
r=s;
q=q->next;
}
r->next=NULL;
/*最後指向空*/
headc=headc->next;/*第一個頭沒有用到*/
return headc;/*返回頭接點*/
4.5 兩個多項式的減法運算，和加法類似，不同的地方已經注釋
pnode * sub(pnode *heada,pnode *headb)
{pnode *headc,*p,*q,*s,*r;
int x;
p=heada;q=headb;
headc=(pnode *)malloc(sizeof(pnode));
r=headc;
while(p!=NULL&&q!=NULL)
{if(p->exp==q->exp)
{x=p->coef-q->coef;/*系數相減*/
if(x!=0)
{s=(pnode *)malloc(sizeof(pnode));
s->coef=x;
s->exp=p->exp;
r->next=s;
r=s;
}
q=q->next;p=p->next;
}
else if(p->exp<q->exp)/*p的系數小於q的系數的話*/
{s=(pnode *)malloc(sizeof(pnode));
s->coef=-q->coef;/*建立的接點的系數為原來的相反數*/
s->exp=q->exp;
r->next=s;
r=s;
q=q->next;
}
else
{s=(pnode *)malloc(sizeof(pnode));
s->coef=p->coef;
s->exp=p->exp;
r->next=s;
r=s;
p=p->next;
}
}
while(p!=NULL)
{s=(pnode *)malloc(sizeof(pnode));
s->coef=p->coef;
s->exp=p->exp;
r->next=s;
r=s;
p=p->next;
}
while(q!=NULL)
{s=(pnode *)malloc(sizeof(pnode));
s->coef=-q->coef;/*建立的接點的系數為原來的相反數*/
s->exp=q->exp;
r->next=s;
r=s;
q=q->next;
}
r->next=NULL;
headc=headc->next;
return headc;
4.6 界面設計:
printf("\n ****************************************\n");
printf("\n ************** 03 Computer *************\n");
printf("\n ******** Class:two **** Num:34 *********\n");
printf("\n *********** Name: xie pan **********\n");
printf("\n ****************************************\n");
printf("\n --------------1: add -------------\n");
printf("\n --------------2: sub -------------\n");
printf("\n --------------3: exit ------------\n");
printf("\n ****************************************\n");
4.7 連接程序:
case 1:add_main();break;/*加法*/
case 2:sub_main();break;/*減法*/
case 3:break;/*退出*/
⑵ 求一份數據結構課程設計報告
//class CNode.h
#ifndef __CNODE_H__
#define __CNODE_H__
#include <iostream>
using namespace std;
struct stData //出生年月結構
{
int m_nYear;
int m_nMonth;
int m_nDay;
};
struct stResult //五門課成績結構
{
double m_dSubject_1; //自己改成績的名稱
double m_dSubject_2;
double m_dSubject_3;
double m_dSubject_4;
double m_dSubject_5;
};
struct stStudent //聲明學生信息的結構
{
string m_strNumber; //學生學號
string m_strName; //姓名
char m_chSex; //性別
struct stData m_stData; //出生年月
string m_strAppearance; //政治面貌
struct stResult m_stResult; //五門課成績
};
typedef class CNode
{
private:
struct stStudent m_stStudent;
CNode* m_Next;
public:
CNode(); //構造函數
~CNode(); //析構函數
void SetNodeData(); //設置結點內容的函數成員
stStudent GetNodeData(); //獲取結點內容的函數成員
void SetNodeNext(CNode* _Next); //設置結點Next指針的函數成員
void ShowNodeData(); //輸出結點內容的函數成員
CNode* GetNodeNext(); //獲取結點Next指針的函數成員
}LinkNode;
#endif
//class CLinkList
#ifndef __CLINKLIST_H__
#define __CLINKLIST_H__
#include "CNode.h"
typedef class CLinkList
{
private:
LinkNode* m_Head; //鏈表的頭指針
LinkNode m_Node; //鏈表的頭結點
public:
CLinkList(); //構造函數
~CLinkList(); //析構函數
void CreateList(); //初始化鏈表的函數成員
LinkNode* GetListNode(int _nIndex); //按位置查找指定位結點的成員函數
void InsertList(int _nIndex); //插入結點的成員函數
void DeleteList(int _nIndex); //刪除某一結點的成員函數
LinkNode* GetHeadList(); //獲取頭指針的成員函數
void SetListData(int _nIndex); //設置鏈表中某一結點的值的成員函數
void ShowListData(int _nIndex); //這個是現實鏈表中某一結點值的函數成員
void DestroyList(int _nIndex); //銷毀某一位置以後鏈表的成員函數
void ShowList(); //顯示鏈表的成員函數
}LinkList;
#endif
//class CLinkList
#include "CLinkList.h"
#include "CNode.h"
CLinkList::CLinkList()
{
cout << "這個是構造函數"<< endl;
m_Head = &m_Node; //鏈表的頭指針指向頭結點
m_Node.SetNodeNext(NULL); //將頭結點的Next指針設置為NULL;
}
CLinkList::~CLinkList()
{
cout << "這個是析構函數" << endl;
}
void CLinkList::CreateList() //以向後追加的方式創建一個鏈表，輸入0退出
{
int nTemp = 0; //定義一個臨時變數用於標志程序結束
cout << "歡迎來創建鏈表 !" << endl;
CNode * pTemp = NULL; //定義一個臨時結點指針，用來增加新結點用
CNode * pNode = m_Head; //定義一個標記指針，首先叫其指向頭結點
while(1)
{
pTemp = new LinkNode;
cout << "請輸入下一個結點的內容!" << endl;
pTemp->SetNodeData(); //設置鏈表中結點的內容
cout << "如果想繼續輸入下一個學生的信息請輸入 1，否則輸入 0" << endl;
cin >> nTemp;
if ('0' == nTemp)
{
break;
}
pNode->SetNodeNext(pTemp); //讓鏈尾的Next指向新建的結點
pNode = pTemp; //將結尾元素向後移
}
cout << "創建鏈表結束" << endl;
}
LinkNode* CLinkList::GetListNode(int _nIndex)
{
cout << "這個是按位置查找指定位結點的成員函數" << endl;
LinkNode* pNode = m_Head->GetNodeNext(); //定義一個臨時的結點指針,初始化指向頭結點
int Temp = 0; //定義一個臨時的變數，用來標記已檢查結點的個數的
if(-1 == _nIndex) //返回頭結點（即頭指針）
{
return m_Head;
}
if(_nIndex < -1) //_nIndex控制條件
{
cout << "您輸入的是錯誤的位置！" << endl;
return 0;
}
while(pNode != NULL)
{
if(_nIndex == Temp)
{
return pNode;
}
pNode = pNode->GetNodeNext(); //臨時結點向後移動
++Temp;
}
return pNode; //沒找到結點就返回NULL
}
void CLinkList::ShowListData(int _nIndex);
void CLinkList::InsertList(int _nIndex) //插入結點的函數成員
{
cout << "這個是插入結點的成員函數" << endl;
LinkNode* pNode = GetListNode(_nIndex - 1); //定義一個結點類的指針，指向的是要插入位置的前一指針
LinkNode* pTemp = new CNode; //定義一個臨時結點指針，用來增加新結點用
pTemp->SetNodeData(); //設置插入結點的內容
pTemp->SetNodeNext(pNode->GetNodeNext());
pNode->SetNodeNext(pTemp);
}
void CLinkList::DeleteList(int _nIndex)
{
cout << "這個是刪除某一結點的成員函數" << endl;
LinkNode* pNode = GetListNode(_nIndex - 1); //定義一個結點類的指針，指向的是要刪除位置的前一指針
LinkNode* pTemp = NULL; //定義一個臨時結點指針，用來指向要刪除的結點
pTemp =pNode->GetNodeNext(); //把pTemp指向要刪除的結點
pNode->SetNodeNext(pTemp->GetNodeNext()); //把pNode指向要刪除的結點的後一個結點
delete pTemp; //刪除結點
pTemp = NULL;
}
LinkNode* CLinkList::GetHeadList()
{
cout << "這個是獲取頭指針的成員函數" << endl;
return m_Head;
}
void CLinkList::SetListData(int _nIndex)
{
cout << "這個是設置鏈表中某一結點的值的成員函數" << endl;
CNode *pNode = GetListNode(_nIndex); //定義一個結點類的指針，指向的是要修改內容位置的結點
pNode->SetNodeData(); //修改內容
}
void CLinkList::ShowListData(int _nIndex)
{
cout << "這個是顯示鏈表中某一結點值的成員函數" << endl;
CNode *pNode = GetListNode(_nIndex); //定義一個結點類的指針，指向的是要獲取內容位置的結點
pNode->ShowNodeData(); //返回想要得到位置的結點內容
}
void CLinkList::DestroyList(int _nIndex)
{
cout << "這個是銷毀某一位置以後鏈表的成員函數" << endl;
LinkNode* pTemp = GetListNode(_nIndex - 1); //定義一個結點指針，指向要銷毀位置的前一結點
LinkNode* pNode = pTemp->GetNodeNext(); //定義一個結點指針，指向要銷毀位置的結點
while(pTemp->GetNodeNext() != NULL) //銷毀動作的結束條件或初始條件
{
pTemp->SetNodeNext(pNode->GetNodeNext()); //把需要銷毀的位置的前結點的Next指向銷毀位置的下一個結點
delete pNode; //銷毀結點
pNode = pTemp->GetNodeNext(); //把pNode重新指向要銷毀位置的結點
}
}
void CLinkList::ShowList()
{
cout << "這個是顯示鏈表的成員函數" << endl;
int nTemp = 0; //定義一個臨時的整形變數用來控制輸入的個數
LinkNode* pTemp = m_Head->GetNodeNext(); //定義一個結點類指針，指向第0位的結點
if(NULL == pTemp)
{
cout << "這是個空鏈" << endl;
}
while(pTemp != NULL)
{
pTemp->ShowNodeData();
++nTemp;
if(0 == nTemp % 5 && nTemp != 0) //控制每行只能輸出5個結點的內容
{
cout << endl;
}
pTemp = pTemp->GetNodeNext();
}
}
//class CNode
#include "CNode.h"
CNode::CNode() //構造函數
{
//m_stStudent = {0};
m_Next = NULL;
}
CNode::~CNode() //析構函數
{
}
void CNode::SetNodeData()
{
char* pNumber = new char[30]; //用來接收字元串的臨時變數
char* pName = new char[30];
char* pAppearance = new char[30];
cout << "學生學號: " << endl;
cin >> pNumber;
m_stStudent.m_strNumber = pNumber;
cout << "姓名: " << endl;
cin >> pName;
m_stStudent.m_strName = pName;
cout << "性別: " << endl;
cin >> m_stStudent.m_chSex;
cout << "出生年月: " << endl;
cout << "m_stData.m_nYear" << endl;
cin >> m_stStudent.m_stData.m_nYear;
cout << "m_stData.m_nMonth" << endl;
cin >> m_stStudent.m_stData.m_nMonth;
cout << "m_stData.m_nDay" << endl;
cin >> m_stStudent.m_stData.m_nDay;
cout << "政治面貌: " << endl;
cin >> pAppearance;
m_stStudent.m_strAppearance = pAppearance;
cout << "五門課成績: " << endl;
cout << "m_dSubject_1: " << endl;
cin >> m_stStudent.m_stResult.m_dSubject_1;
cout << "m_dSubject_2: " << endl;
cin >> m_stStudent.m_stResult.m_dSubject_2;
cout << "m_dSubject_3: " << endl;
cin >> m_stStudent.m_stResult.m_dSubject_3;
cout << "m_dSubject_4: " << endl;
cin >> m_stStudent.m_stResult.m_dSubject_4;
cout << "m_dSubject_5: " << endl;
cin >> m_stStudent.m_stResult.m_dSubject_5;
delete []pNumber; //釋放內存
pNumber = NULL; //指針置空
delete []pName; //釋放內存
pName = NULL;
delete []pAppearance; //釋放內存
pAppearance = NULL;
}
stStudent CNode::GetNodeData() //返回結點內容（即學生信息）
{
return m_stStudent;
}
void CNode::SetNodeNext(CNode* _Next)
{
m_Next = _Next;
}
void CNode::ShowNodeData()
{
const char* pNumber = m_stStudent.m_strNumber.c_str(); //用來接收字元串的臨時變數
const char* pName = m_stStudent.m_strNumber.c_str();
const char* pAppearance = m_stStudent.m_strAppearance.c_str();
cout << "學生學號: " << pNumber << '\t' << "姓名: " << pName << '\t' << "性別: " << m_stStudent.m_chSex;
cout << "出生年月: " << m_stStudent.m_stData.m_nYear << ',' << m_stStudent.m_stData.m_nMonth << ',' << m_stStudent.m_stData.m_nDay;
cout << "政治面貌: " << pAppearance << "五門課成績: " << endl;
cout << "m_dSubject_1: "<< m_stStudent.m_stResult.m_dSubject_1<< endl;
cout << "m_dSubject_2: "<< m_stStudent.m_stResult.m_dSubject_2<< endl;
cout << "m_dSubject_3: "<< m_stStudent.m_stResult.m_dSubject_3<< endl;
cout << "m_dSubject_4: "<< m_stStudent.m_stResult.m_dSubject_4<< endl;
cout << "m_dSubject_5: "<< m_stStudent.m_stResult.m_dSubject_5<< endl;
}
CNode* CNode::GetNodeNext()
{
return m_Next;
}
#include "CLinkList.h"
#include "CNode.h"
void Text(); //測試函數聲明
int main()
{
cout << "這是mian函數" << endl;
Text();
return 0;
}
void Text()
{
cout << "這個是測試函數" << endl;
LinkList* pList = new LinkList; //創建一個內存鏈表對象
cout << "------------------CreateList-----------------------------" << endl;
pList->CreateList(); //初始化鏈表的函數成員
pList->ShowList();
cout << endl;
cout << "------------------GetListNode-----------------------------" << endl;
LinkNode* pNode = NULL; //定義一個臨時的結點類指針用於檢測查找函數成員
pNode = pList->GetListNode(3); //按位置查找指定位結點的成員函數的測試
if(pNode)
{
cout << "用按位置查找的方法找到了指定位結點" << endl;
}
else
{
cout << "對不起，用按位置查找的方沒有找到指定位結點" << endl;
}
cout << endl;
cout << "------------------InsertList-----------------------------" << endl;
pList->InsertList(0); //插入結點的成員函數的測試
pList->ShowList();
cout << endl;
cout << "------------------DeleteList-----------------------------" << endl;
pList->DeleteList(0); //刪除某一結點的成員函數的測試
pList->ShowList();
cout << endl;
cout << "------------------GetHeadList-----------------------------" << endl;
pNode = NULL;
pNode = pList->GetHeadList(); //獲取頭指針的成員函數的測試
if(pNode)
{
cout << "已經返回了頭指針" << endl;
}
else
{
cout << "對不起，頭指針為空" << endl;
}
cout << endl;
cout << "------------------GetHeadList-----------------------------" << endl;
pList->SetListData(3); //設置鏈表中某一結點的值的成員函數的測試
pList->ShowList();
cout << endl;
cout << "------------------GetListData-----------------------------" << endl;
cout << "pList->ShowListData(3) =";
pList->ShowListData(3); //獲取鏈中某一結點值的成員函數的測試
cout << endl;
cout << "------------------DestroyList(3)-----------------------------" << endl;
pList->DestroyList(3); //銷毀第3位置以後鏈表的成員函數的測試
pList->ShowList();
cout << endl;
cout << "------------------DestroyList(0)-----------------------------" << endl;
pList->DestroyList(0); //銷毀第0位置以後鏈表的成員函數的測試
pList->ShowList();
cout << endl;
delete pList; //釋放內存
pList = NULL; //指針置空
}
你的要求太多 ， 沒仔細看， 我把我給別人寫的賦值給你吧 ， 我已經寫的很全了，程序有問題可以給我留言
⑶ 誰養魚問題的數據結構與演算法課程設計報告
.需求分析1.運行環境硬體：計算機486/64M以上操作系統：WIN9x以上/WIN2000/WINXP/WINME相關軟體：vistualC++2．程序所實現的功能：（1）建立並顯示圖的鄰接表。（2）深度優先遍歷，顯示遍歷結果。（3）對該圖進行拓撲排序，顯示排序結果。（4）給出某一確定頂點到所有其它頂點的最短路徑。3.程序的輸入，包含輸入的數據格式和說明(1)輸入頂點數,及各頂點信息(數據格式為整形)(2)輸入邊數,及權值(數據格式為整形)4.程序的輸出，程序輸出的形式(1)輸出圖的鄰接表、深度優先遍歷結果、拓撲排序結果。(2)輸入某一確定頂點到其它所有頂點的最短路徑。5.測試數據二、設計說明1、演算法設計的思想建立圖類，建立相關成員函數。最後在主函數中實現。具體成員函數的實現請參看源程序。2、主要的數據結構設計說明圖鄰接矩陣、鄰接表的建立。圖的深度優先遍歷、拓撲排序、頂點之間的最短路徑。3、程序的主要模板templateclassGraph4、程序的主要函數Graph、link()、DFTraverse()、TopologicalOrder()、TopologicalOrder()、GetVertexPos()、ShortestPath三、上機結果及體會1、實際完成的情況說明主要程序參考教材《數據結構——C++版》。2、程序的性能分析可連續建圖3、上機過程中出現的問題及其解決方案。編譯沒有錯誤，但結果有問題。解決方案：雖然程序的編譯通過，只能說明語法上沒有問題，結果只所以不正確是因為演算法上原因。4、程序中可以改進的地方說明程序中的深度優先遍歷，浪費空間較大，可以考慮用循環來做。但這樣將付出代碼長度度加長的代價。5、程序中可以擴充的功能及設計實現假想實現假想：隨用戶的輸入可以隨時動態的顯示圖的生成。6、收獲及體會編寫程序即是一件艱苦的工作，又是一件愉快的事情。最大的收獲：編程時如果遇到看似簡單但又無法解決的問題，很容易灰心喪氣。此時切不可煩躁，一定要冷靜的思考，認真的分析。要勇敢的面對問題，勇敢的接受問題，勇敢的處理問題，最後最勇敢的解決問題。四、參考文獻數據結構（C++版）葉核亞主編機械工業出版社數據結構經典演算法實現與習題解答汪傑編著人民郵電出版社數據結構課程設計蘇仕華編著機械工業出版社數據結構程序設計題典李春葆編著清華大學出版社數據結構課程與題解（用C/C++描述）胡聖榮編著北京大學出版社[程序運行流程圖]charop//程序控制變數希望對你能有所幫助。
⑷ 數據結構的課程設計報告要怎麼寫啊
暈/////真麻煩。。。。。
數據結構實習報告規范
實習報告的開頭應給出題目、班級、姓名、學號和完成日期，並包括以下七個內容：
1、需求分析
以無歧義的陳述說明程序設計的任務，強調的是程序要做什麼？明確規定：
（1）輸入的形式和輸入值的范圍；
（2）輸出的形式；
（3）程序所能達到的功能；
（4）測試數據：包括正確地輸入及其輸出結果和含有錯誤的輸入及其輸出結果。
2、概要設計
說明本程序中用到的所有抽象數據類型的定義、主程序的流程以及各程序模塊之間的層次（調用）關系。
3、詳細設計
實現概要設計中定義的所有數據類型，對每個操作只需要寫出偽碼演算法；對主程序和其他模塊也都需要寫出偽碼演算法（偽碼演算法達到的詳細程度建議為：按照偽碼演算法可以在計算機鍵盤直接輸入高級程序設計語言程序）；畫出函數的調用關系圖。
4、調試分析
內容包括：
（1）調試過程中遇到的問題是如何解決的以及對設計與實現的回顧討論和分析；
（2）演算法的時空分析（包括基本操作和其他演算法的時間復雜度和空間復雜度的分析）和改進思想；
（3）經驗和體會等。
5、用戶使用說明
說明如何使用你編寫的程序，詳細列出每一步操作步驟。
6、測試結果
列出你的測試結果，包括輸入和輸出。這里的測試數據應該完整和嚴格，最好多於需求分析中所列。
7、附錄
題 目 : [數據結構] 約瑟夫-實習報告
尺 寸 : 約瑟夫-實習報告.doc
目 錄 : 一、需求分析
二、概要設計
三、程序具體設計及函數調用關系
四、調試分析
五、測試結果
原 文 : 實習報告
題目：約瑟夫（Joseph）問題的一種描述是：編號為1，2，......，n的n個人按順時針方向圍坐一圈，每人持有一個密碼（正整數）。一開始任選一個整數作為報數上限值m，從第一個人開始按順時針方向自1開始順序報數，報到m時停止報數。報m的人出列，將他的密碼作為新的m值，從他在順時針方向上的下一個開始重新從1報數，如此下去，直至年有人全部出列為止。試設計一個程序求出出列順序。
班級： 姓名： 學號： 完成日期：
一、需求分析
1． 本演示程序中，利用單向循環鏈表存儲結構存儲約瑟夫環數據（即n個人的編號和密碼）。
2． 演示程序以用戶和計算機的對話方式執行，即在計算機終端上顯示"提示信息"之後，由用戶在鍵盤上輸入演示程序中需要輸入的數據，運算結果顯示在其後。
3． 程序執行的命令包括：
1)構造單向循環鏈表；2）
4． 測試數據
m 的初值為20；n=7，7個人的密碼依次為：3，1，7，2，4，8，4，首先m值為6（正確的出列順序為6，1，4，7，2，1，3，5）。
二、概要設計
1．單向循環鏈表的抽象數據類型定義為：
ADT List｛
數據對象：D=｛ai | ai∈正整數，I=1，2，......，n,n≥0｝
數據關系：R1=｛< ai-1，ai > |，ai-1，ai∈D,I=1，2，......，n｝
基本操作：
Init List(&L)
操作結果：構造一個空的線性表L。
List Insert(&L,i,e)
初始條件：線性表L已存在，1≤i≤List Length(L)+1.
操作結果：在L中第i個位置之前插入新的數據無素e，L長度加1。
List Delete(&L,i,&e)
初始條件：線性表L存在非空，1≤i≤List Length(L).
操作結果：刪除L的第i個元素，並用e返回其值，L長度減1。
2． 程序包含四個模塊：
1）主程序模塊：
⑸ 數據結構課程設計
#include <stdio.h>
#include <malloc.h>
#include <windows.h>
#include <time.h>
#define MAXSIZE 100
typedef struct Ttime{
int t_hour;
int t_min;
int t_sec;
}Ttime;
typedef struct Mcar{
int number;
Ttime t[2];
}Mcar;
typedef struct{
Mcar elements[MAXSIZE];
int top;
}CarStop;
typedef struct node{
Mcar date;
struct node *next;
}LinkQueue;
typedef struct{
LinkQueue *front;
LinkQueue *rear;
}Queue;
void InitQueue(Queue *Q){
Q -> front = (LinkQueue *) malloc(sizeof(LinkQueue));
Q -> front -> next = NULL;
Q -> rear = Q -> front;
}
int IsEmptyH(Queue Q){
if(Q.front == Q.rear)
return 1;
else
return 0;
}
void EeQueue(Queue *Q, Mcar x){
Q -> rear -> next = (LinkQueue *)malloc(sizeof(LinkQueue));
Q -> rear = Q -> rear -> next;
Q -> rear -> date = x;
Q -> rear -> next = NULL;
}
Mcar DeQueue(Queue *Q){
LinkQueue *p;
Mcar y;
if(!IsEmpty(*Q)){
p = Q -> front -> next;
Q -> front -> next = p -> next;
if(p -> next == NULL)
Q -> rear = Q -> front;
y = p -> date;
free(p);
return y;
}
}
int IsEmpty(CarStop S){
if(S.top == 0)
return 1;
else
return 0;
}
int IsFull(CarStop S){
if(S.top == MAXSIZE)
return 1;
else
return 0;
}
int Init(CarStop *S){
S -> top = 0;
}
void PutIn(CarStop *S, Mcar D){
if(!IsFull(*S)){
S -> elements[S -> top] = D;
S -> top++;
}
else
printf("IS FULL");
}
Mcar Pop(CarStop *S){
if(!IsEmpty(*S)){
S -> top--;
return S -> elements[S -> top];
}
else
printf("IS NULL");
}
Mcar TopNum(CarStop S){
if(!IsEmpty(S)){
return S.elements[S.top - 1];
}
}
int serachOneCar(CarStop S, Mcar num){
int i = 0;
if(!IsEmpty(S)){
while(i <= S.top){
if(num.number == S.elements[i].number)
return 1;
i++;
}
}
else
return 0;
}
void getInOneCar(CarStop *CarStack, Queue *Q, Mcar car){
time_t secnow;
struct tm * tmptr;
time(&secnow);
tmptr = localtime(&secnow);
car.t[0].t_hour= tmptr -> tm_hour;
car.t[0].t_min = tmptr -> tm_min;
car.t[0].t_sec = tmptr -> tm_sec;
printf("please put in you car number:\n");
scanf("%d", &car.number);
if(!IsFull(*CarStack))
PutIn(CarStack, car);
else{
printf("car stop is full, please stay in bian\n");
EeQueue(Q, car);
}
printf("you car's intime is :[%d]:[%d]:[%d]\n\n\n", car.t[0].t_hour, car.t[0].t_min, car.t[0].t_sec);
}
void getOutOneCar(CarStop *CarStack, CarStop *CarStackL, Queue *Q, Mcar car){
Mcar lin;
time_t secnow;
struct tm * tmptr;
time(&secnow);
tmptr = localtime(&secnow);
car.t[1].t_hour= tmptr -> tm_hour;
car.t[1].t_min = tmptr -> tm_min;
car.t[1].t_sec = tmptr -> tm_sec;
printf("please put in you car number:\n");
scanf("%d", &car.number);
if(IsEmpty(*CarStack) || !serachOneCar(*CarStack, car))
printf("soory, there is no the car\n");
else{
while(1){
lin = Pop(CarStack);
if(lin.number == car.number)
break;
else
PutIn(CarStackL, lin);
}
while(!IsEmpty(*CarStackL)){
PutIn(CarStack, Pop(CarStackL));
}
if(!IsEmptyH(*Q))
PutIn(CarStack, DeQueue(Q));
printf("\n\nyou car's intime is :[%d]:[%d]:[%d]\n", lin.t[0].t_hour, lin.t[0].t_min, lin.t[0].t_sec);
printf("you car's out time is :[%d]:[%d]:[%d]\n", car.t[1].t_hour, car.t[1].t_min, car.t[1].t_sec);
int alltime = (car.t[1].t_hour - lin.t[0].t_hour) * 3600 + (car.t[1].t_min - lin.t[0].t_min) * 60 + (car.t[1].t_sec - lin.t[0].t_sec);
printf("you car's all time is second:[%d]\n", alltime);
}
}
int main(){
CarStop CarStack, CarStackL;
Queue Q;
LinkQueue *pp;
InitQueue(&Q);
Init(&CarStack);
Init(&CarStackL);
Mcar car;
//String caozuo;
int caozuo, i, j;
while(1){
printf("\t**************the car stop menu*************\n");
printf("\t\t***** 1. get in a car\n\n");
printf("\t\t***** 2. get out a car\n\n");
printf("\t\t***** 0. out the car stop\n\n");
printf("\t\t*****put in the else you can see all the car in the carstop\n\n");
printf("\t*****************************************\n");
printf("please put in you caozuo: \n");
scanf("%d", &caozuo);
switch(caozuo){
case 1: getInOneCar(&CarStack, &Q, car);
break;
case 2: getOutOneCar(&CarStack, &CarStackL, &Q, car);
break;
case 0: return 0; break;
default : break;
}
if(!IsEmpty(CarStack)){
i = 0;
printf("the all car is:\n");
while(i < CarStack.top){
printf("the [%d] is %d\n",i + 1, CarStack.elements[i].number);
i++;
}
}
else
printf("the car stop IS NULL\n");
printf("****************************\n");
if(!IsEmptyH(Q)){
j = 1;
pp=Q.front;
printf("the bian's car is:\n");
while(pp!=Q.rear){
printf("the [%d] wait car is %d\n", j, pp -> next -> date.number);
pp = pp -> next;
j++;
}
}
else
printf("the bian is NULL\n");
printf("****************************\n");
system("pause");
system("cls");
}
}
C語言編譯通過
⑹ 《數據結構 課程設計》表達式求值 實驗報告
算術表達式求值演示
一、概述
數據結構課程設計，要求學生在數據結構的邏輯特性和物理表示、數據結構的選擇和應用、演算法的設計及其實現等方面，加深對課程基本內容的理解。同時，在程序設計方法以及上機操作等基本技能和科學作風方面受到比較系統和嚴格的訓練。
在這次的課程設計中我選擇的題目是算術表達式求值演示。表達式計算是實現程序設計語言的基本問題之一，也是棧的應用的一個典型例子。設計一個程序，演示用算符優先法對算術表達式求值的過程。深入了解棧和隊列的特性，以便在解決實際問題中靈活運用它們，同時加深對這種結構的理解和認識。
二、 系統分析
1． 以字元列的形式從終端輸入語法正確的、不含變數的整數表達式。利用已知的算符優先關系，實現對算術四則混合運算表達式的求值，並仿照教科書的例子在求值中運算符棧、運算數棧、輸入字元和主要操作的變化過程。
2． 一般來說，計算機解決一個具體問題時，需要經過幾個步驟：首先要從具體問題抽象出一個適當的數學模型，然後設計一個解決此數學模型的演算法，最後編出程序，進行測試，調試直至得到想要的答案。對於算術表達式這個程序，主要利用棧，把運算的先後步驟進行分析並實現簡單的運算！為實現算符優先演算法，可以使用兩個棧，一個用以寄存運算符，另一個用以寄存操作數和運算結果。
3． 演示程序是以用戶於計算機的對話方式執行，這需要一個模塊來完成使用者與計算機語言的轉化。 4． 程序執行時的命令：
本程序為了使用具體，採用菜單式的方式來完成程序的演示，幾乎不用輸入什麼特殊的命令，只需按提示輸入表達式即可。（要注意輸入時格式，否者可能會引起一些錯誤） 5. 測試數據。
2
算術表達式求值演示
一、概述
數據結構課程設計，要求學生在數據結構的邏輯特性和物理表示、數據結構的選擇和應用、演算法的設計及其實現等方面，加深對課程基本內容的理解。同時，在程序設計方法以及上機操作等基本技能和科學作風方面受到比較系統和嚴格的訓練。
在這次的課程設計中我選擇的題目是算術表達式求值演示。表達式計算是實現程序設計語言的基本問題之一，也是棧的應用的一個典型例子。設計一個程序，演示用算符優先法對算術表達式求值的過程。深入了解棧和隊列的特性，以便在解決實際問題中靈活運用它們，同時加深對這種結構的理解和認識。
二、 系統分析
1． 以字元列的形式從終端輸入語法正確的、不含變數的整數表達式。利用已知的算符優先關系，實現對算術四則混合運算表達式的求值，並仿照教科書的例子在求值中運算符棧、運算數棧、輸入字元和主要操作的變化過程。
2． 一般來說，計算機解決一個具體問題時，需要經過幾個步驟：首先要從具體問題抽象出一個適當的數學模型，然後設計一個解決此數學模型的演算法，最後編出程序，進行測試，調試直至得到想要的答案。對於算術表達式這個程序，主要利用棧，把運算的先後步驟進行分析並實現簡單的運算！為實現算符優先演算法，可以使用兩個棧，一個用以寄存運算符，另一個用以寄存操作數和運算結果。
3． 演示程序是以用戶於計算機的對話方式執行，這需要一個模塊來完成使用者與計算機語言的轉化。 4． 程序執行時的命令：
本程序為了使用具體，採用菜單式的方式來完成程序的演示，幾乎不用輸入什麼特殊的命令，只需按提示輸入表達式即可。（要注意輸入時格式，否者可能會引起一些錯誤） 5. 測試數據。
操作集合：
(1)void InitStack1(SqStack1 &S1);//聲明棧建立函數 (2)void InitStack2(SqStack2 &S2);//聲明棧建立函數
(3)void evaluate(SqStack1 &S1,SqStack2 &S2);//確定如何入棧函數 (4)void Push1(SqStack1 &S1,char e);//聲明入棧函數 (5)void Push2(SqStack2 &S2,float e);//聲明入壓棧函數 (6)char GetTop1(SqStack1 &S1);//聲明取棧頂元素函數 (7)float GetTop2(SqStack2 &S2);//聲明取棧頂元素函數 (8)char Pop1(SqStack1 &S1);//聲明出棧函數 (9)float Pop2(SqStack2 &S2);//聲明出棧函數 (10)char Compare(char m,char n);//聲明比較函數
(11)float Operate(float a,char rheta,float b);//聲明運算函數 (12)void DispStack1(SqStack1 &S1);//從棧底到棧頂依次輸出各元素 (13)void DispStack2(SqStack2 &S2);//從棧底到棧頂依次輸出各元素 }ADT SqStack
結構分析:
棧中的數據節點是通過數組來存儲的。因為在C語言中數組是用下標從零開始的，因此我
們在調用他們的數據是要特別注意。指針變數的值要麼為空(NULL)，不指向任何結點；要麼其值為非空，即它的值是一個結點的存儲地址。注意，當P為空值時，則它不指向任何結點，此時不能通過P來訪問結點，否則會引起程序錯誤。如果輸入的數字不符合題目要求，則會產生錯誤結果。
演算法的時空分析：
時間和空間性能分析：時間上，對於含n個字元的表達式，無論是對其進行合法性檢測還是對其進行入棧出棧操作n次，因此其時間復雜度為O(n)。空間上，由於是用數組來存儲輸入的表達式，用棧來存儲運算中的數據和運算符，而棧的本質也用到的數組，數組在定義時必須確定其大小。在不知表達式長度的情況下確定數組的長度確非易事，此時極易造成空間的浪費，因此空間性能不是很好。
⑺ 數據結構課程設計報告 馬的遍歷 麻煩了
//圖的遍歷演算法程序
//圖的遍歷是指按某條搜索路徑訪問圖中每個結點，使得每個結點均被訪問一次，而且僅被訪問一次。圖的遍歷有深度遍歷演算法和廣度遍歷演算法，程序如下：
#include <iostream>
//#include <malloc.h>
#define INFINITY 32767
#define MAX_VEX 20 //最大頂點個數
#define QUEUE_SIZE (MAX_VEX+1) //隊列長度
using namespace std;
bool *visited; //訪問標志數組
//圖的鄰接矩陣存儲結構
typedef struct{
char *vexs; //頂點向量
int arcs[MAX_VEX][MAX_VEX]; //鄰接矩陣
int vexnum,arcnum; //圖的當前頂點數和弧數
}Graph;
//隊列類
class Queue{
public:
void InitQueue(){
base=(int *)malloc(QUEUE_SIZE*sizeof(int));
front=rear=0;
}
void EnQueue(int e){
base[rear]=e;
rear=(rear+1)%QUEUE_SIZE;
}
void DeQueue(int &e){
e=base[front];
front=(front+1)%QUEUE_SIZE;
}
public:
int *base;
int front;
int rear;
};
//圖G中查找元素c的位置
int Locate(Graph G,char c){
for(int i=0;i<G.vexnum;i++)
if(G.vexs[i]==c) return i;
return -1;
}
//創建無向網
void CreateUDN(Graph &G){
int i,j,w,s1,s2;
char a,b,temp;
printf("輸入頂點數和弧數:");
scanf("%d%d",&G.vexnum,&G.arcnum);
temp=getchar(); //接收回車
G.vexs=(char *)malloc(G.vexnum*sizeof(char)); //分配頂點數目
printf("輸入%d個頂點.\n",G.vexnum);
for(i=0;i<G.vexnum;i++){ //初始化頂點
printf("輸入頂點%d:",i);
scanf("%c",&G.vexs[i]);
temp=getchar(); //接收回車
}
for(i=0;i<G.vexnum;i++) //初始化鄰接矩陣
for(j=0;j<G.vexnum;j++)
G.arcs[i][j]=INFINITY;
printf("輸入%d條弧.\n",G.arcnum);
for(i=0;i<G.arcnum;i++){ //初始化弧
printf("輸入弧%d:",i);
scanf("%c %c %d",&a,&b,&w); //輸入一條邊依附的頂點和權值
temp=getchar(); //接收回車
s1=Locate(G,a);
s2=Locate(G,b);
G.arcs[s1][s2]=G.arcs[s2][s1]=w;
}
}
//圖G中頂點k的第一個鄰接頂點
int FirstVex(Graph G,int k){
if(k>=0 && k<G.vexnum){ //k合理
for(int i=0;i<G.vexnum;i++)
if(G.arcs[k][i]!=INFINITY) return i;
}
return -1;
}
//圖G中頂點i的第j個鄰接頂點的下一個鄰接頂點
int NextVex(Graph G,int i,int j){
if(i>=0 && i<G.vexnum && j>=0 && j<G.vexnum){ //i,j合理
for(int k=j+1;k<G.vexnum;k++)
if(G.arcs[i][k]!=INFINITY) return k;
}
return -1;
}
//深度優先遍歷
void DFS(Graph G,int k){
int i;
if(k==-1){ //第一次執行DFS時,k為-1
for(i=0;i<G.vexnum;i++)
if(!visited[i]) DFS(G,i); //對尚未訪問的頂點調用DFS
}
else{
visited[k]=true;
printf("%c ",G.vexs[k]); //訪問第k個頂點
for(i=FirstVex(G,k);i>=0;i=NextVex(G,k,i))
if(!visited[i]) DFS(G,i); //對k的尚未訪問的鄰接頂點i遞歸調用DFS
}
}
//廣度優先遍歷
void BFS(Graph G){
int k;
Queue Q; //輔助隊列Q
Q.InitQueue();
for(int i=0;i<G.vexnum;i++)
if(!visited[i]){ //i尚未訪問
visited[i]=true;
printf("%c ",G.vexs[i]);
Q.EnQueue(i); //i入列
while(Q.front!=Q.rear){
Q.DeQueue(k); //隊頭元素出列並置為k
for(int w=FirstVex(G,k);w>=0;w=NextVex(G,k,w))
if(!visited[w]){ //w為k的尚未訪問的鄰接頂點
visited[w]=true;
printf("%c ",G.vexs[w]);
Q.EnQueue(w);
}
}
}
}
//主函數
void main(){
int i;
Graph G;
CreateUDN(G);
visited=(bool *)malloc(G.vexnum*sizeof(bool));
printf("\n廣度優先遍歷: ");
for(i=0;i<G.vexnum;i++)
visited[i]=false;
DFS(G,-1);
printf("\n深度優先遍歷: ");
for(i=0;i<G.vexnum;i++)
visited[i]=false;
BFS(G);
printf("\n程序結束.\n");
}
輸出結果為（紅色為鍵盤輸入的數據，權值都置為1）：
輸入頂點數和弧數:8 9
輸入8個頂點.
輸入頂點0:a
輸入頂點1:b
輸入頂點2:c
輸入頂點3:d
輸入頂點4:e
輸入頂點5:f
輸入頂點6:g
輸入頂點7:h
輸入9條弧.
輸入弧0:a b 1
輸入弧1:b d 1
輸入弧2:b e 1
輸入弧3:d h 1
輸入弧4:e h 1
輸入弧5:a c 1
輸入弧6:c f 1
輸入弧7:c g 1
輸入弧8:f g 1
廣度優先遍歷: a b d h e c f g
深度優先遍歷: a b c d e f g h
程序結束.
⑻ 數據結構課程設計分析報告
我有份數據結構的課程設計報告已經發到你郵箱，請參考下吧，以下是代碼部分
課程設計步驟簡介
1.系統架構建模以及工具的選擇
利用Microsoft Visio建模工具規劃GUI，為後面的工具選擇提供參照（如下圖所示）。
2．調試核心排序演算法
2．1插入排序演算法
private void insertSort(int a[]){ //插入排序演算法
for(int i=1;i<a.length;i++)
for(int j=0;j<i;j++) //查找插入位置
{ if(a[j]>a[i])
{int t=a[i];
for(int k=i;k>j;k--) //移動
a[k]=a[k-1];
a[j]=t;
}
}
}
2.2冒泡排序演算法
private void bubbleSort(int[] shuzu) {
for(int j=0;j<shuzu.length-1;j++)
for(int i=0;i<(shuzu.length-1)-j;i++)
if(shuzu[i]>shuzu[i+1]) //升序排序
{int temp=shuzu[i]; shuzu[i]=shuzu[i+1]; shuzu[i+1]=temp;} //交換
}
2.3快速排序演算法
private void quickSort(int a[],int left,int right) {
if(left<right)
{
int point=quick(a,left,right);
quickSort(a,point+1,right); //分割點右邊排序
quickSort(a,left,point-1); //分割點左邊排序
}
}
private static int quick(int[] arr,int left,int right){
int i,j,point,temp;
int[] array = arr; i=left; j=right;
point=array[left];//設置分割點
while(i<j) {
while(i<j&&array[j]>=point) //左移
{ --j; }
array[i]=array[j];
while(i<j&&array[i]<=point) //右移
{ ++i; }
array[j]=array[i];
} //換回分割點
array[i]=point;
return j;
}
2.4選擇排序演算法
private void choseSort(int a[]) {
int min,temp, len=a.length;
for (int i=0;i<len-1 ;i++ )
{
min=i;
for (int j=i+1;j<len ;j++ )
if(a[j]<a[min]) min=j;
if(min!=i) //最值是否有變化
{temp=a[i]; a[i]=a[min];a[min]=temp; }
}
}
2.5 合並排序演算法
private void mergeSort(int a[],int p,int r) {
int q;
if(p!=r)
{ //若子序列A中不止一個元素
q=(int)((p+r-1)/2); //計算中間下標,將子序列A分為左子序列和右子序列
mergeSort(a,p,q); //對左子序列進行合並排序
mergeSort(a,q+1,r); //對右子序列進行合並排序
merge(a,p,q,r); //對左子序類和右子序列進行合並
}
}
private void merge(int z[],int p,int q,int r)
{ int temp1[]=new int[z.length];
int i,j,t;
t=p; //序列temp1的下標計數器,從p開始
i=p; //左子序A[P..Q]的下標計數器,從p開始
j=q+1; //右子序A[Q+1..R]的下表計數器,從q+1開始
//合並序列
while(t<=r)
if(i<=q&&(j>r||z[i]<=z[j]))
temp1[t++]=z[i++];
else
temp1[t++]=z[j++];
//將temp1中的序列賦值給A
for(i=p;i<=r;i++)
z[i]=temp1[i];
}
2.6二分插入排序演算法
private void halfSort(int[] a) {
for (int i=1;i<a.length ;i++ )
{
int left=0,right=i-1;
int temp=a[i];
while(left<=right)
{
int middle=(left+right)/2;
if(temp<a[middle])
right=middle-1;
else
left=middle+1;
}
for(int j=i-1;j>=left;j--)
a[j+1]=a[j];
a[left]=temp;
} }
3. 設計常產生隨機數的演算法
public int[] randdata(){
int choice=jComboBox1.getSelectedIndex();
int index[]={100,500,1000,5000};
int[] data=new int[index[choice]];
java.util.Random r=new java.util.Random(); //利用java產生隨機數的函數
switch(choice){ //產生的隨機數在0-4999之間
case 0: {
for(int i=0;i<100;i++) //產生100個隨機數組
data[i]=Math.abs(r.nextInt())%5000; break;
}
case 1: {
for(int i=0;i<500;i++) //產生500個隨機數組
data[i]=Math.abs(r.nextInt())%5000; break;
}
case 2: {
for(int i=0;i<1000;i++) //產生1000個隨機數組
data[i]=Math.abs(r.nextInt())%5000; break;
}
case 3: {
for(int i=0;i<5000;i++) //產生5000個隨機數組
data[i]=Math.abs(r.nextInt())%5000;
} }// end swhitch
return data; //回傳產生的隨機數組
⑼ 演算法課程設計報告
題目中要求的功能進行敘述分析，並且設計解決此問題的數據存儲結構，（有些題目已經指定了數據存儲的，按照指定的設計），設計或敘述解決此問題的演算法，描述演算法建議使用流程圖，進行演算法分析指明關鍵語句的時間復雜度。
給出實現功能的一組或多組測試數據，程序調試後，將按照此測試數據進行測試的結果列出來 。
對有些題目提出演算法改進方案，比較不同演算法的優缺點。
如果程序不能正常運行，寫出實現此演算法中遇到的問題，和改進方法；
2 對每個題目要有相應的源程序（可以是一組源程序，即詳細設計部分）：
源程序要按照寫程序的規則來編寫。要結構清晰，重點函數的重點變數，重點功能部分要加上清晰的程序注釋。
程序能夠運行，要有基本的容錯功能。盡量避免出現操作錯誤時出現死循環；
3 最後提供的主程序可以象一個應用系統一樣有主窗口，通過主菜單和分級菜單調用課程設計中要求完成的各個功能模塊，調用後可以返回到主菜單，繼續選擇其他功能進行其他功能的選擇。最好有窗口展示部分。
4 課程設計報告：（保存在word 文檔中，文件名要求 按照"姓名-學號-課程設計報告"起名，如文件名為"張三-001-課程設計報告".doc ）按照課程設計的具體要求建立的功能模塊，每個模塊要求按照如下幾個內容認真完成；
其中包括:
a)需求分析：
在該部分中敘述，每個模塊的功能要求
b)概要設計
在此說明每個部分的演算法設計說明（可以是描述演算法的流程圖），每個程序中使用的存儲結構設計說明（如果指定存儲結構請寫出該存儲結構的定義。
c）詳細設計
各個演算法實現的源程序，對每個題目要有相應的源程序（可以是一組源程序，每個功能模塊採用不同的函數實現）
源程序要按照寫程序的規則來編寫。要結構清晰，重點函數的重點變數，重點功能部分要加上清晰的程序注釋。
d）調試分析
測試數據，測試輸出的結果，時間復雜度分析，和每個模塊設計和調試時存在問題的思考（問題是哪些？問題如何解決？），演算法的改進設想。
5. 課設總結： （保存在word 文檔中）總結可以包括 : 課程設計 過程的收獲、遇到問題、遇到問題解決問題過程的思考、程序調試能力的思考、對數據結構這門課程的思考、在課程設計過程中對C課程的認識等內容；
6.實驗報告的首頁請參考如下格式：
課程設計實驗
起止日期:20 -20 學年 學期
系別 班級 學號 姓名
實驗題目 □設計性 □綜合性
自我評價
教師評語 能夠實現實驗要求的功能 □全部 □部分演算法有新意 □有 □一般程序運行通過 □全部 □部分 演算法注釋說明 □完善 □僅有功能說明介面參數說明 □有 □無按期上交列印文檔資料及源程序 □所有 □部分綜合設計說明報告結構 □合理 □不合理用戶使用說明 □完整 □不全現場演示操作有準備 □有 □無問題解答流暢 □流暢 □不流暢獨立完成實驗 □能 □不能體現團隊合作精神。 □能夠 □不能
成績
這是張表格，過來時沒調整好，不過應該看得明白。我們是這樣寫的，你可以參考一下。