2024数据结构报告

09-22

我们听了一场关于“数据结构报告”的演讲让我们思考了很多，平常学习工作中。很多时候我们都需要去写一份报告，将结果整理成报告对我们来说更便于阅读和理解，撰写报告时我们可以从哪些角度着手？经过阅读本页你的认识会更加全面。

数据结构报告 篇1

数据结构报告

引言：

数据结构是计算机科学的一个基础概念，它涉及组织和管理数据的方法和原则。在计算机科学领域，数据结构是一种将数据元素组织为不同形式的数据集合的方法。本报告将介绍数据结构的重要性、主要类型、应用领域以及未来的发展趋势。

一、数据结构的重要性：

数据结构对于计算机科学至关重要。在计算机程序中，数据的组织和存储方式直接影响程序的效率和可维护性。良好的数据结构可以提供高效的数据访问和操作，从而提高程序的执行效率。此外，数据结构还能够帮助开发人员理清程序中各个数据元素之间的关系，提供良好的逻辑结构，使得程序的开发、维护和扩展更加容易。

二、主要类型：

数据结构主要分为线性结构、树结构和图结构三类。

1. 线性结构：包括数组、链表、栈和队列等。数组是一种静态线性结构，具有连续的存储空间，适合随机访问；链表是一种动态线性结构，存储空间可以动态分配，适合插入和删除操作；栈是一种先进后出（LIFO）的线性结构；队列是一种先进先出（FIFO）的线性结构。

2. 树结构：包括二叉树、AVL树、红黑树等。树结构由节点和边组成，每个节点可以有多个子节点。二叉树是一种特殊的树结构，每个节点最多只有两个子节点。

3. 图结构：由节点和边组成，节点之间可以有多条边相连。图结构可以分为有向图和无向图，有向图中的边有方向，无向图中的边没有方向。

三、数据结构的应用领域：

数据结构在计算机科学的各个领域都有广泛应用。

1. 数据库系统：数据结构用于组织和管理数据库中的数据，包括数据表、索引、视图等。

2. 算法设计和分析：数据结构是设计和实现高效算法的基础，不同的数据结构适用于不同的算法问题。

3. 操作系统：数据结构用于管理操作系统中的进程、文件系统和内存等。

4. 网络和图像处理：数据结构可以用于网络路由算法和图像压缩等应用。

5. 人工智能：数据结构在机器学习和深度学习等领域有重要作用。

四、数据结构的发展趋势：

随着计算机科学的不断发展，数据结构也在不断演进和创新。

1. 高性能数据结构：为了提高程序的执行效率，研究人员致力于设计高性能的数据结构，如哈希表、跳表等。

2. 大数据处理：随着大数据时代的到来，数据结构需要能够处理海量的数据，如分布式哈希表、B树等。

3. 数据隐私与安全：在数据共享和隐私保护中，数据结构需要具备安全性，如保护数据的隐私和防止数据泄露。

4. 学科交叉融合：数据结构与其他学科的交叉融合也是未来的发展方向，如数据结构与人工智能、数据结构与生物学等领域的结合。

结论：

数据结构作为计算机科学的基础概念，对于程序的性能和可维护性至关重要。通过良好的数据结构设计，我们可以提高程序的效率，并且使得程序的开发、维护和扩展更加容易。随着计算机科学的发展，数据结构也在不断演变和创新，满足不同应用领域和需求。因此，深入理解和掌握数据结构的原理和应用是每一个计算机科学从业者所必备的基本素质。

数据结构报告 篇2

问题描述：;四则运算表达式求值，将四则运算表达式用中缀表达式;一、需求分析：;输入输出格式：;输入格式：在字符界面上输入一个中缀表达式，回车表;请输入表达式：;输入一个中缀表达式;输出格式：如果该中缀表达式正确，那么在字符界面上;式，其中后缀表达式中两相邻操作数之间利用空格隔开;果不正确，在字符界面上输出

问题描述：

四则运算表达式求值，将四则运算表达式用中缀表达式，然后转换为后缀表达式，并计算结果。

一、 需求分析：

1、本程序是利用二叉树后序遍历来实现表达式的转换，同时可以使用实验三的结果来求解后缀表达式的值。

2、输入输出格式：

输入格式：在字符界面上输入一个中缀表达式，回车表示结束。

请输入表达式：

输入一个中缀表达式

输出格式：如果该中缀表达式正确，那么在字符界面上输出其后缀表达

式，其中后缀表达式中两相邻操作数之间利用空格隔开;如

果不正确，在字符界面上输出表达式错误提示。

逆波兰表达式为：

3、测试用例

输入：21+23*(12-6)

输出：21 23 12 6 -*+ 输出逆波兰表达式 运算结果为：输出运算后的结果

二、概要设计 ：

抽象数据类型

二叉树类BiTree

算法的基本思想

根据题目要求，利用栈计算，和二叉树存储，来计算表达式

该算法的基本思想是：

先利用栈进行计算，然后用二叉树进行存储，和实验三算法一样来计算逆波兰表达式的值

程序的流程

程序由三个模块组成：

(1) 输入模块：输入一个运算式

(2) 计算模块：利用栈进行表达式的计算，二叉树来存储。 (3 ) 输出模块：屏幕上显示出后缀表达式和运算结果。

三、详细设计

物理数据类型

程序含有两个类，其中栈不再赘述，另一个类为二叉树class BiTree包含私有成员struct BiTreeNode，根节点BiTreeNode *T;索引index; int number_of_point 优先级比较函数 compare(char a,char b);生成树的函数void InorderCreate(BiTreeNode *&T,char str[30][10],int start,int end);判断数字函数bool IsNumber(char a);求值函数double Operate(BiTreeNode *T);还有显示后缀表达式的函数void display(BiTreeNode *T) ;而公有成员函数则是对私有函数的重载，为方便使用，因为函数中普遍使用了递归的算法。

