⑴ 数据结构课程设计报告
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 学年 学期
系别 班级 学号 姓名
实验题目 □设计性 □综合性
自我评价
教师评语 能够实现实验要求的功能 □全部 □部分算法有新意 □有 □一般程序运行通过 □全部 □部分 算法注释说明 □完善 □仅有功能说明接口参数说明 □有 □无按期上交打印文档资料及源程序 □所有 □部分综合设计说明报告结构 □合理 □不合理用户使用说明 □完整 □不全现场演示操作有准备 □有 □无问题解答流畅 □流畅 □不流畅独立完成实验 □能 □不能体现团队合作精神。 □能够 □不能
成绩
这是张表格，过来时没调整好，不过应该看得明白。我们是这样写的，你可以参考一下。