数据结构杨辉三角实验报告

杨辉三角

问题描述

编写程序，根据输入的行数，屏幕显示杨辉三角。

基本要求

(1)行数不大于20行。

(2)基于队列的操作来实现杨辉三角的不断生成过程。（注：不要用其它的公式计算的

方法或者二维数组来实现）

(3)基于数组实现队列的物理数据结构。

输入输出

输入n＝ 6

输出

1 n=0

1 1 n=1

1 2 1 n=2

1 3 3 1 n=3

1 4 6 4 1 n=4

1 5 10 10 5 1 n=5

1 6 15 20 15 6 1 n=6

概要设计：

基本操作：

SeqQueue()

操作结果：构造一个空队列Q

makeEmpty()

初始条件：队列Q已存在

操作结果：将Q清为空队列

IsEmpty()

初始条件：队列Q已存在

操作结果：若Q为空队列，则返回TRUE，否则FALSE getSize()

初始条件：队列Q已存在

操作结果：返回Q的元素个数，即队列长度

EnQueue(const T& x)

初始条件：队列Q已存在

操作结果：若队列不满，则将x进队，否则一处处理

DeQueue(T& x);

初始条件：Q为非空队列

操作结果：删除Q的队头元素，并用x返回其值

具体程序

//SeqQueue.h

//-------------------------------------------循环队列的类定义

#include

template

class SeqQueue