算法的时空分析

此算法利用栈和二叉树来实现，故次算法的的时间复杂度为(N)。

输入和输出的格式

输入格式：请输入表达式：

输入一个中缀表达式 //回车

输出格式：逆波兰表达式为：

输出逆波兰表达式

运算结果为：输出运算后的结果

四、调试分析

略。

五、测试结果

本实验的测试结果截图如下：

六、用户使用说明(可选)

运行程序时

提示输入表达式

本程序可以将中缀表达式转换为后缀表达式后在计算出运算式的结果。 提示：请输入表达式：

输出

提示：逆波兰表达式为：

运算结果：

七、实验心得(可选)

本次实验过程比较复杂，由于书上的`知识掌握的还不是很牢靠，所以现在实验做起来有点儿吃力。本实验主要是通过与同学的讨论和课后查阅资料来完成的，虽然有些地方还不是很懂，但基本上能完成此次实验的内容。而且通过本次实验，加深了对二叉树算法的了解。

附录(实验代码)：

#include

#include

#include

#include

#include

#include

#define STACK_INIT_SIZE 100

#define DATA_SIZE 10

#define STACKINCREMENT 10

#define OK 1

#define TRUE 1

#define FALSE 0

#define ERROR 0

#define OVERFLOW -2

using namespace std;

typedef float SElemtype;

typedef int Status;

typedef char * TElemType;

typedef struct BiTNode {

TElemType data;

int len; //data字符串中字符的个数

struct BiTNode * lchild, * rchild;

}BiTNode, *BiTree;

typedef struct

{

SElemtype *base;

SElemtype *top;

int stacksize;

} SqStack;

Status IsDigital(char ch)

{ if(ch>='0'&&ch

{return 1; //是数字字母

}

return 0; //不是数字字母

}

int CrtNode(stack &PTR, char *c)

{

BiTNode * T;

int i=0;

T = (BiTNode *)malloc(sizeof(BiTNode));

T->data = (char *)malloc(DATA_SIZE*sizeof(char));

while(IsDigital(c[i]))

{T->data [i] = c[i];

i++; }

T->len = i;

T->lchild = T->rchild = NULL;

PTR.push (T);

return i;

}

void CrtSubTree(stack &PTR, char c)

{BiTNode * T;

T = (BiTNode *)malloc(sizeof(BiTNode));

T->data = (char *)malloc(DATA_SIZE*sizeof(char));

T->data [0] = c;

T->len = 1;

T->rchild = (); //先右子树，否则运算次序反了

PTR.pop ();

T->lchild = ();

PTR.pop ();

PTR.push (T);

}

char symbol[5][5]={{'>', '>', ''}, //符号优先级

{'>', '>', ''},

{'>', '>', '>', '>', '>'},

{'>', '>', '>', '>', '>'},

{'

int sym2num(char s) //返回符号对应优先级矩阵位置 { switch(s)

{

case '+': return 0; break;

case '-': return 1; break;

case '*': return 2; break;

case '/': return 3; break;

case '#': return 4; break;

}

}

char Precede(char a, char b) //返回符号优先级

{return(symbol[sym2num(a)][sym2num(b)]);}

void CrtExptree(BiTree &T, char exp[])

{ //根据字符串exp的内容构建表达式树T

stack PTR;//存放表达式树中的节点指针

stack OPTR;//存放操作符

char op;

int i=0;

OPTR.push ('#');

op = ();

while( !((exp[i]=='#') && (()=='#')) ) //与

{

if (IsDigital(exp[i]))

{//建立叶子节点并入栈 PTR

i+=CrtNode(PTR, &exp[i]);

}

else if (exp[i] == ' ')

i++;

else{

switch (exp[i])

{

case '(': {

OPTR.push (exp[i]);

i++;

break;}

case ')': {

op = (); OPTR.pop ();

while(op!='('){

CrtSubTree(PTR, op);

op = (); OPTR.pop ();

数据结构报告 篇3

设计题目：模拟计算器程序

学生姓名：谢先斌

系 别：计算机与通信工程学院

专 业：计算机科学与技术

班 级：1班

学 号：541007010144

指导教师：卢冰 李晔

2012 年 6 月 21 日

郑州轻工业学院

课 程 设 计 任 务 书

题目 模拟计算器程序

专业、班级 计算机科学与技术10-01班 学号 541007010144 姓名 谢先斌

主要内容：

设计一个模拟计算器的程序，要求能对包含加、减、乘、除、括号运算符及SQR和ABS函数的任意整型表达式进行求解。

基本要求：

要检查有关运算的条件，并对错误的条件产生报警。

主要参考资料：

[第52页3.2.5表达式求值

完 成 期 限： 2012年6月21日

指导教师签名：

课程负责人签名：

2012年 6月 21 日

一、 设计题目

模拟计算器的程序

设计一个模拟计算器的程序，要求能对包含加、减、乘、除、括号运算符及SQR和ABS函数的任意整型表达式进行求解。

设计要求：要检查有关运算的条件，并对错误的条件产生报警。

二、 算法设计的思想

本程序设计主要是应用了栈，利用栈的“先进后出”原理，建立了两个栈，分别为运算符栈pOStack和运算数栈pDStack。算法的基本思想(参考课本p53页)是：

(1) 首先置操作数栈为pDStack空栈，表达式起始符为“=”，位运算符栈的栈底元素;

(2) 依次读入表达式中的每个字符，若是操作数则进入pDStack栈，若是运算符则和pOStack栈的栈定运算符比较优先权后作相应操作，直到整个表达式求值完毕(即pOStack栈的栈定元素和当前读入的字符均为“=” )。

三、 算法的流程图

本程序的流程如下附图1所示：

附图1 程序流程图

四、 算法设计分析

首先创建了两个栈：

typedef struct OPStack //定义运算符栈

{

char opStack[MAX_OPERATOR_NUM];

int top;

}OPStack, *pOPStack;

typedef struct DATAStack //定义运算数栈

{

double stack[MAX_DATA_NUM];

int top;

}DATAStack, *pDATAStack;

来分别存放运算符和运算数。在两个结构体中均有一个top数据域，当top=-1时，表示该站为空栈。

定义一个Evaluateexpression_r()函数来完成函数运算的主要功能：读入表达式，并计算结果。以下是对该函数的分析：

当一次运算开始时，分别调用InitpOPStack(pOPStack &pOStack)函数和InitpDATAStack(pDATAStack &pDStack)函数分别对运算符栈和运算数栈进行初始化。调用PushOPStack(pOStack, '=')函数来完成运算符栈栈低元素的设置。

通过PushOPStack(pOPStack &pOStack, char ch)函数、

PopOPStack(pOPStack &pOStack, char &ch)函数、

PushDATAStack(pDATAStack &pDStack, double d)函数和PopDATAStack(pDATAStack &pDStack, double &d)函数来分别完成运算符和运输数的进出栈操作。getToppOPStack(pOPStack &pOStack)函数和getToppDATAStack(pDATAStack &pDStack) 函数主要是进行得到栈定元素的作用，特别是在对运算符栈优先级的比较中十分重要，其中还会调用IsOP(char &ch) 函数来区分读入的是运算符还是运算数。

ChangeChar(char &c)函数当每次读入一个字符是都会调用一次，主要的作用就是完成不用区分A、S的大小的功能。

Precede(char op>、=”结果来进行下一步的操作：''表示运算符和运算数各退栈一次并调用Operate(double a, char theta, double b)函数(主要是对出栈的运算符和运算数进行计算)，最后将运算结果压入运算数栈pDStack。

当操作结束时运算数栈的栈顶元素就是计算结果，分别调用ClearpOPStack(pOStack)函数清空运算符栈、ClearpDATAStack(pDStack)函数清空运算数栈以待下一次继续进行相关操作。

print_user()函数和exit_E()函数开始和结束时个调用一次，分别完成欢迎界面和退出界面的布置。main()是本程序的主函数，主要通过while语句和switch语句来完成本程序的运行，当输入Y(y)时调用Evaluateexpression_r()函数完成计算，当输入N(n)时，调用exit_E()函数退出本程序的运行。

本程序还考虑到各种异常的处理，如运算时除数为0、被开方数为0等情况的出现，最终的处理是直接退出程序的运行。

五、 运行结果分析

1. 程序开始界面，如附图2：

附图2 开始界面

2.如下附图3，附图4分别是选择进入和退出程序界面：

附图3(在以下界面输入计算式即可运行出计算结果如附图5)

附图4 退出界面

附图5 运行界面

2. 对异常的处理

a) 对异常1除数为0，如输入“1+2/0=”程序将直接退出，如附图6：

附图6 异常1除数为0

b) 对异常2被开方数为负数，如输入“3+S(-9)=”程序将直接退出，如附图7：

附图7 异常2被开方数为负数

3.以下是对各种简单运算的运行结果，如附图8：

附图8 简单运算

3. 综合运算：如式子“1/2+A(7-8)-S(9*8)=”运行结果如附图9

附图9 综合运算

六、 收获及体会

本程序以C语言的栈的相关知识为基础，通过控制两个栈(运算数栈和运算符栈)的进出的栈操作，来实现对包含加、减、乘、除、括号运算符及SQRT和ABS函数的任意整型表达式的求解运算。

从程序的编写来看，感觉这次自己真的学到了好多，特别是对程序的开发流程。从最初的选定程序，到最终的程序运行成功，让我感到如果是仅仅掌握课本上的知识是远远不能够很好的应用到实际的编程中去的。在这个过程中还需要我们更多的去考虑到实际条件的种种限制和约束。

我在写本程序的过程中也遇到了很多的问题，当然本程序的.核心问题就是对两个栈的压出栈操作，需要做优先级判断，并要考虑什么时候进栈，什么时候出栈等操作。我采用了课本上第()AS=”共被开方数小于N、A、S等字符也进行了改进，最终本程序可以不区分大小写就完成相关操作。

总之，经过本次专业课程设计，让我掌握了开发应用软件的基本流程，运用所学编程技能的基本技巧，也让我初步了解了软件设计的基本方法，提高进行工程设计的基本技能及分析、解决实际问题的能力，为以后毕业设计和工程实践等打下良好的基础。相信通过这次的课程设计，我对所学的《数据结构(C语言版)》和各种编程语言都有了一个全新的认识。我也会积极吸取本次课程设计的经验，继续研究数据结构和所学的各种编程语言。

七、 源代码

# include

# include

# include

# include

# define MAX_OPERATOR_NUM 100 //运算符栈数组长度

# define MAX_DATA_NUM 100 //运算数栈数组长度

typedef struct OPStack //定义运算符栈

{

char opStack[MAX_OPERATOR_NUM];

int top;

}OPStack, *pOPStack;

typedef struct DATAStack //定义运算数栈

{

double stack[MAX_DATA_NUM];

int top;

}DATAStack, *pDATAStack;

void InitpOPStack(pOPStack &pOStack) //初始化运算符栈

{

if( !(pOStack = (pOPStack)malloc(sizeof(OPStack)))) //为运算符栈分配空间

{

printf("分配内存空间失败! ");

exit(-1);

}

pOStack->top = -1;

}

void InitpDATAStack(pDATAStack &pDStack) //初始化运算数栈

{

if( !(pDStack = (pDATAStack)malloc(sizeof(DATAStack)))) //为运算数栈分配空间

{

printf("分配内存空间失败! ");

exit(-1);

}

pDStack->top = -1;

}

void PushOPStack(pOPStack &pOStack, char ch) //运算符进栈

{

pOStack->opStack[++(pOStack->top)] = ch;

}

void PopOPStack(pOPStack &pOStack, char &ch) //运算符出栈

{

ch = pOStack->opStack[pOStack->top];

pOStack->top--;

}

void PushDATAStack(pDATAStack &pDStack, double d) //运算数进栈

{

++(pDStack->top);

pDStack->stack[pDStack->top] = d;

}

void PopDATAStack(pDATAStack &pDStack, double &d) //运算数出栈

{

d = pDStack->stack[pDStack->top];

pDStack->top--;

}

void ClearpOPStack(pOPStack &pOStack) //清空运算符栈

{

pOStack->top = -1;

}

void ClearpDATAStack(pDATAStack &pDStack) //清空运算数栈

{

pDStack->top = -1;

}

char GetToppOPStack(pOPStack &pOStack) //获取运算符栈顶元素

{

return pOStack->opStack[pOStack->top];

}

double GetToppDATAStack(pDATAStack &pDStack) //获取运算数栈顶元素

{

return pDStack->stack[pDStack->top];

}

bool IsOP(char &ch) //区分 运算符 和 运算数 的函数，是运算符时返回true,否则返回false

{ //判断是否为符号

if ( (ch == '+') || (ch == '-') || (ch == '*') || (ch == '/') || (ch == '=') || (ch == 'A') || (ch == 'S') || (ch == 'a') || (ch == 's') || (ch == '(') || (ch == ')') )

return true;

else

return false;

}

char Precede(char op1, char op2) //参考《数据结构》(C语言版)第53页 3.2.5表达式求值 表 3.1

{

char tab[9][10]; //定义字符串的二维数组来存放运算符优先级的关系

strcpy( tab[0], ">>" );

strcpy( tab[1], ">>" );

strcpy( tab[2], ">>>>" );

strcpy( tab[3], ">>>>" );

strcpy( tab[4], "

strcpy( tab[5], ">>>>E>>>>" );

strcpy( tab[6], ">>>>>>>" );

strcpy( tab[7], ">>>>>>>" );

strcpy( tab[8], "

printf(" | ***欢迎您的下次使用!谢谢!!!*** | "); //退出使用

printf(" |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~| ");

}

double Operate(double a, char theta, double b) //对出栈的运算符和运算数进行计算

{

double s;

switch(theta)

{

case '+':

s = a + b;

break;

case '-':

s = a - b;

break;

case '*':

s = a * b;

break;

case '/':

if ( b != 0 ) //判断除数是否为0，若为0，退出程序

{

s = a/b;

break;

}

else

{

printf(" #### 除数为0，非法运算。程序终止! #### ");

exit_E(); //打印结束菜单

exit(-1);

}

case 'A':

s = fabs(b); //调用FABS()函数

break;

case 'S':

if( b >= 0) //判断被开方数是否为0，若为0，退出程序

{

s = sqrt(b); //调用SQRT()函数

break;

}

else

{

printf(" #### 求负数的平方根是非法运算。程序终止! #### ");

exit_E(); //打印结束菜单

exit(-1);

}

}

return s;

}

char ChangeChar(char &c) //通过ChangeChar函数来把a、s的小写字母改为大写的

{

if( c == 'a' )

c = 'A';

else if( c == 's' )

c = 'S';

return c;

}

//参考《数据结构》(C语言版)第53页 3.2.5表达式求值算法3.4 Evaluateexpression_r()函数

void Evaluateexpression_r() //计算函数：读入表达式，并计算结果

{

pOPStack pOStack; //声明运算符栈

pDATAStack pDStack; //声明运算数栈

double result; //存运算的结果

char x, theta, c; //c存放读取的字符,x、theta存放运算符栈的栈顶元素

int flag, data; //标识符，用来读入连续的数字

double s;

double getd; //存放GetTop***的结果

double a, b, cc; //a,b存放数据栈出栈的栈顶元素, c存放运算结果

flag = 0; //初始化标识符，用来判断字符串中的连续数字

data = 0; //

InitpOPStack(pOStack); //初始化运算符栈

InitpDATAStack(pDStack); //初始化运算数栈

PushOPStack(pOStack, '='); //在运算符栈底放入'='

printf(" &请输入表达式以'='结束：");

c = get); //读入字符

ChangeChar(c); //通过调用函数来实现把小写的a、s改为大写的A、S

while( c != '=' || GetToppOPStack(pOStack) != '=')

{

if( !IsOP(c) ) //不是运算符进栈

{

s = c - '0'; //把字符转化为数字

if ( flag == 1 )

{

PopDATAStack(pDStack, getd);

s = getd*10 + s;

}

PushDATAStack(pDStack, s);

flag = 1;

c = get);

ChangeChar(c);

}

else

{

flag = 0;

switch( Precede(GetToppOPStack(pOStack), c) ) //输入元素和运算符栈顶元素比较

{

case '

PushOPStack(pOStack, c);

c = get);

ChangeChar(c);

break;

case '=': //托括号并接受下一个字符

PopOPStack(pOStack, x);

c = get);

ChangeChar(c);

break;

case '>': //退栈并将运算结果进栈

PopOPStack(pOStack, theta);

PopDATAStack(pDStack, b);

PopDATAStack(pDStack, a);

cc = Operate(a, theta, b);

PushDATAStack(pDStack, cc);

break;

}//switch

}//else

}//while

result = GetToppDATAStack(pDStack); //运算结束时，运算数栈的栈底元素就是计算结果

ClearpOPStack(pOStack); //清空运算符栈

ClearpDATAStack(pDStack); //清空运算数栈

printf(" ->计算结果为：%.2f ", result); //输出运算结果

return ;

}

void print_user() //欢迎界面

{

printf(" 欢迎使用C语言版模拟计算器 ");

printf("************************************************************************ ");

printf(" |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~| ");

printf(" | 模拟计算器使用说明 | ");

printf(" | 作者：谢先斌 | ");

printf(" | 本程序包括对'+'、'-'、'*'、'/'、'()'的运算 | ");

printf(" | 本程序中ABS()算用A()替代、SQRT()运算用S()代替 | ");

printf(" | 本程序中的一切字母均不区分大小写 | ");

printf(" 正确的表达式如：1+A(7-8)+S(9*8)= ");

printf(" | 输入'='表示表达式输入结束!! | ");

printf(" | 欢迎使用!!!-->--> | ");

printf(" |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~| ");

printf("************************************************************************ ");

}

int main() //主函数

{

char in;

bool b; //标识符，用来标识是否结束程序

b = true; //初始化，不结束

print_user(); //打印欢迎界面

printf(" *请确认使用计算器Y/N:");

while(1)

{

scanf("%c", &in); //确认是否继续操作

get); //吃掉会车，避免干扰

switch(in)

{

case 'Y':

case 'y':

{

Evaluateexpression_r(); //进入计算函数：读入表达式，并计算结果

break;

}

case 'N':

case 'n':

{

exit_E();

b = false;

break;

}

//default:

// printf(" **输入错误，请重新输入Y/N:");

// break;

}

if(b==false) //如果 b==false ,退出整个程序

break;

printf(" *您确定要继续使用计算机Y/N:");

get); //用getchar吃掉回车，避免对后续输入中in的干扰

}

数据结构报告 篇4

一、实验目的及要求

1)掌握栈和队列这两种特殊的线性表，熟悉它们的特性，在实际问题背景下灵活运用它们。

本实验训练的要点是“栈”和“队列”的观点;

二、实验内容

1) 利用栈，实现数制转换。

2) 利用栈，实现任一个表达式中的语法检查(选做)。

判队列空、入队列、出队列);

三、实验流程、操作步骤或核心代码、算法片段

顺序栈：

Status InitStack(SqStack &S)

{

S.base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));

if(!S.base)

return ERROR;

=S.base;

S.stacksize=STACK_INIT_SIZE;

return OK;

}

Status DestoryStack(SqStack &S)

{

free(S.base);

return OK;

}

Status ClearStack(SqStack &S)

{

=S.base;

return OK;

}

Status StackEmpty(SqStack S)

{

if(S.base==)

return OK;

return ERROR;

}

int StackLength(SqStack S)

{

return -S.base;

}

Status GetTop(SqStack S,ElemType &e)

{

if(-S.base>=S.stacksize)

{

S.base=(ElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemType));

if(!S.base) return ERROR;

=S.base+S.stacksize;

S.stacksize+=STACKINCREMENT;

}

*++=e;

return OK;

}

Status Push(SqStack &S,ElemType e)

{

if(-S.base>=S.stacksize)

{

S.base=(ElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemType));

if(!S.base)

return ERROR;

=S.base+S.stacksize;

S.stacksize+=STACKINCREMENT;

}

*++=e;

return OK;

}

Status Pop(SqStack &S,ElemType &e)

{

if(==S.base)

return ERROR;

e=*--;

return OK;

}

Status StackTraverse(SqStack S)

{

ElemType *p;

p=(ElemType *)malloc(sizeof(ElemType));

if(!p) return ERROR;

p=;

while(p!=S.base)//上面一个...

{

p--;

printf("%d ",*p);

}

return OK;

}

Status Compare(SqStack &S)

{

int flag,TURE=OK,FALSE=ERROR;

ElemType e,x;

InitStack(S);

flag=OK;

printf("请输入要进栈或出栈的元素：");

while((x= getchar)!='#'&&flag)

{

switch (x)

{

case '(':

case '[':

case '{':

if(Push(S,x)==OK)

printf("括号匹配成功! ");

break;

case ')':

if(Pop(S,e)==ERROR || e!='(')

{

printf("没有满足条件 ");

flag=FALSE;

}

break;

case ']':

if ( Pop(S,e)==ERROR || e!='[')

flag=FALSE;

break;

case '}':

if ( Pop(S,e)==ERROR || e!='{')

flag=FALSE;

break;

}

}

if (flag && x=='#' && StackEmpty(S))

return OK;

else

return ERROR;

}

链队列：

Status InitQueue(LinkQueue &Q)

{

Q.front =Q.rear=

(QueuePtr)malloc(sizeof(QNode));

if (!Q.front) return ERROR;

Q.front->next = NULL;

return OK;

}

Status DestoryQueue(LinkQueue &Q)

{

while(Q.front)

{

Q.rear=Q.front->next;

free(Q.front);

Q.front=Q.rear;

}

return OK;

}

Status QueueEmpty(LinkQueue &Q)

{

if(Q.front->next==NULL)

return OK;

return ERROR;

}

Status QueueLength(LinkQueue Q)

{

int i=0;

QueuePtr p,q;

p=Q.front;

while(p->next)

{

i++;

p=Q.front;

q=p->next;

p=q;

}

return i;

}

Status GetHead(LinkQueue Q,ElemType &e)

{

QueuePtr p;

p=Q.front->next;

if(!p)

return ERROR;

e=p->data;

return e;

}

Status ClearQueue(LinkQueue &Q)

{

QueuePtr p;

while(Q.front->next )

{

p=Q.front->next;

free(Q.front);

Q.front=p;

}

Q.front->next=NULL;

Q.rear->next=NULL;

return OK;

}

Status EnQueue(LinkQueue &Q,ElemType e)

{

QueuePtr p;

p=(QueuePtr)malloc(sizeof (QNode));

if(!p)

return ERROR;

p->data=e;

p->next=NULL;

Q.rear->next = p;

Q.rear=p; //p->next 为空

return OK;

}

Status DeQueue(LinkQueue &Q,ElemType &e)

{

QueuePtr p;

if (Q.front == Q.rear)

return ERROR;

p = Q.front->next;

e = p->data;

Q.front->next = p->next;

if (Q.rear == p)

Q.rear = Q.front; //只有一个元素时(不存在指向尾指针)

free (p);

return OK;

}

Status QueueTraverse(LinkQueue Q)

{

QueuePtr p,q;

if( QueueEmpty(Q)==OK)

{

printf("这是一个空队列! ");

return ERROR;

}

p=Q.front->next;

while(p)

{

q=p;

printf("%ddata);

q=p->next;

p=q;

}

return OK;

}

循环队列：

Status InitQueue(SqQueue &Q)

{

Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));

if(!Q.base)

exit(OWERFLOW);

Q.front=Q.rear=0;

return OK;

}

Status EnQueue(SqQueue &Q,QElemType e)

{

if((Q.rear+1)%MAXQSIZE==Q.front)

return ERROR;

Q.base[Q.rear]=e;

Q.rear=(Q.rear+1)%MAXQSIZE;

return OK;

}

Status DeQueue(SqQueue &Q,QElemType &e)

{

if(Q.front==Q.rear)

return ERROR;

e=Q.base[Q.front];

Q.front=(Q.front+1)%MAXQSIZE;

return OK;

}

int QueueLength(SqQueue Q)

{

return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;

}

Status DestoryQueue(SqQueue &Q)

{

free(Q.base);

return OK;

}

Status QueueEmpty(SqQueue Q) //判空

{

if(Q.front ==Q.rear)

return OK;

return ERROR;

}

Status QueueTraverse(SqQueue Q)

{

if(Q.front==Q.rear)

printf("这是一个空队列!");

while(Q.front%MAXQSIZE!=Q.rear)

{

printf("%d

Q.front++;

}

return OK;

}

数据结构报告 篇5

一、实验目的

数据结构是计算机科学与技术中非常重要的一门课程，它研究的是各种各样的数据以及它们在计算机中的存储和操作方式。本次实验旨在通过对不同数据结构的实现与应用，进一步理解和掌握各种数据结构的特点、运算和算法。

二、实验背景

数据结构是计算机科学的重要基石之一，它可以帮助有效地组织和管理数据。实验课程的目的是通过实际操作来加深对数据结构的理解，锻炼的编程技能以及分析和解决实际问题的能力。

三、实验过程

1. 实验环境的准备

本次实验使用的编程语言是C++，需要首先配置好编程环境，安装好相关的开发工具和库文件。

2. 实验数据的准备

在实验开始前，需要准备好不同的数据集，这些数据集可以包括不同类型的数据，例如整数、字符串等。可以从文件中读取数据，或者手动输入数据。

3. 实验数据结构的实现

根据实验要求，需要实现多个数据结构，例如链表、栈、队列、二叉树等。在实现过程中，需要考虑数据结构的初始化、增删改查等基本操作，并且保证数据结构的稳定性和高效性。

4. 实验算法的设计与应用

在实验过程中，需要设计和实现与数据结构相关的算法。例如，在链表中查找指定元素、在二叉树中进行遍历等。这些算法可以通过递归、循环等方式实现，需要根据具体问题来选择最优解。

5. 实验数据的测试与分析

实现完成后，需要针对不同的数据结构和算法进行测试。通过不同规模和类型的数据进行性能测试，分析不同数据结构和算法的运行效率和空间复杂度。并且对实验结果进行详细的分析和总结。

四、实验结果与分析

在本次实验中，基于C++语言实现了链表、栈、队列、二叉树等数据结构，并设计了相关的算法进行测试。通过实验数据的测试与分析，得出了以下：

1. 在数据规模较小的情况下，各个数据结构的性能相差不大，但随着数据规模的增大，链表和队列的性能表现更好。

2. 在需要频繁插入和删除数据的场景中，链表和队列的效率明显高于其他数据结构。

3. 在需要高效搜索和排序的场景中，二叉树的性能最好，具有较快的搜索速度和高效的排序能力。

五、实验总结

通过本次实验，加深了对数据结构的理解和应用，熟练掌握了常见数据结构的实现和算法设计。同时，也发现了不同数据结构在不同场景下的优势和劣势，这将对日后的程序设计和问题解决有着重要的指导作用。

本次实验不仅帮助深入了解了数据结构的原理和应用，还提高了的编程技巧和问题解决能力。实验过程中的一系列操作和思考，都是今后从事软件开发和算法设计必不可少的经验。

数据结构报告 篇6

实验报告;课程名称：数据结构班级：软件工程实验成绩：;实验目的;对队列的理解;对STL中的queue的使用;实验仿真一个网络打印过程;二、实验内容与实验步骤流程图;这个任务队列的测试使用STL队列适配器;具体地说,每一行中包含的信息是

实 验 报 告

课程名称：数据结构 班级：软件工程实验成绩：

1206

实验名称：打印机队列模拟学号：20124848 批阅教师签字：

程序的设计

实验编号：实验一 姓名： 实验日期：2014年5 月 24 日

一、实验目的

对队列的理解

对STL中的queue的使用

实验仿真一个网络打印过程

二、实验内容与实验步骤流程图

这个任务队列的测试使用STL队列适配器。程序要求完成模拟的实现共享打印机。这个打印机使用先进先出队列。仿真是通过读取和处理事件数据文件的`列表。一个有效的数据文件中的每一行包含信息打印作业和提交这份工作的时间。

