计算器数据结构课程设计报告

❶ 数据结构的课程设计报告要怎么写啊

晕/////真麻烦。。。。。

数据结构实习报告规范

实习报告的开头应给出题目、班级、姓名、学号和完成日期，并包括以下七个内容：

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）主程序模块：

❷ 数据结构课程设计~ 求报告+代码~

分吧。

❸ 求数据结构课程设计 算数表达式报告及C语言源代码

ok 目标已完成

❹ 数据结构课程设计分析报告

这个我也提问过 就是没人给回复。。。祝楼主好运吧

❺ 求一份数据结构课程设计报告

//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; //指针置空

}

你的要求太多 ， 没仔细看， 我把我给别人写的赋值给你吧 ， 我已经写的很全了，程序有问题可以给我留言

❻ 数据结构课程设计报告（一元多项式的计算）

#include "stdafx.h"
#include "iostream"
using namespace std;
#define MAXSIZE 10
typedef struct
{
int xi;
int ;
}DataType;
typedef struct node
{
DataType data[MAXSIZE];
int length;
}Dx,*PDx;
PDx Init_List()
{
Dx *S;
S=(Dx *)malloc(sizeof(Dx));
if(S)
S->length=0;
return S;
}
int Empty(Dx *S)
{
if(S->length==0)
return 1;
else return 0;
}
int In_list(Dx *S,DataType a)//建立多项式存储结构
{
if(S&&S->length<MAXSIZE)
{
S->length++;
S->data[S->length-1]=a;
return 1;
}
else return 0;
}
int Insert_list(Dx *S,int j,DataType e)//插入
{
if(S&&S->length<MAXSIZE)
{
S->length++;
for(int i=S->length-1;i>j;i--)
S->data[i]=S->data[i-1];
S->data[j]=e;
return 1;
}
else return 0;
}
int Delete_list(Dx *S,int m)//m就是数组下标
{
if(!S)
{
cout<<"多项式不存在！"<<endl;
return -1;
}
if(m<1||m>S->length)
{
cout<<"删除位置不合法！"<<endl;
return 0;
}
for(int j=m;j<S->length;j++)
S->data[j-1]=S->data[j];
S->length--;
return 1;
}
PDx Luru(int n)//录入多项式，并存储起来,n为多项式的项数！
{
Dx *S;
S=Init_List();
DataType e;
cout<<"按从高指数到低指数，输入一元多项式的系数和指数；"<<endl;
for(int i=0;i<n;i++)
{
cout<<"指数：";
cin>>e.;
if((S->length-1>=0&&e.>=S->data[S->length-1].)||e.<0)
{
i--;
cout<<"输入指数大于前一项错误请重输或小于0！"<<endl;
continue;
}
cout<<"系数：";
cin>>e.xi;
In_list(S,e);
}
return S;
}
void print(Dx *S)
{
for(int i=0;i<S->length;i++)
{
if(i>0&&S->data[i].xi>=0)
cout<<"+";
cout<<S->data[i].xi<<"X^"<<S->data[i].;
}
cout<<endl;
}
PDx Add(Dx *S1,Dx *S2)
{
Dx *S3;
S3=Init_List();
for(int x=0;x<S1->length;x++)
{
S3->length++;
S3->data[S3->length-1]=S1->data[x];
}
for(int i=0;i<S2->length;i++)
{ for(int j=0;j<S3->length;j++)
{
if(S2->data[i].==S3->data[j].)
{
S3->data[j].xi+=S2->data[i].xi;
break;
}
else if(S2->data[i].>S3->data[j].)
{
Insert_list(S3,j,S2->data[i]);
break;
}
}
if(S2->data[i].<S3->data[S3->length-1].)
{
In_list(S3,S2->data[i]);
}
}
return S3;
}
PDx Sub(Dx *S1,Dx *S2)//S1-S2
{
Dx *S3;
S3=Init_List();
DataType e;
for(int x=0;x<S1->length;x++)
{
S3->length++;
S3->data[S3->length-1]=S1->data[x];
}
for(int i=0;i<S2->length;i++)
{ for(int j=0;j<S3->length;j++)
{
if(S2->data[i].==S3->data[j].)
{
S3->data[j].xi-=S2->data[i].xi;
if(S3->data[j].xi==0)
Delete_list(S3,j+1);
break;
}
else if(S2->data[i].>S3->data[j].)
{
e=S2->data[i];
e.xi=-1*e.xi;
Insert_list(S3,j,e);
break;
}
}
if(S2->data[i].<S3->data[S3->length-1].)
{
e=S2->data[i];
e.xi=-1*e.xi;
In_list(S3,e);
}
}
return S3;
}
PDx Bin(Dx *S1,Dx *S2)
{
Dx *S3;
S3=Init_List();
DataType e,a;
a.xi=0;
a.=0;
In_list(S3,a);
for(int i=0;i<S1->length;i++)
for(int j=0;j<S2->length;j++)
{
e.xi=S1->data[i].xi*S2->data[j].xi;
e.=S1->data[i].*S2->data[j].;
for(int k=0;k<S3->length;k++)
{
if(e.==S3->data[k].)
{
S3->data[k].xi+=S2->data[j].xi;
break;
}
else if(e.>S3->data[k].)
{
Insert_list(S3,k,e);
break;
}
if(S3->length-2>=0&&e.<S3->data[S3->length-2].)
{
Insert_list(S3,S3->length-1,e);
}
}
}
return S3;
}

int _tmain(int argc, _TCHAR* argv[])
{
Dx *S1,*S2,*S3,*S4,*S5;
int i,j;
cout<<"要录入的1多项式项数:";
cin>>i;
S1=Luru(i);
cout<<"要录入的2多项式项数:";
cin>>j;
S2=Luru(j);
S3=Add(S1,S2);
S4=Sub(S1,S2);
S5=Bin(S1,S2);
cout<<"第一个多项式:"<<endl;
print(S1);
cout<<"第二个多项式:"<<endl;
print(S2);
cout<<"两多项式的和:"<<endl;
print(S3);
cout<<"两多项式的差"<<endl;
print(S4);
cout<<"两多项式的积"<<endl;
print(S5);
return 0;
}