{

public:

SeqQueue(){ maxSize=20; element=new T[maxSize]; front=0; rear=0; }

~SeqQueue(){delete[] element;} //析构函数

bool EnQueue(const T& x); // 进队//若队列不满，则将x进队，否则一处处理

bool DeQueue(T& x); //出队//若队列不空，则退出队头元素x

bool getFront(); //若队列不空，则返回队首元素的值

bool IsEmpty(){return(front==rear)?true:false;} //当对头指针跟队尾指针相同时，既队列为空//判断队列空否bool IsFull() //判断队列满否

{return ((rear+1)%maxSize==front)?true:false;}

void makeEmpty() //清空队列

{front=rear=0;cout<<"队列已清空！"<

void

getSize()const{

//返回队列的长度

cout<<"队列的长度为："<<(rear - front + maxSize)%maxSize<

void Y angHui(int n); //杨辉三角

private:

int rear, front; //队尾与队首指针

T * element; //存放队列元素的数组

int maxSize; //队列最大可容纳元素个数

};

//---------------------------------------进队

template

bool SeqQueue::EnQueue (const T& x)

{ //若队列不满，则将元素x插入到该队列的队尾，否则出错处理if(IsFull()==true)return false; //若队列满则插入失败，返回

element[rear]=x; //按照队尾指针指示的位置插入

rear=(rear+1)%maxSize; //队尾指针加

return true; //插入成功，返回

}

//-------------------------------------退队

template

bool SeqQueue::DeQueue (T& x)

{ //若队列不空则函数退掉队头元素if(IsEmpty()){cout<<"队列为空！退队操作失败！"<

x=element[front];

front=(front+1)%maxSize; //队头指针加

return true;

}

//------------------------------------取对头元素

template

bool SeqQueue::getFront () //若队列不空则退掉队头元素

{

if (IsEmpty()){cout<<"队列为空！不能返回队首元素的值！"<

cout<<"队首元素为："<

return true;

}

//---------------------------------------杨辉三角

template

void SeqQueue::Y angHui(int n)

{

SeqQueue q; //建立队列对象

int i=1,j,s=0,k=0,l=0,t,u; //计算下一行系数时用到的工作单元

cout<

q.EnQueue(i);q.EnQueue(i); //预先放入第一行的两个系数

for(i=1;i<=n;i++) //逐行处理

{

cout<

q.EnQueue(k); //各行间插入一个

for(j=1;j<=i+2;j++) //处理第i行的i+2个系数（包括一个）

{

q.DeQueue(t); //读取一个系数

u=s+t;q.EnQueue(u); //计算下一行系数，并进队列

s=t;

if(j!=i+2) cout<

}

l=l+1;

cout<<"n="<

}

}

//Y angHui.cpp

#include

#include"SeqQueue.h"

int main() //主函数

{

SeqQueue s;

int n;

cout<<"输入n=";

cin>>n;

cout<<"输出：";

s.Y angHui (n);

return 0;

}

运行结果：

算法的时空分析

时间复杂度为O(N)

输入输出格式

输入：

直接输入想要行数n

输出：如果输入小于条件给予的20，则显示如题所要求的杨辉三角

逆波兰表达式求值

一、需求分析

1.本程序要求读入一个后缀表达式，利用堆栈来计算该表达式的值，同时要效验后缀表达式是否正确。

2.从键盘中输入一个后缀表达式，该表示包括加减乘除等操作符，以及正整数作为操作

数等。

3.在Dos界面输出表达式的值或报错。

4.测试数据

输入：2 3 * 1 –#

输出：5

二、概要设计

抽象数据类型

为实现上述程序的功能，应以字符串存储用户的输入。

算法的基本思想

操作数入栈；遇到操作符时，操作数出栈，求值，将结果入栈；当一遍后，栈顶就是表达式的值。

程序的流程

程序由三个模块组成：

（1）输入模块：完成表达式输入存放于字符串中。

（2）转化模块：将字符串转化成数字。

（3）计算模块：通过表达式信息计算值。

（4）输出模块：表达式的值，同时要效验后缀表达式是否正确。

三、详细设计

物理数据类型

输入用string类输出为double类

算法的具体步骤

#include

#include

#include

#include

using namespace std;

typedef struct stack //栈结构体

{

double num;

stack *pre;

}stack;

stack* top; //定义全局变量栈顶

void initial(stack *& l) //初始化链表

{

l=(stack*)malloc(sizeof(stack));

top=l;

l->pre=NULL;

}

bool pop(stack*& l , double &n)//出栈

{

if(top->pre==NULL)

return false;

n=top->num;

top=top->pre;

return true;

}

void push(stack*& l , double n)//入栈

{

stack* temp;

temp=(stack*)malloc(sizeof(stack));

temp->num=n;

temp->pre=top;

top=temp;

}

double caculater(double a , double b , char ch)//计算

{

switch(ch)

{

case '+':return a+b;

case '-':return a-b;

case '*':return a*b;

case '/':return a/b;

default:printf("FALSE!!!\n");

}

}

double stringtodouble(char * input , int i) //将字符串转化为数字{

double index=1;

double sum=0;

while(*(input+i)!='\0')

{

if(*(input+i)=='.') //实现小数输入

{

i++; //跳过'.'字符

index=0.1;

while(*(input+i)!='\0')

{

sum=sum+(*(input+i)-48)*index;

index=index/10;

i++;

}

return sum;

}

sum=sum*10+(*(input+i)-48);

i++;

}

return sum;

}

int main()

{

string in;

char *input;

stack* l;

initial(l);

while(cin>>in)

{

input=(char *)malloc((in.length()+1)*(sizeof(char))); //实现任意长度字符串输入

in.copy(input,in.length());

input[in.length()]='\0';

if(*input=='-'&&(*(input+1)>='0')&&(*(input+1)<='9'))//输入为负数

{

push(l,-1*stringtodouble(input,1));

}

else if((*(input)>='0')&&(*(input)<='9')) //输入为非负数

{

push(l,stringtodouble(input,0));

}

else //输入为运算符

{

double a,b;

if(!pop(l,b))

printf("FALSE!!!\n");

if(!pop(l,a))

printf("FALSE!!!\n");

push(l,caculater(a,b,*input));

}

if(*(input+1)=='#') //实现输入为#时跳出

break;

}

printf("%.2lf\n",top->num); //打印结果

return 0;

}

算法的时空分析

时间复杂度为O(N)

输入输出格式

输入：

在字符界面上输入一个后缀表达式，其中两相邻操作数之间利用空格隔开。以“#”表示结束。

输出：如果该后缀表达式正确，那么在字符界面上输出其结果，计算结果小数点后面保留两位有效数字，如果不正确，请在字符界面上输出表达式错误提示。

四、测试结果

输入 2 3 * 1 –#输出 5

输入 2.4 2.5 + 4.9 *# 输出24.01