具体地说,每一行中包含的信息是提交工作的时间(以秒为单位),和在页面的工作长及工作的计算机的名称。在模拟的开始,每个这些事件的每一个应该被程序所读，存储在继承工作负载队列。程序应该通过循环递增计数器或while-loop模拟时间的流逝。程序应该将计数器初始化为零,然后依次增加1秒。当模拟等于当前时间的打印作业的提交时间在工作队列的前面，一个打印作业完成。当这一切发生的时候,从工作队列取出这个事件,然后把它放在另一个队列对象。这个队列对象存储已完成的打印作业。当程序仿真其他的打印工作的时候，这些工作在队列等待。

Win8，Visual C++ 6.0

四、实验过程与分析

(1)实验主要函数及存储结构

main.cpp 包括主函数和主要的功能

simulator.h 仿真类的声明

simulator.cpp 仿真类的定义

event.h 事件类的声明

event.cpp - 事件类的定义

job.h 作业类的声明

job.cpp 作业类的定义

包括任意打印作业数的数据文件

arbitrary.out 输出

包括打印较大作业的数据文件

bigfirst.out 输出

(2)实验代码

#ifndef FIFO_H //fifo.h

#define FIFO_H

#include "simulator.h"

class fifo:public simulator{

protected:

queue waiting;

priority_queue priority_waiting;

public:

fifo(int seconds_per_page);

void simulate(string file);

};

