C语言编写四则运算
#include
#include
#define STACK_SIZE100 //max size of the stack
#define STACK_INCREMENT10 //realloc size
typedef struct FStack//stack of int
{
float* base;
float* top;
int stacksize;
}FStack;
void Init(FStack* s)
{
s->base = (float*)malloc(STACK_SIZE * sizeof(FStack));
if (!s->base)
{
printf("overflow!\n");
return;
}
s->top = s->base;
s->stacksize = STACK_SIZE;
}
bool isEmpty(FStack* s)
{
if (s->top == s->base)
{
return true;
}
else
{
return false;
}
}
void Push(FStack* s, float e)
{
if (s->top - s->base >= s->stacksize)
{
printf("stack is full!\nrealloc %d\n", STACK_INCREMENT);
s->base = (float*)realloc(s->base, (s->stacksize +
sizeof(FStack)));
if (!s->base)
{
printf("overflow!\n");
return;
}
s->top = s->base + s->stacksize;
s->stacksize += STACK_INCREMENT;
}
*(s->top) = e;
(s->top)++;
}
float GetTop(FStack* s)
{
if (s->top == s->base)
{
printf("stack is empty!\n");
return 0;
}
float e = *(s->top - 1);
return e;
}
void Pop(FStack* s)
{
if (s->top == s->base)
{
printf("stack is empty!\n");
return;
}
s->top--;
}
typedef struct CStack//stack of char
{
char* base;
char* top;
int stacksize;
}CStack;
void Init(CStack* s)
{
s->base = (char*)malloc(STACK_SIZE * sizeof(CStack));
if (!s->base)
{
printf("overflow!\n");
return;
}
s->top = s->base;
s->stacksize = STACK_SIZE;
}
bool isEmpty(CStack* s)
{
if (s->top == s->base)
{
return true;
}
else
{
return false;
}
}
void Push(CStack* s, int e)
{
if (s->top - s->base >= s->stacksize)
{
printf("stack is full!\nrealloc %d\n", STACK_INCREMENT);
s->base = (char*)realloc(s->base, (s->stacksize +
sizeof(CStack)));
if (!s->base)
{
printf("overflow!\n");
return;
}
s->top = s->base + s->stacksize;
s->stacksize += STACK_INCREMENT;
}
*(s->top) = e;
(s->top)++;
}
char GetTop(CStack* s)
{
if (s->top == s->base)
{
printf("stack is empty!\n");
return 0;
}
char e = *(s->top - 1);
return e;
}
void Pop(CStack* s)
{
if (s->top == s->base)
{
printf("stack is empty!\n");
return;
}
s->top--;
}
bool isOper(char ch)
{
if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '%') {
return true;
}
else
{
return false;
}
}
int Priority(char ch)
{
int p;
switch(ch)
{
case'(':
p = 0;
break;
case'+':
case'-':
p = 1;
break;
case'*':
case'/':
case'%':
p = 2;
break;
}
return p;
}
float Calculate(float f1, float f2, char oper) {
float f3;
switch(oper)
{
case'+':
f3 = f1 + f2;
break;
case'-':
f3 = f1 - f2;
break;
case'*':
f3 = f1 * f2;
break;
case'%':
f3 = (float)((int)f1 % (int)f2);
break;
case'/':
if (f2 == 0)
{
printf("\nDevided by zero!");
exit(1);
}
else
{
f3 = f1 / f2;
}
break;
}
return f3;
}
float StrtoFloat(char* str, int* pos)
{
float fRes;
int i = *pos;
int k;
char n[50];
for(k= 0; str[i] >= '0'&& str[i] <= '9'|| str[i] == '.'; i++, k++) {
n[k] = str[i];
}
n[k] = '\0';
*pos = i;
fRes = atof(n);
return fRes;
}
bool Check(char* str)
{
int i = 0;
while (str[i] != '\0')
{
if (str[i] != '+' && str[i] != '-' && str[i] != '*' && str[i] != '/' && str[i] != '%' && str[i] != '.' && str[i] != '(' && str[i] != ')' && (str[i] < '0' || str[i] > '9'))
{
return false;
}
i++;
}
return true;
}
void main()
{
char exp[100];
int i;
float f, f1, f2;
char oper;
FStack fstack;
CStack cstack;
Init(&fstack);
Init(&cstack);
printf("The expression is:");
gets(exp);
if (!Check(exp))
{
printf("input error! exit now!\n");
exit(1);
}
for (i = 0; exp[i] != '\0' && exp[i] != -52; i++)
{
if (!isOper(exp[i]))
{
f = StrtoFloat(exp, &i);
Push(&fstack, f);
}
if (isOper(exp[i]))
{
if (!isEmpty(&cstack))
{
while (!isEmpty(&cstack) && Priority(exp[i]) <= Priority(GetTop(&cstack)))
{
oper = GetTop(&cstack);
Pop(&cstack);
f2 = GetTop(&fstack);
Pop(&fstack);
f1 = GetTop(&fstack);
Pop(&fstack);
f = Calculate(f1, f2, oper);
Push(&fstack, f);
}
Push(&cstack, exp[i]);
}
else
{
Push(&cstack, exp[i]);
}
}
else if (exp[i] == '(')
{
Push(&cstack, exp[i]);
}
else if (exp[i] == ')')
{
while (GetTop(&cstack) != '(' && !isEmpty(&cstack))
{
oper = GetTop(&cstack);
Pop(&cstack);
f2 = GetTop(&fstack);
Pop(&fstack);
f1 = GetTop(&fstack);
Pop(&fstack);
f = Calculate(f1, f2, oper);
Push(&fstack, f);
}
Pop(&cstack);
}
}
while (!isEmpty(&cstack))
{
oper = GetTop(&cstack);
Pop(&cstack);
f2 = GetTop(&fstack);
Pop(&fstack);
f1 = GetTop(&fstack);
Pop(&fstack);
f = Calculate(f1, f2, oper);
Push(&fstack, f);
}
printf("\nThe result is:%f\n", GetTop(&fstack));
Pop(&fstack);
}
栈的应用:C实现简单计算器(表达式的计算) 作为栈的著名应用,表达式的计算可以用下面方法实现: 首先建立两个栈,操作数栈NUM_S和运算符栈OPR_S。 其中,操作数栈用来存储表达式中的操作数;运算符栈用来存储表达式中的运算符。可以用字符‘=’来表示表达式结束符。 自左至右的扫描待处理的表达式,并假设当前扫描到的符号为W,根据不同的符号W 做如下不同的处理: 1.若W为操作数,则将W压入操作数栈NUM_S,且继续扫描下一个字符; 2.若W为运算符,则根据运算符的性质做相应的处理: (0)若符号栈为空,无条件入栈当前指针指向的字符 (1)若w为不大于运算符栈栈顶的运算符,则从操作数栈NUM_S中弹出两个操作数,设先后弹出的操作数为a、b,再从运算符栈 OPR_S中弹出一个运算符,比如为+,然后作运算a+b,并将运算结果压入操作数栈NUM_S。 (2)若w为左括号或者运算符的优先级大于运算符栈栈顶的运算符,则将运算符W 压入运算符栈OPR_S,并继续扫描下一个字符。 (3)若运算符W为右括号,循环操作(设先后弹出的操作数为a、b,再从运算符栈OPR_S中弹出一个运算符,比如为+,然后作运 算a+b, 并将运算结果压入操作数栈NUM_S),直到从运算符栈中弹出第一个左括号。 (4)若运算符W为表达式结束符‘=’,循环操作(设先后弹出的操作数为a、b,再从运算符栈OPR_S中弹出一个运算符,比如为 +,然后作运算a+b, 并将运算结果压入操作数栈NUM_S),直到运算符栈为空为止。此时,操作数栈栈顶元素即为表达式的 值。 ====================================================================== === 举例:计算3+(5-2*3)/4-2= (1)开始栈为空,3入栈,+入栈,(无条件入栈,5入栈,-号优先级比(高,所以-号入栈,2入栈,*优先级比目前栈顶的-号优先级高,所以*入栈,3入栈,接着扫描到)括号,)括号不入栈 | | | | --------- ---------- | 3 | | * | --------- ---------- | 2 | | - |
昆明理工大学 《计算机程序设计基础》课程 综合实践型教学课题报告 课题名称:100以内的整数四则运算测试程序设计 组长:学号 040401067 姓名周绍平 组员:学号 040401070 姓名邓磊 学号 040401106 姓名刘云路 学号姓名 学号姓名 学号姓名 学号姓名 学院:信自学院专业班级:自动化0421 指导教师:耿植林 昆明理工大学计算中心 2005 年 6月18日
昆明理工大学计算中心 《计算机程序设计基础》课程综合实践型教学课题报告课程名称:100以内的整数四则运算测试程序设计
正文内容: 一、问题描述 这是一个进行数学计算的程序,且要求拥有多种功能,包括(1)选项菜单集成各功能函数模块(2)出题(每次出10道题目)(3)答题并评分(4)答错的题给出正确答案(5)显示答卷。总体看来,大多数功能要求调用错题,所以面临的两个难题便是出题和保存答题者做错的题以便其它函数调用。另外,由于除法的特殊性——其除数不能为0。又因为这是一个用于100以内整数的四则运算的程序,又对除法这个特殊成员提出了新的要求——要使得到的结果为整数。所以有必要把除法单独拿出来作为一个函数处理。 二、问题分析 这是一个任务很明确的程序设计—用于100以内的整数的四则运算。这个程序要求拥有选项菜单、出题、答题评分、显示答卷、错题再解、重复练习的功能。既然是一个用于计算的程序那它的主要作用就是给练习者答题,并验证答题的正确与否。当然,还要有一些附加功能,比如:把答卷显示出来,错题给出正解,错题再抽出来再做。 这个程序只要求100以内的四则运算,所以随机出现的数字只能是100以内的,并且要求其为整数。不论是数据的输入与输出,都要求其为整数。 鉴于这个程序所要求达到的功能,我们小组决定把它分为计算、菜单、答卷、重做、正解、评价、除法七个函数模块。 对各成员的分工如下: 计算、正解和菜单(周绍平) 评价和除法(邓磊) 答卷和重做(刘云路) 主函数及各函数的连接则由小组成员共同完成。 三、程序设计思路功能模块说明 各函数流程图: 1、除法(chufa) 2、计算(jisuan)
四则运算 姓名: 学号: 班级: 1.功能结构图 2.程序功能 进行整数的加减乘除和求模运算。程序采用随机产生1~100的两个数进行运算每种运算有10个题目用户输入对应的答案程序提示答案的对错最后统计正确率。每次给出两次答题机会。 3.程序流程图
4.函数列表及功能
5.源程序代码 #include
printf("\n---加减乘除运算练习系统---\n"); printf("1.加法运算\n"); printf("2.减法运算\n"); printf("3.乘法运算\n"); printf("4.除法运算\n"); printf("5.求模运算\n"); printf("6.混合运算\n"); printf("0.退出练习\n"); printf(" 请输入数字0~6:"); scanf("%d",&op); //输入相应数字进行练习switch(op) { case 1:printf("--请进行加法运算--\n"); count=0; for(i=1;i<=N;i++) { a=rand()%100+1; b=rand()%100+1; res=f(a,b); //调用加法函数 printf("%d+%d=",a,b); scanf("%d",&ans); //输入数值 if(ans==res) { printf("Very Good!\n"); count++; } else { printf("wrong! 请重新输入\n"); scanf("%d",&ans); if(ans==res) printf("Very Good!\n"); else printf("Wrong Answer!\n"); } } printf("***正确率为%.0f%%***\n",100.0*count/N); break; case 2:printf("--请进行减法运算--\n"); count=0; for(i=1;i<=N;i++) { a=rand()%100+1; b=rand()%100+1;
《C语言》课内实验报告 学生姓名: 及学号: 学院: 班级: 课程名称:C语言 实验题目:实验二选择结构程序设计 指导教师 姓名及职称: 年月日
一、实验目的 1.掌握逻辑表达式和if语句、嵌套的if语句、switch语句和break语句的格式、语义。 2.掌握选择结构程序设计方法。 二、实验内容 编写程序实现两个数的四则运算,要求从键盘输入进行运算的两个数字以及相应的运算符('+'、'-'、'*'、'/'),程序给出算数表达式及运算结果。(如下图所示,要求使用if语句和switch语句两种方法实现) 三、实验结果 1、流程图
2、源程序 (1)使用if语句 #include
目录 题目一.二叉树操作(1)二.算术表达式求 (1) 一、课程设计的目的 (1) 二、课程设计的内容和要求 (1) 三、题目一设计过程 (2) 四、题目二设计过程 (6) 五、设计总结 (17) 六、参考文献 (18)
题目一.二叉树操作(1)二.算术表达式求 一、课程设计的目的 本学期我们对《数据结构》这门课程进行了学习。这门课程是一门实践性非常强的课程,为了让大家更好地理解与运用所学知识,提高动手能力,我们进行了此次课程设计实习。这次课程设计不但要求学生掌握《数据结构》中的各方面知识,还要求学生具备一定的C语言基础和编程能力。 (1)题目一的目的: 1、掌握二叉树的概念和性质 2、掌握二叉树的存储结构 3、掌握二叉树的基本操作 (2)题目二的目的: 1、掌握栈的顺序存储结构和链式存储结构 2、掌握栈的先进后出的特点 3、掌握栈的基本运算 二、课程设计的内容和要求 (1)题目一的内容和要求: 1、编写已知二叉树的先序、中序序列,恢复此二叉树的程序 2、编写求二叉树深度的程序 (2)题目二的内容和要求: 1、算术表达式由操作数、运算符和界限符组成。操作数是正整数,运算符为 加减乘除,界限符有左右括号和表达式起始 2、将一个表达式的中缀形式转化为相应的后缀形式 3、依据后缀表达式计算表达式的值
三、题目一设计过程 1、题目分析 现已知一棵二叉树的先序遍历序列和中序遍历序列,依次从先序遍历序列中取结点,由先序序列确定根结点(就是第一个字母),每次取出一个结点就与中序遍历的序列进行比较,当相等的时候,中序遍历序列就被分成以该结点为根的二叉树子树,该结点左部分为左子树,右部分为右子树,直到取完先序列里的所有结点,则二叉树构造完毕(树用链式存储结构存储),用递归实现! 由建好的二叉树,先判断这棵树是否为空,若不为空则找数的左子树,统计它的高度,然后找树的右子树,统计它的高度,比较左子树和右子树的高度,然后返回其中大的那个值加一,则求出数的高度。这里用递归实现! 2、算法描述 main ( )(主函数) 先构造一颗二叉树,初始化为空,用来存储所构造的二叉树,并输入一棵树的先序序列和中序序列,并统计这个序列的长度。然后调用实现功能的函数。 void CreateBiTree(BiTree *T,char *pre,char *in,int len)(由先序序列和中序序列构造二叉树) 根据前序遍历的特点, 知前序序列(pre)的首个元素(pre[0])为根(root), 然后在中序序列(in)中查找此根(pre[0]), 根据中序遍历特点, 知在查找到的根(root) 前边的序列为左子树, 后边的序列为右子树。设根前边有n个元素,则又有, 在前序序列中,紧跟着根(root)的n个元素序列(即pre[1...n]) 为左子树, 在后边的为右子树,而构造左子树问题其实跟构造整个二叉树问题一样,只是此时前序序列为pre[1...n]), 中序序列为in[0...n-1], 分别为原序列的子串, 构造右子树同样。这里用递归实现! int Depth(BiTree T)(求树的深度) 当所给的参数T是NULL时,返回0。说明这个树只有一个叶子节点深度为0,当所给的参数不是NULL时,函数调用自己看看这个参数的左分支是不是NULL,
#include"stdio.h" #include"stdlib.h" void main() { int a,b,c,d,e,f,g,t; printf("****************************欢迎使用!************************\n"); printf("\n"); printf("1.加法运算\n"); printf("2.减法运算\n"); printf("3.乘法运算\n"); printf("4.除法运算\n"); printf("*****************************请选择运算类型:"); scanf("%d",&a); while(a<1||a>4) { printf("输入错误,请重新输入"); scanf("%d",&a); } if(a==1) { printf("5,一位数加一位数\n"); printf("6,一位数加两位数\n"); printf("7,两位数加两位数\n"); printf("*********************************请输入题型:"); scanf("%d",&a); while(a<5||a>7) { printf("输入错误,请重新输入"); scanf("%d",&a); } if(a==5) { loop:b=rand()%10; c=rand()%10; d=b+c; printf("%d+%d=?\n",b,c); printf("请输入答案:"); scanf("%d",&e); while(e!=d) { printf("回答错误,请重做"); printf("%d+%d=?\n",b,c); printf("请输入答案:"); scanf("%d",&e);
实验名称栈的基本操作 实验目的 掌握栈这种抽象数据类型的特点及实现方法。 实验内容 从键盘读入若干个整数,建一个顺序栈或链式栈,并完成下列操作: (1)初始化栈; (2)判栈为空; (3)出栈; (4)入栈。 算法设计分析 (一)数据结构的定义 struct stackNode{ int data; struct stackNode *nextPtr; }; typedef struct stackNode listStact; typedef listStact *stackNodePtr; (二)总体设计 程序由主函数、入栈函数,出栈函数,删除函数判官是否为空函数和菜单函数组成。 (1)主函数:调用各个函数以实现相应功能
(三)各函数的详细设计: Function1: void instruct() //菜单 (1):使用菜单显示要进行的函数功能; Function2:void printStack(stackNodePtr sPtr) //输出栈 (1):利用if判断栈是否为空; (2):在else内套用while(头指针不为空条件循环)循环输出栈元素; Function3:void push(stackNodePtr *topPtr,int value //进栈 (1):建新的头指针; (2):申请空间; (3):利用if判断newPtr不为空时循环进栈 (4):把输入的value赋值给newPtr,在赋值给topPtr,再指向下一个位置; Function4:int pop(stackNodePtr*topPtr) //删除 (1):建新的头指针newPtr; (2):利用if判断newPtr是否为空,再删除元素。 (3):把topPtr等于newPtr,把头指针指向的数据赋值给topValue,输出要删除的数据值,头指针指向下一个位置,并清空newPtr; (4):完成上述步骤后,return toPvalue,返回;
设计题目:大整数的四则运算 1. 功能简介:编写出实现大整数之间相加,相减,相乘,相除的程序,并输出计算结构。 课程设计要求:采用模块化程序设计 源程序中应有足够的注释 必须上机调试通过 注重算法运用,优化存储效率与运算效率 需提交源程序(含有注释)及相关文件(数据或数据库文件); 提交设计报告书。 2.总体结构:
数据初判断运算符 加法 正整数非正整 转变为 减法 转变为 乘法除法 转变为 退出 流程图:
3 .概要设计:
1)加法运算 利用两个整形数组分别存放两个数a和b的每一位的数值,最低位存放符号。如果a 和b同号,从最低为开始计算,如果有进位则保存在高一位,本为则减10,然后反序将计算后的各个位的数值保存在一个数组c并输出,如果a和b都是负数则在前面要输出负号,函数的返回值为c的位数。如果a和b异号,也即两个正整数相减,从最低位开始相减,如果要借位则本位加10再相减,高一位要减1,然后反序将计算后的各个位的数值保存在一个数组c并输出,在前面要输出相应的符号位。 2)减法运算 可将减法运算转化为加法运算,只要将被减数的符号改变即可。 3)乘法运算 符号存放在最低位,将其中一个数a的每一位分别乘以另一个数b的每一位,并将结果保存在数组c中,然后重复计算a的下一位跟b的每一位的乘积,把上一次计算保存在c 的值加上本次计算后的值,并保存在c自身中,直到a的最高位,最后输出符号和相应的计算结果。 4)除法运算 利用乘法和减法,将除数分别乘以1到9,直到其值大于等于被除数的对应的数,然后被除数对应的数减去其乘积,保存在一个数组中,下一次循环把它归到被除数中继续做除法运算,最后得到余数并输出。 4.函数功能: 1.void init(int a[],int b[],int *p1,int *p2) 2.功能说明:读入所要计算的数值,数据初始化 3.i nt plus(int a[],int b[],int c[],int m,int n) 4.功能说明:两个正整数相加 3. void change(int a[],int b[],int m,int n) 功能说明:当两异号数相加时,改变其符号以符合加法运算 5.i nt minus(int a[],int b[],int d[],int m,int n)
详解堆栈的几种实现方法——C语言版 基本的抽象数据类型(ADT)是编写C程序必要的过程,这类ADT有链表、堆栈、队列和树等,本文主要讲解下堆栈的几种实现方法以及他们的优缺点。 堆栈(stack)的显著特点是后进先出(Last-In First-Out, LIFO),其实现的方法有三种可选方案:静态数组、动态分配的数组、动态分配的链式结构。 静态数组:特点是要求结构的长度固定,而且长度在编译时候就得确定。其优点是结构简单,实现起来方便而不容易出错。而缺点就是不够灵活以及固定长度不容易控制,适用于知道明确长度的场合。 动态数组:特点是长度可以在运行时候才确定以及可以更改原来数组的长度。优点是灵活,缺点是由此会增加程序的复杂性。 链式结构:特点是无长度上线,需要的时候再申请分配内存空间,可最大程度上实现灵活性。缺点是链式结构的链接字段需要消耗一定的内存,在链式结构中访问一个特定元素的效率不如数组。 首先先确定一个堆栈接口的头文件,里面包含了各个方案下的函数原型,放在一起是为了实现程序的模块化以及便于修改。然后再接着分别介绍各个方案的具体实施方法。 堆栈接口stack.h文件代码: [cpp]view plaincopy 1./* 2.** 堆栈模块的接口 stack.h 3.*/ 4.#include
C++编写的简单计算器,能执行简单的四则运算 文档时copy过来的!只为方便大家 #include
C语言用栈实现进制转换 #include
软件名称:四则运算训练器 软件功能介绍: 该软件主要用于训练并测试使用者的四则运算能力。 进入软件主界面,界面上会显示3个选项,分别是: 1.10以内的四则运算训练。 2.20以内的四则运算训练。 0.退出。 使用者根据自己的需要选择不同的选项: 按“1”进入10以内的四则运算训练; 按“2”进入20以内的四则运算训练; 按“0”退出程序主界面。 10以内的四则运算和20以内的四则运算均为10题一组;在这10个题中,加减乘除均有,操作数均为整数,且加减乘除出现的顺序不定,除法给出的两个操作数能除尽。 对于给出的题目,当操作者计算正确时,操作界面上无特殊显示;当操作者计算错误时,操作界面上会显示“FAULT!”,提示操作者该题计算错误并同时进入下一题。 操作者每做完10道题,界面上会显示此轮计算的正确率,并询问操作者是否继续。此时操作者可根据自己的需要,按“1”进入10以内的四则运算训练; 按“2”进入20以内的四则运算训练; 按“0”退出程序主界面。
程序代码: #include
使用C++中STL的stack,只有C++中有,C标准库没有STL。 程序:(单整数) #include
数据结构与算法实验报告
基于栈的C语言迷宫问题与实现 一.问题描述 多年以来,迷宫问题一直是令人感兴趣的题目。实验心理学家训练老鼠在迷宫中寻找食物。许多神秘主义小说家也曾经把英国乡村花园迷宫作为谋杀现场。于是,老鼠过迷宫问题就此产生,这是一个很有趣的计算机问题,主要利用“栈”是老鼠通过尝试的办法从入口穿过迷宫走到出口。 迷宫只有两个门,一个叫做入口,另一个叫做出口。把一只老鼠从一个无顶盖的大盒子的入口处赶进迷宫。迷宫中设置很多隔壁,对前进方向形成了多处障碍,在迷宫的唯一出口处放置了一块奶酪,吸引老鼠在迷宫中寻找通路以到达出口。求解迷宫问题,即找出从入口到出口的路径。 一个迷宫可用上图所示方阵[m,n]表示,0表示能通过,1 表示不能通过。现假设耗子从左上角[1,1]进入迷宫,编写算法,寻求一条从右下角[m,n] 出去的路径。下图是一个迷宫的示意图: 入口 出口
迷宫示意图 二.算法基本思想 迷宫求解问题是栈的一个典型应用。基本算法思想是:在某个点上,按照一定的顺序(在本程序中顺序为上、右、下、左)对周围的墙、路进行判断(在本程序中分别用1、0)代替,若周围某个位置为0,则移动到该点上,再进行下一次判断;若周围的位置都为1(即没有通路),则一步步原路返回并判断有无其他通路,然后再次进行相同的判断,直到走到终点为止,或者确认没有任何通路后终止程序。 要实现上述算法,需要用到栈的思想。栈里面压的是走过的路径,若遇到死路,则将该位置(在栈的顶层)弹出,再进行下一次判断;若遇到通路,则将该位置压栈并进行下一次判断。如此反复循环,直到程序结束。此时,若迷宫有通路,则栈中存储的是迷宫通路坐标的倒序排列,再把所有坐标顺序打印后,即可得到正确的迷宫通路。 三.程序具体部分的说明 1.迷宫的生成 根据题目的要求,迷宫的大小是自定义输入的。所以在程序中用malloc申请动态二维数组。数组中的元素为随机生成的0、1。数组周围一圈的元素全部定义为1,以表示边界。 2.栈的C语言实现 为了实现栈的功能,即清空、压栈、弹出、返回栈顶元素,在程序中编写了相应的函数。 MakeNULL 清空栈 Push 将横、纵坐标压栈 Topx 返回栈顶存储的横坐标 Topy 返回栈顶存储的纵坐标 Pop 弹出栈顶元素 3.具体的判断算法
C语言编写四则运算 #include//计算器 #include〈malloc、h> ?//maxsize of the stack 100 #define STACK_SIZE?? #defineSTACK_INCREMENT10?//realloc size typedef structFStack//stackof int { ?float* base; float*top; ?intstacksize; }FStack; void Init(FStack*s) { ?s—>base= (float*)malloc(STACK_SIZE* sizeof(FStack)); if(!s->base) ?{ ??printf(”overflow!\n”); ??return; ?} ?s->top = s—>base; ?s->stacksize = STACK_SIZE; } boolisEmpty(FStack*s) { ?if(s-〉top == s—〉base) ?{ ??returntrue; } ?else { ??return false; ?} } voidPush(FStack* s, floate) { if(s-〉top-s—>base >= s-〉stacksize) ?{ ??printf(”stack is full!\nrealloc %d\n", STACK_INCREM ENT); ?s—〉base = (float*)realloc(s->base, (s—>stacksize + sizeof(FStack))); ??if(!s—>base) ??{
#define_CRT_SECURE_NO_WARNINGS #include
stack.h #ifndef _STACK_H_ #define _STACK_H_ #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define OVERFLOW -2 #define STACK_INIT_SIZE 100 // 栈储存空间的初始分配量 #define STACKINCREMENT 10 // 储存空间分配增量 typedef int Status typedef char SElemType typedef struct { SElemType *base;// 储存数据元素的数组 SElemType *top; // 栈顶指针 int stacksize; // 当前分配的栈空间大小,以sizeof(SElemType)为单位 }SqStack;
//** 构造一个空栈 Status InitStack(SqStack *S); //** 销毁栈 Status DestroyStack(SqStack *S); //** 栈是否为空 Status StackEmpty(SqStack *S); //** 入栈 Status Push(SqStack *S,SElemType e); //**取栈顶 SElemType GetTop(SqStack *S); //** 出栈 SElemType Pop(SqStack *S); //** 栈长度 int StackLength(SqStack *S);
//** 遍历 Status StackTraverse(SqStack *S,Status( *visit)(SElemType)); Status visit(SElemType e); #endif stack.c #include
实验报告 课程名称:数据结构 年级班级:计算机1712 学号姓名:查玉坤 2017116128 任课教师:康长青
实验目的 设计算法,把十进制整数转换为二至九进制之间的任一进制输出。 实验内容 代码如下: #include
for(i=S->top-1;i>=0;i--) printf("%d",S->base[i]); printf("\n"); } int main(){ int a,b,Jin,x,X,size; a=1; printf("输入一个十进制数\n"); scanf("%d",&x); X=x; printf("需要转化为多少进制数?\n"); scanf("%d",&Jin); sqstack S; initstack(&S); while(x>=Jin){ a=(x%Jin); b=(x/Jin); push(&S,a); x=b; } push(&S,x); printf("转换的%d进制数为:",Jin); list(&S); printf("验证:\n"); for(int i=S.top;i>0;i--){ if(i-1!=0) printf("%d*(%d^%d)+",S.base[i-1],Jin,i-1); else printf("%d*(%d^0)=%d\n",S.base[i-1],Jin,X); } return 0; }
C、C++语言实现的数据结构课程设计的计算器(堆栈) /* // 我真诚地保证: // 我自己独立地完成了整个程序从分析、设计到编码的所有工作。 // 如果在上述过程中,我遇到了什么困难而求教于人,那么,我将在程序实习报告中// 详细地列举我所遇到的问题,以及别人给我的提示。 // 我的程序里中凡是引用到其他程序或文档之处, // 例如教材、课堂笔记、网上的源代码以及其他参考书上的代码段, // 我都已经在程序的注释里很清楚地注明了引用的出处。 // 我从未没抄袭过别人的程序,也没有盗用别人的程序, // 不管是修改式的抄袭还是原封不动的抄袭。 // 我编写这个程序,从来没有想过要去破坏或妨碍其他计算机系统的正常运转。 // <李雷阳> */ /******************************************************************** 用堆栈做的计算器程序* 创建者:李雷阳* 创建时间:2011.03.12 * 最后修改时间:2011.03.15 * /******************************************************************** /******************************************************************** 本程序功能:实现用堆栈处理计算表达式 具体内容: I: 如果算式里面有计算式不应该出现的字符,则将其智能略去 如:将(1.4a54+2f.6)*3.09s+4ff看成(1.454+2.6)*3.09+4 II: 检查括号是否匹配,如果匹配,再检查是否出现在合法位置 如:(8*(7-4)不匹配,以及65*(72+98)(70-45)匹配但是不合法 III: 检查计算数与计算符号的数量是否合格 如:+23-4* 、23-4*、+23-4 等等
C语言栈的指针实现 #include
Error("Echausted memory."); else return p; } //数据成员element 存储栈元素,next 是指向下一个结点的指针,函数NewStackNode()创建一个新结点 //用指针实现的链栈 typedef struct Istack *Stack; typedef struct Istack { slink top; //栈顶结点指针 }Lstack; /*top 是指向栈顶结点的指针*/ Stack StackInit() //将top 置为空指针,创建一个空栈 { Stack S = (Lstack *)malloc(sizeof*S); S->top = 0; return S; } int StackEmpty(Stack S) //简单的检测指向栈顶的指针top 是否为空指针 { return S->top == 0; } int StackFull(Stack S) //通过StackMenFull()为栈S试分配一个新结点,检测栈空间是否