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

int n;
cout<<"输入n=";
cin>>n;
cout<<"输出：";
s.YangHui (n);
return 0;
}
运行结果：
算法的时空分析
时间复杂度为O(N)
输入输出格式
输入：
直接输入想要行数n
输出：如果输入小于条件给予的20，则显示如题所要求的杨辉三角
逆波兰表达式求值
一、需求分析
1.本程序要求读入一个后缀表达式，利用堆栈来计算该表达式的值，同时要效验后缀表达式是否正确。
}
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
s=t;
if(j!=i+2) cout<<s<<' '; //打印一个系数，第i+2个是
}
l=l+1;
cout<<"n="<<l;
}
}
//YangHui.cpp
#include<iostream>
#include"SeqQueue.h"
int main() //主函数
{
SeqQueue <int> s;
杨辉三角
问题描述
编写程序，根据输入的行数，屏幕显示杨辉三角。
基本要求
(1)行数不大于20行。
(2)基于队列的操作来实现杨辉三角的不断生成过程。（注：不要用其它的公式计算的方法或者二维数组来实现）
(3)基于数组实现队列的物理数据结构。
输入输出
输入n＝6
输出
1 n=0
1 1 n=1
1 2 1 n=2
1 3 3 1 n=3
{
string in;
char *input;
stack* l;
initial(l);
while(cin>>in)
{
input=(char *)malloc((in.length()+1)*(sizeof(char))); //实现任意长度字符串输入
in.copy(input,in.length());
程序的流程
程序由三个模块组成：
（1）输入模块：完成表达式输入存放于字符串中。
（2）转化模块：将字符串转化成数字。
（3）计算模块：通过表达式信息计算值。
（4）输出模块：表达式的值，同时要效验后缀表达式是否正确。
三、详细设计
物理数据类型
输入用string类输出为double类
算法的具体步骤
#include<cstdio>
getSize()
初始条件：队列Q已存在
操作结果：返回Q的元素个数，即队列长度
EnQueue(const T& x)
初始条件：队列Q已存在
操作结果：若队列不满，则将x进队，否则一处处理
DeQueue(T& x);
初始条件：Q为非空队列
操作结果：删除Q的队头元素，并用x返回其值
具体程序
//SeqQueue.h
}
}
double stringtodouble(char * input , int i) //将字符串转化为数字
{
double index=1;
double sum=0;
while(*(input+i)!='\0')
{
if(*(input+i)=='.') //实现小数输入
{
i++; //跳过'.'字符
input[in.length()]='\0';
if(*input=='-'&&(*(input+1)>='0')&&(*(input+1)<='9'))//输入为负数
{
push(l,-1*stringtodouble(input,1));
}
else if((*(input)>='0')&&(*(input)<='9')) //输入为非负数
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;
2.从键盘中输入一个后缀表达式，该表示包括加减乘除等操作符，以及正整数作为操作数等。
3.在Dos界面输出表达式的值或报错。
4.测试数据
输入：2 3 * 1 –#
输出：5
二、概要设计
抽象数据类型
为实现上述程序的功能，应以字符串存储用户的输入。
算法的基本思想
操作数入栈；遇到操作符时，操作数出栈，求值，将结果入栈；当一遍后，栈顶就是表达式的值。
x=element[front];
front=(front+1)%maxSize; //队头指针加
return true;
}
//------------------------------------取对头元素
template <class T>
bool SeqQueue<T>::getFront () //若队列不空则退掉队头元素
bool IsEmpty(){return(front==rear)?true:false;} //当对头指针跟队尾指针相同时，既队列为空//判断队列空否
bool IsFull() //判断队列满否
{return ((rear+1)%maxSize==front)?true:false;}
void makeEmpty() //清空队列
private:
int rear, front; //队尾与队首指针
T * element; //存放队列元素的数组
int maxSize; //队列最大可容纳元素个数
};
//---------------------------------------进队
template <class T>
bool SeqQueue<T>::EnQueue (const T& x)
//-------------------------------------------循环队列的类定义
#include <iostream>
template <class T>
class SeqQueue
{
public:
SeqQueue(){ maxSize=20; element=new T[maxSize]; front=0; rear=0; }
template <class T>
void SeqQueue<T>::YangHui(int n)
{
SeqQueue q; //建立队列对象
int i=1,j,s=0,k=0,l=0,t,u; //计算下一行系数时用到的工作单元
cout<<endl<<"1 n=0";
q.EnQueue(i);q.EnQueue(i); //预先放入第一行的两个系数
{
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 (IsEmpty()){cout<<"队列为空！不能返回队首元素的值！"<<endl;return false;}
cout<<"队首元素为："<<element[front]<<endl;
return true;
}
//---------------------------------------杨辉三角
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()
{front=rear=0;cout<<"队列已清空！"<<endl;} //清空队列
void getSize()const{ //返回队列的长度
cout<<"队列的长度为："<<(rear - front + maxSize)%maxSize<<endl;} //获取队列长度
void YangHui(int n); //杨辉三角
}
//-------------------------------------退队
template <class T>
bool SeqQueue<T>::DeQueue (T& x)
{ //若队列不空则函数退掉队头元素
if(IsEmpty()){cout<<"队列为空！退队操作失败！"<<endl;return false;}
for(i=1;i<=n;i++) //逐行处理
{
cout<<endl; //换一行
q.EnQueue(k); //各行间插入一个
for(j=1;j<=i+2;j++) //处理第i行的i+2个系数（包括一个）
{
q.DeQueue(t); //读取一个系数
u=s+t;q.EnQueue(u); //计算下一行系数，并进队列
{ //若队列不满，则将元素x插入到该队列的队尾，否则出错处理
if(IsFull()==true)return false; //若队列满则插入失败，返回
element[rear]=x; //按照队尾指针指示的位置插入
rear=(rear+1)%maxSize; //队尾指针加
return true; //插入成功，返回
#include<cstdlib>
#include<iostream>
#include<string>
using namespace std;
typedef struct stack //栈结构体
{
double num;
stack *pre;
}stack;
stack* top; //定义全局变量栈顶
~SeqQueue(){delete[] element;} //析构函数
bool EnQueue(const T& x); //进队//若队列不满，则将x进队，否则一处处理
bool DeQueue(T& x); //出队//若队列不空，则退出队头元素x
bool getFront(); //若队列不空，则返回队首元素的值
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
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;
}
double caculater(double a , double b , char ch)//计算
{
switch(ch)
{Fra Baidu bibliotek
case '+':return a+b;
case '-':return a-b;
case '*':return a*b;
case '/':return a/b;
default:printf("FALSE!!!\n");