bool operator

#endif

#include "fifo.h" //fifo.cpp

#include

using namespace std;

fifo::fifo(int seconds_per_page):simulator(seconds_per_page){ }

void fifo::simulate(string file){

int finish_time = 0;

float agg_latency = 0;

int totaljob =0;

event evt;

if(file.find("arbitrary")!= string::npos){

string outfile ="arbitrary.out";

ofstream osf(outfile.c_str());

loadworkload(file);

osf

for(int time =1;!waiting.empty()||!workload.empty();time++){ while(!workload.empty() && time ==

workload.front().arrival_time()){

evt= workload.front();

osf

workload.pop();

}

if(!waiting.empty() && time >= finish_time){

totaljob ++;

evt = waiting.front();

agg_latency += time - evt.arrival_time();

osf

finish_time = time + evt.getjob().getnumpages() * seconds_per_page;

}

}

osf

osf

osf

return;

}

if(file.find("bigfirst") != string::npos){

string outfile = "bigfirst.out";

ofstream osf(outfile.c_str());

loadworkload(file);

osf

for(int time

=1;!priority_waiting.empty()||!workload.empty();time++){

while(!workload.empty() && time ==

workload.front().arrival_time()){

evt= workload.front();

osf

workload.pop();

}

if(!priority_waiting.empty() && time >= finish_time){

totaljob ++;

evt = priority_();

agg_latency += time - evt.arrival_time();

osf

finish_time = time + evt.getjob().getnumpages() * seconds_per_page; }

}

osf

osf

osf

return;

}

cerr

cerr

bool operator

return evtleft.getjob().getnumpages()

evtright.getjob().getnumpages();

}

