c语言栈算法,c语言函数栈

本文目录一览：

• 1、C语言计算栈
• 2、栈的操作算法c语言实现
• 3、c语言 C语言 双向栈 算法

C语言计算栈

#include stdio.h

double readnumber(char a[],int *i)//将数字字符转变成相应的数

{

double x=0.0;

int k=0;

while(a[*i]=’0’a[*i]=’9′)

{

x=x*10+a[*i]-‘0’;

(*i)++;

}

if(a[*i]==’.’)

{

(*i)++;

while(a[*i]=’0’a[*i]=’9′)

{

x=x*10+a[*i]-‘0’;

(*i)++;

k++;

}

}

while(k!=0)

{

x=x/10.0;

k=k-1;

}

return x;

}

double yunsuan(char a[])//求一个后缀表达式的值

{

double obst[100],b,c;//操作数栈

int top=0,i=0;

while(a[i]!=’\0′)

{

if(a[i]=’0’a[i]=’9′)

obst[top++]=readnumber(a,i);

else if(a[i]==’ ‘) i++;

else if(a[i]==’+’)

{

b=obst[–top];

c=obst[–top];

obst[top++]=b+c;

i++;

}

else if(a[i]==’-‘)

{

b=obst[–top];

c=obst[–top];

obst[top++]=c-b;

i++;

}

else if(a[i]==’*’)

{

b=obst[–top];

c=obst[–top];

obst[top++]=b*c;

i++;

}

else if(a[i]==’/’)

{

b=obst[–top];

c=obst[–top];

obst[top++]=c/b;

i++;

}

}

return obst[0];

}

int pd(char op)//判断一个字符是不是运算符

{

switch(op)

{

case ‘+’:

case ‘-‘:

case ‘*’:

case ‘/’:return 1;

default :return 0;

}

}

int priority(char op)//求运算符的优先级

{

switch(op)

{

case ‘\0’:return -1;

case ‘(‘:return 0;

case ‘+’:

case ‘-‘:return 1;

case ‘*’:

case ‘/’:return 2;

default:return -1;

}

}

void charge(char a[],char b[])//将中缀表达式转换等价的后缀表达式

{

int i=0,j=0;

char opst[100];

int top,t;

top=0;

opst[top]=’\0′;

top++;

while(a[i]!=’\0′)

{

if(a[i]=’0’a[i]=’9’||a[i]==’.’)

b[j++]=a[i];//遇到数字和小数点直接写入后缀表达式

else if(a[i]=='(‘)//遇到左括号进入操作符栈

{

opst[top]=a[i];

top++;

}

else if(a[i]==’)’)

{

t=top-1;

while(opst[t]!='(‘)

{//'(‘之前出栈

b[j++]=opst[–top];

t=top-1;

}

top–;

}

else if(pd(a[i]))//’+’,’-‘,’*’,’/’

{

b[j++]=’ ‘;//用空格分开两个操作数

while(priority(opst[top-1])=priority(a[i]))

b[j++]=opst[–top];

opst[top]=a[i];

top++;

}

i++;

}

while(top) b[j++]=opst[–top];

}

int main()

{

char a[100],b[100];

double jieguo;

printf(“\n\t请输入算术表达式:”);

scanf(“%s”,a);

charge(a,b);

jieguo=yunsuan(b);

printf(“\t表达式运算的结果为:%lf”,jieguo);

return 0;

}

栈的操作算法c语言实现

#includeiostream

using namespace std;

#define STACK_INIT_SIZE 100

#define STACKINCREASE 1ypedef struct{

int *base;

int *top;

int stacksize;

}SqStack;

int InitStack (SqStack S)//构造空栈

{

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

if(!S.base)exit(OVERFLOW);//存储分配失败

S.top=S.base;

return 0;

}

int Push(SqStack S,int e)//插入新的元素为新的栈顶元素

{

if(S.top-S.base=S.stacksize)//z栈满，追加存储空间

{

S.base=(int *)realloc(S.base,(S.stacksize+STACKINCREASE)*sizeof(int));

if(!S.base)exit(OVERFLOW);//存储失败

S.top=S.base+S.stacksize;

S.stacksize+=STACKINCREASE;

}

*S.top++ =e;//认为是先赋值再加加？

return 0;

}

void Insert(SqStack S,int e)

{

int *p;

int temp;

p=S.base;

if(S.top-S.base=S.stacksize)//z栈满，追加存储空间

{

S.base=(int *)realloc(S.base,(S.stacksize+STACKINCREASE)*sizeof(int));

if(!S.base)exit(OVERFLOW);//存储失败

S.top=S.base+S.stacksize;

S.stacksize+=STACKINCREASE;

}

while(*p=e)

p++;

while(pS.top)

{

temp=*p;

*p=e;

e=temp;

p++;

}

}0

void Pop(SqStack S)

{

if(S.base==S.top)

cout”该栈是空栈”endl;

while(S.baseS.top)

{

cout*++S.base” “;

}

}

void main()

{

SqStack S;

int j,i;

InitStack(S);

for(i=1;i=5;i++)

{

cout”请输入”i”个栈内元素”endl;

cinj;

Push(S,j);

}

Pop(S);

cout”请输入你要插入的元素”endl;

cinj;

Insert(S,j);

cout”输出栈内元素”endl;

Pop(S);

}

c语言 C语言 双向栈 算法

#include stdio.h

#include stdlib.h

#include conio.h

#define MaxSize 1024

typedef struct stack {

int data[MaxSize];

int lp; // 左指针

int rp; // 右指针

}*STACK;

/*

栈指针总是指向待压入位置。初始时，(0#栈)左指针lp指向data[0]，即lp == 0;

(1#栈)右指针rp指向data[MaxSize – 1]，即rp == MaxSize – 1。当lp == rp时，

还有一个存储单元可用，所以栈满的条件是lp  rp。

*/

STACK InitStack() { // 置空双向栈

STACK S = (STACK)malloc(sizeof(struct stack));

S-lp = 0;

S-rp = MaxSize – 1;

return S;

}

int Full(STACK S) { // 判断是否满了

return S-lp  S-rp;

}

int Empty(STACK S, int number) { // 判断number栈是否为空

if(number  0 || number  1) {

printf(“不存在 #%d 栈。\n”,number);

return 1;

}

if(number) return (S-rp  MaxSize – 1); // 右栈

return S-lp  1; // 左栈

}

int Push(STACK S,int number,int e) { // 入栈

if(number  0 || number  1) {

printf(“不存在 #%d 栈。\n”,number);

return 0;

}

if(Full(S)) {

printf(“栈已满。\n”);

return 0;

}

if(number) S-data[S-rp–] = e;

else S-data[S-lp++] = e;

return 1;

}

 

int Pop(STACK S,int number,int *e) { // 出栈

if(number  0 || number  1) {

printf(“不存在 #%d 栈。\n”,number);

return 0;

}

if(Empty(S,number)) {

printf(“#%d 空栈已空。\n”,number);

return 0;

}

if(number == 0) *e = S-data[–S-lp];

else *e = S-data[++S-rp];

return 1;

}