五、实验结果总结

经测试，功能较为完整。代码流程简图如下：

通过这次实验，我了解了有关队列方面的知识。掌握了队列的逻辑结构，抽象数据类型，队列的存储方式等。运用先进先出表，仿真了网络打印队列。这都使我对数据结构的学习有了新的认识与帮助。在实验过程中，我也遇到了许多困难，从开始时对队列运算的不熟悉，到逐渐查找资料，从而完成了实验;六、附录;-《数据结构与算法分析》以及网上资料;

逐渐查找资料，从而完成了实验。在今后的学习中，我将继续努力，加强对堆栈，队列等知识的学习，以达到精益求精。

六、附录

数据结构报告 篇7

1)掌握栈和队列这两种特殊的线性表，熟悉它们的特性，在实际问题背景下灵活运用它们。

本实验训练的要点是“栈”和“队列”的观点;

1) 利用栈，实现数制转换。

2) 利用栈，实现任一个表达式中的语法检查(选做)。

3) 编程实现队列在两种存储结构中的基本操作(队列的初始化、判队列空、入队列、出队列);

顺序栈：

Status InitStack(SqStack &S)

{

S.base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));

return ERROR;

=S.base;

S.stacksize=STACK_INIT_SIZE;

return OK;

}

Status DestoryStack(SqStack &S)

{

free(S.base);

return OK;

}

Status ClearStack(SqStack &S)

{

=S.base;

return OK;

}

return OK;

return ERROR;

}

{

return -S.base;

}

Status GetTop(SqStack S,ElemType &e)

{

if(-S.base>=S.stacksize)

{

S.base=(ElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemType));

if(!S.base) return ERROR;

=S.base+S.stacksize;

S.stacksize+=STACKINCREMENT;

}

*++=e;

return OK;

}

Status Push(SqStack &S,ElemType e)

{

if(-S.base>=S.stacksize)

{

S.base=(ElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemType));

return ERROR;

=S.base+S.stacksize;

S.stacksize+=STACKINCREMENT;

}

*++=e;

return OK;

}

Status Pop(SqStack &S,ElemType &e)

return ERROR;

e=*--;

return OK;

}

{

ElemType *p;

p=(ElemType *)malloc(sizeof(ElemType));

if(!p) return ERROR;

p=;

while(p!=S.base)//上面一个...

{

p--;

printf(“%d ”,*p);

}

return OK;

}

{

int flag,TURE=OK,FALSE=ERROR;

ElemType e,x;

InitStack(S);

flag=OK;

while((x= getchar)!='#'&&flag)

case '{':

printf(“括号匹配成功!nn”);

break;

printf(“没有满足条件n”);

flag=FALSE;

}

break;

break;

break;

}

}

if (flag && x=='#' && StackEmpty(S))

return ERROR;

}

链队列：

Status InitQueue(LinkQueue &Q)

{

Q.front =Q.rear=

(QueuePtr)malloc(sizeof(QNode));

if (!Q.front) return ERROR;

Q.front->next = NULL;

return OK;

}

Status DestoryQueue(LinkQueue &Q)

{

Q.rear=Q.front->next;

free(Q.front);

Q.front=Q.rear;

}

return OK;

}

Status QueueEmpty(LinkQueue &Q)

{

return OK;

return ERROR;

}

{

int i=0;

QueuePtr p,q;

p=Q.front;

{

i++;

p=Q.front;

q=p->next;

p=q;

}

return i;

}

Status GetHead(LinkQueue Q,ElemType &e)

{

QueuePtr p;

p=Q.front->next;

return ERROR;

e=p->data;

return e;

}

Status ClearQueue(LinkQueue &Q)

{

QueuePtr p;

{

p=Q.front->next;

free(Q.front);

Q.front=p;

}

Q.front->next=NULL;

Q.rear->next=NULL;

return OK;

}

Status EnQueue(LinkQueue &Q,ElemType e)

{

QueuePtr p;

p=(QueuePtr)malloc(sizeof (QNode));

return ERROR;

p->data=e;

p->next=NULL;

Q.rear->next = p;

return OK;

}

Status DeQueue(LinkQueue &Q,ElemType &e)

{

QueuePtr p;

return ERROR;

p = Q.front->next;

e = p->data;

Q.front->next = p->next;

Q.rear = Q.front; //只有一个元素时(不存在指向尾指针)

free (p);

return OK;

}

Status QueueTraverse(LinkQueue Q)

{

QueuePtr p,q;

{

printf(“这是一个空队列!n”);

return ERROR;

}

p=Q.front->next;

{

q=p;

printf(“%ddata);

q=p->next;

p=q;

}

return OK;

}

循环队列：

Status InitQueue(SqQueue &Q)

{

Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));

exit(OWERFLOW);

Q.front=Q.rear=0;

return OK;

}

Status EnQueue(SqQueue &Q,QElemType e)

{

if((Q.rear+1)%MAXQSIZE==Q.front)

return ERROR;

Q.base[Q.rear]=e;

Q.rear=(Q.rear+1)%MAXQSIZE;

return OK;

}

Status DeQueue(SqQueue &Q,QElemType &e)

return ERROR;

e=Q.base[Q.front];

Q.front=(Q.front+1)%MAXQSIZE;

return OK;

}

{

return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;

}

Status DestoryQueue(SqQueue &Q)

{

free(Q.base);

return OK;

}

Status QueueEmpty(SqQueue Q) //判空

return OK;

return ERROR;

}

printf(“这是一个空队列!”);

Q.front++;

}

return OK;

}

数据结构报告 篇8

数据结构报告

引言：

数据结构是计算机科学中的一门重要课程，它研究如何组织和存储数据，以便在计算机中高效地操作和处理。数据结构对于计算机科学的发展和应用起着至关重要的作用。本报告将详细介绍数据结构的相关主题，包括数组、链表、栈、队列和树等。

一、数组

数组是一种线性数据结构，它由相同类型的元素组成，并按照一定的顺序存储在内存中。数组提供了按下标随机访问元素的能力，具有快速读取和修改元素的特点。本节将介绍数组的定义、基本操作及其在实际应用中的使用。

二、链表

链表是另一种常见的线性数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。与数组相比，链表的插入和删除操作更加灵活，但访问元素时需要遍历整个链表。本节将介绍链表的分类、基本操作以及它在实际应用中的应用场景。

三、栈

栈是一种具有特殊操作规则的线性数据结构，它遵循先进后出（Last In First Out，LIFO）的原则。栈主要包含入栈和出栈两个基本操作，可以用于实现简单的计算器、函数调用等。本节将介绍栈的定义、基本操作以及它在计算机系统中的应用。

四、队列

队列是一种具有特殊操作规则的线性数据结构，它遵循先进先出（First In First Out，FIFO）的原则。队列主要包含入队和出队两个基本操作，可以用于实现线程池、消息队列等。本节将介绍队列的定义、基本操作以及它在实际应用中的使用。

五、树

树是一种非线性的数据结构，由节点和边组成，节点之间存在层次关系。树具有层次性、唯一根节点和子树的递归结构等特点。树的应用非常广泛，比如文件系统、数据库索引和图像压缩等。本节将介绍树的定义、基本概念以及常见的树结构和它们的应用场景。

六、总结

数据结构是计算机科学的基础，它为我们提供了有效存储和操作数据的方法。通过本报告的详细介绍，我们了解了数组、链表、栈、队列和树等常见的数据结构，以及它们在实际应用中的使用场景。在实际开发中，根据不同的问题需求选择合适的数据结构非常重要，只有熟练掌握数据结构的原理和应用，才能更高效地解决实际问题。

参考文献：

1.《数据结构与算法分析- C语言描述》

2.《数据结构与算法分析- Java语言描述》

3.《Introduction to Algorithms》

附录：数据结构相关算法代码实现及其测试用例

相信《2024数据结构报告》一文能让您有很多收获！“幼儿教师教育网”是您了解幼师资料，工作计划的必备网站，请您收藏yjs21.com。同时，编辑还为您精选准备了数据结构报告专题，希望您能喜欢！