c語言堆棧實現
A. c語言中如何用堆棧實現個位數的四則運算(不帶括弧也可）
#include<iostream>
#include<stdio.h>
#include<math.h>
#define MaxSize 100
using namespace std;
//下面兩個函數不是我發明的，數據結構上有
void trans(char*exp,char postexp[])//此函數是將中綴表達式轉後綴表達式，利用棧
{
char *temp=exp;
for(;*temp!='\0';temp++){if(*temp=='a')*temp='1';}
struct
{
char data[MaxSize];
int top;
}op;
int i=0;
op.top=-1;
while(*exp!='\0')
{
switch(*exp)
{
case '(':
op.top++;op.data[op.top]=*exp;
exp++;
break;
case ')':
while(op.data[op.top]!='(')
{
postexp[i++]=op.data[op.top];
op.top--;
}
op.top--;
exp++;
break;
case '+':
case '-':
while(op.top!=-1&&op.data[op.top]!='(')
{
postexp[i++]=op.data[op.top];
op.top--;
}
op.top++;op.data[op.top]=*exp;
exp++;
break;
case '*':
case '/':
while(op.data[op.top]=='*'||op.data[op.top]=='/'||op.data[op.top]=='^')
{
postexp[i++]=op.data[op.top];
op.top--;
}
op.top++;op.data[op.top]=*exp;
exp++;
break;
case '^':
while(op.data[op.top]=='^')
{
postexp[i++]=op.data[op.top];
op.top--;
}
op.top++;op.data[op.top]=*exp;
exp++;
break;
case ' '://這里考慮空格了
exp++;
break;
default:
while(*exp>='0'&&*exp<='9')
{
postexp[i++]=*exp;
exp++;
}
postexp[i++]='#';
}
}
while(op.top!=-1)
{
postexp[i++]=op.data[op.top];
op.top--;
}
postexp[i]='\0';
}
float compvalue(char *postexp)//此函數利用棧對後綴表達式求值
{
struct
{
float data[MaxSize];
int top;
}st;
float d,a,b,c;
st.top=-1;
while(*postexp!='\0')
{
switch(*postexp)
{
case '+':
a=st.data[st.top];
st.top--;
b=st.data[st.top];
st.top--;
c=a+b;
st.top++;
st.data[st.top]=c;
break;
case '-':
a=st.data[st.top];
st.top--;
b=st.data[st.top];
st.top--;
c=b-a;
st.top++;
st.data[st.top]=c;
break;
case '*':
a=st.data[st.top];
st.top--;
b=st.data[st.top];
st.top--;
c=a*b;
st.top++;
st.data[st.top]=c;
break;
case '/':
a=st.data[st.top];
st.top--;
b=st.data[st.top];
st.top--;
c=b/a;
st.top++;
st.data[st.top]=c;
break;
case '^':
a=st.data[st.top];
st.top--;
b=st.data[st.top];
st.top--;
c=pow(b,a);
st.top++;
st.data[st.top]=c;
break;
default:
d=0;
while(*postexp>='0'&&*postexp<='9')
{
d=10*d+*postexp-'0';
postexp++;
}
st.top++;
st.data[st.top]=d;
break;
}
postexp++;
}
return(st.data[st.top]);
}
int main()
{
char exp[50],postexp[50],output[50];
int temp,n;
char *X=output,*Y=exp;//臨時指針
memset(output,0,50);//這句將全部數組元素置為零
memset(exp,0,50);
cout<<"input:"<<endl;
cin.getline(exp,50);
trans(exp,postexp);
temp=compvalue(postexp);
cin>>n;
fflush(stdin);
for(int i=0;i<n;i++)
{
memset(exp,0,50);
cin.getline(exp,50);
trans(exp,postexp);
if(temp==compvalue(postexp)){*X='A'+i;X++;}//通過指針X來逐個向output元素賦值
}
cout<<"output:"<<endl;
cout<<output<<endl;
return 0;
}
B. 用堆棧來實現四則運算.（C語言）
here it is，1個半小時才搞定的，好辛苦，呵呵：
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
double var[1024];
char opt[1024];
double* sp1 = var;
char* sp2 = opt;
#define PUSH(s, v) (*s++ = v)
#define POP(s) (*--s)
#define EMPTY1() (sp1 == var)
#define EMPTY2() (sp2 == opt)
#define TOP(s) (s[-1])
#define isopt1(c) (c == '+' || c == '-')
#define isopt2(c) (c == '*' || c == '/')
#define isopt(c) (isopt1(c) || isopt2(c))
#define isbkt(c) (c == '(')
double docal(double lhs, double rhs, char op)
{
switch(op) {
case '+':return lhs + rhs;
case '-':return lhs - rhs;
case '*':return lhs * rhs;
}
if(op == '/' && rhs == 0) {
printf("divided by zero encountered.\n");
exit(0);
}
return lhs / rhs;
}
void eval1(char* expr)
{
double t1, t2;
while(sp1 - var > 1 && !EMPTY2() && TOP(sp2) != '(') {
t2 = POP(sp1);
t1 = POP(sp1);
PUSH(sp1, docal(t1, t2, POP(sp2)));
}
if(expr)
PUSH(sp2, *expr);
}
void eval2(char* expr)
{
double t1, t2;
while(TOP(sp2) != '(') {
t2 = POP(sp1);
t1 = POP(sp1);
PUSH(sp1, docal(t1, t2, POP(sp2)));
}
POP(sp2);
}
double parse(char* expr)
{
double val;
while(*expr) {
if(isdigit(*expr)) {
sscanf(expr, "%lf", &val);
PUSH(sp1, val);
while(isdigit(*expr) || *expr == '.')
++expr;
--expr;
} else if(isopt(*expr)) {
if(EMPTY2() || (isopt1(TOP(sp2)) && !isopt1(*expr)) || isbkt(TOP(sp2)))
PUSH(sp2, *expr);
else if(isopt(TOP(sp2)))
eval1(expr);
} else if(*expr == '(') {
PUSH(sp2, *expr);
}
C. c語言怎麼用堆棧實現多項式的加法運算
//已經幫忙調整，對比下代碼吧，就知道是什麼問題了
typedefstructPolyNode*Polynomial;
structPolyNode{
intcoef;
intexpon;
Polynomiallink;
};
PolynomialReadPoly();
PolynomialPolyAdd(PolynomialP1,PolynomialP2);
voidAttach(intc,inte,Polynomial*pRear);
intCompare(intp1,intp2);//未定義函數，自己寫實現
intmain()
{
PolynomialP1,P2,PP,PS;
P1=ReadPoly();
P2=ReadPoly();
// PP=Mult(P1,P2);
// PrintPoly(PP);
PS=PolyAdd(P1,P2);
// PrintPoly(PS);
return0;
}
PolynomialReadPoly()
{
PolynomialP,Rear,t;
intc,e,N;
scanf("%d",&N);
P=(Polynomial)malloc(sizeof(structPolyNode));
P->link=NULL;
Rear=P;
while(N--){
scanf("%d%d",&c,&e);
Attach(c,e,&Rear);
}
t=P;P=P->link;
free(t);
//retrunP;//return寫錯
returnP;
}
voidAttach(intc,inte,Polynomial*pRear)
{
PolynomialP;
P=(Polynomial)malloc(sizeof(structPolyNode));
P->coef=c;
P->expon=e;
P->link=NULL;
(*pRear)->link=P;
*pRear=P;
}
PolynomialPolyAdd(PolynomialP1,PolynomialP2)
{
Polynomialfront,rear,temp;
intsum;
rear=(Polynomial)malloc(sizeof(structPolyNode));
front=rear;
while(P1&&P2);
switch(Compare(P1->expon,P2->expon)){//這里要用指針->
case1:
Attach(P1->coef,P1->expon,&rear);//這里要用指針->
P1=P1->link;
break;
case-1:
Attach(P2->coef,P2->expon,&rear);//這里要用指針->
P2=P2->link;
break;
case0:
sum=P1->coef+P2->coef;//這里要用指針->
if(sum)Attach(sum,P1->expon,&rear);//這里要用指針->
P1=P1->link;
P2=P2->link;
break;
}
for(;P1;P1=P1->link)Attach(P1->coef,P1->expon,&rear);
for(;P2;P2=P2->link)Attach(P2->coef,P2->expon,&rear);
rear->link=NULL;
temp=front;
front=front->link;
free(temp);
returnfront;
}
D. C語言，棧的實現~
你寫的太復雜，這個拿去用吧
// Stack node
struct Node
{
int data ;
Node* next ;
Node(int d, Node* p):data(d), next(p){}
};
class Stack
{
public:
Stack():top(NULL){}
void Push(int d)
{
top = new Node(d, top) ;
}
int Pop()
{
Node* temp = top ;
top = top->next ;
return temp->data ;
}
bool Empty()
{
return top == NULL ;
}
private:
Node* top ;
};
E. C語言問題,利用堆棧實現四則運算,謝謝高手幫我編寫出來
我就喜歡害人：）
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#defineERR-1
#defineMAX100/*定義堆棧的大小*/
intstack[MAX];/*用一維數組定義堆棧*/
inttop=0;/*定義堆棧指示*/
intpush(inti)/*存儲運算數,入棧操作*/
{
if(top<MAX)
{
stack[++top]=i;/*堆棧仍有空間，棧頂指示上移一個位置*/
return0;
}
else
{
printf("Thestackisfull");
returnERR;
}
}
intpop()/*取出運算數，出棧操作*/
{
intvar;/*定義待返回的棧頂元素*/
if(top!=NULL)/*堆棧中仍有元素*/
{
var=stack[top--];/*堆棧指示下移一個位置*/
returnvar;/*返回棧頂元素*/
}
else
printf("Thestackisempty!\n");
returnERR;
}
voidmain()
{
intm,n;
charl;
inta,b,c;
intk;
do{
printf("\tAriothmaticOperatesimulator\n");/*給出提示信息*/
printf("\n\tPleaseinputfirstnumber:");/*輸入第一個運算數*/
scanf("%d",&m);
push(m);/*第一個運算數入棧*/
printf("\n\tPleaseinputsecondnumber:");/*輸入第二個運算數*/
scanf("%d",&n);
push(n);/*第二個運算數入棧*/
printf("\n\tChooseoperator(+/-/*//):");
l=getche();/*輸入運算符*/
switch(l)/*判斷運算符，轉而執行相應代碼*/
{
case'+':
b=pop();
a=pop();
c=a+b;
printf("\n\n\tTheresultis%d\n",c);
printf("\n");
break;
case'-':
b=pop();
a=pop();
c=a-b;
printf("\n\n\tTheresultis%d\n",c);
printf("\n");
break;
case'*':
b=pop();
a=pop();
c=a*b;
printf("\n\n\tTheresultis%d\n",c);
printf("\n");
break;
case'/':
b=pop();
a=pop();
c=a/b;
printf("\n\n\tTheresultis%d\n",c);
printf("\n");
break;
}
printf("\tContinue?(y/n):");/*提示用戶是否結束程序*/
l=getche();
if(l=='n')
exit(0);
}while(1);
}
F. 用C語言代碼來編寫含漢諾塔問題,利用堆棧來實現.求代碼
演算法思想
對於漢諾塔問題，當只移動一個圓盤時，直接將圓盤從 A 針移動到 C 針。若移動的圓盤為 n(n>1)，則分成幾步走：把 (n-1) 個圓盤從 A 針移動到 B 針（藉助 C 針）；A 針上的最後一個圓盤移動到 C 針；B 針上的 (n-1) 個圓盤移動到 C 針（藉助 A 針）。每做一遍，移動的圓盤少一個，逐次遞減，最後當 n 為 1 時，完成整個移動過程。
因此，解決漢諾塔問題可設計一個遞歸函數，利用遞歸實現圓盤的整個移動過程，問題的解決過程是對實際操作的模擬。
程序代碼
#include <stdio.h>
int main()
{
int hanoi(int,char,char,char);
int n,counter;
printf("Input the number of diskes：");
scanf("%d",&n);
printf("\n");
counter=hanoi(n,'A','B','C');
return 0;
}
int hanoi(int n,char x,char y,char z)
{
int move(char,int,char);
if(n==1)
move(x,1,z);
else
{
hanoi(n-1,x,z,y);
move(x,n,z);
hanoi(n-1,y,x,z);
}
return 0;
}
int move(char getone,int n,char putone)
{
static int k=1;
printf("%2d:%3d # %c---%c\n",k,n,getone,putone);
if(k++%3==0)
printf("\n");
return 0;
}
G. 怎麼用C語言編寫堆棧並能進行四則運算
3個文件，按您的要求
頭文件H
＃IFNDEF _XXXX_H
＃定義_XXXX_H
＃定義錯誤-1
＃定義MAX 100 / *定義堆棧的大小* /
靜態int堆棧[MAX]; / *定義一個一維數組堆棧* /
靜態int top = 0的; / *自定義堆棧指令* /
詮釋推（int i）的;
的pop（）;
＃ENDIF / * _XXXX_H * /
功能文件CPP
＃包括「xxxx.h」的
詮釋推（I）/ *內存操作數棧操作* /
{
？？（頂部<MAX）
？？？
？？？？棧[+ +頂部] = I / *棧，仍然有空間的堆棧頂部的表示移動一個位置* /
？？？？返回0;
？？}
？？其他
？？？
？？？？printf的（「堆棧滿了」）;
？？？？返回錯誤;
？？}
}
POP（）/ *刪除的操作數，並彈出操作* /
{
？？VAR; / *定義要返回的頂級元素* /
？？如果（top! = NULL）/ *仍然堆放元素* /
？？？
？？？？VAR =棧[ - ] / *堆棧指針向下移動一個位置* /
？？？？返回VAR / *返回的頂部堆棧元素* /
？？}
？？其他
？？？？printf的（「堆棧是空的！\ n」）;
？？返回錯誤;
}
主文件CPP
＃包括<stdio.h>
＃包括<conio.h>
＃包括<stdlib.h>
＃包括「xxxx.h」的
無效的主要（）
{
？？INT M，N;
？？字元L;
？？整數A，B，C;
？？整數K;
？？{
？？？？輸出（「\ n \ n \ t單擊以下提示輸入你需要的信息\ n」）;
？？？？輸出（「\ n \問你輸入第二個搗弄數字」）;
？？？？scanf的（「％d」，＆M）;
？？？？推（M）/ *第一個操作數堆棧* /
？？？？輸出（「\ n \問你輸入第二個搗弄數字」）;
？？？？scanf的（「％d」，＆N）;
？？？？推（N）; / *第二個操作數堆棧* /
？？？？輸出（「\ n \你不想算術運算（+ / - / * / /）：」）;
？？？？L = getche（）; / *輸入操作符* /
？？？？開關（L）/ *確定的運營商，依次執行代碼* /
？？？？
？？？？？？'+'：
？？？？？？？？= pop（）方法;
？？？？？？？？= pop（）方法;
？？？？？？？？C = A + B;
？？？？？？？？輸出（「\ n \ n \ t計算公式為：％d條\ n」，c）;
？？？？？？？？輸出（「\ n」）;
？？？？？？？？;
？？？？？？情況下，' - '：
？？？？？？？？= pop（）方法;
？？？？？？？？= pop（）方法;
？？？？？？？？C = A-B;
？？？？？？？？輸出（「\ n \ n \ t計算公式為：％d條\ n」，c）;
？？？？？？？？輸出（「\ n」）;
？？？？？？？？;
？？？？？？情況下，'*'：
？？？？？？？？= pop（）方法;
？？？？？？？？= pop（）方法;
？？？？？？？？C = A * B;
？？？？？？？？輸出（「\ n \ n \ t計算公式為：％d條\ n」，c）;
？？？？？？？？輸出（「\ n」）;
？？？？？？？？;
？？？？？？情況下，'/'：
？？？？？？？？= pop（）方法;
？？？？？？？？= pop（）方法;
？？？？？？？？C = A / B;
？？？？？？？？輸出（「\ n \ n \ t計算公式為：％d條\ n」，c）;
？？？？？？？？輸出（「\ n」）;
？？？？？？？？;
？？？？}
？？？？輸出（「\ t要繼續輸入計算嗎？（Y / N）：」）; / *提示用戶是否在程序結束* /
？？？？L = getche（）;
？？？？（L =='N'）
？？？？？？退出（0）;
？？}（1）;
}
H. 棧的c語言實現基本操作
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#definestack_init_size20
#defineincreasesize10;
typedefintElemType;
typedefstructnode{
ElemType*base;
ElemType*top;
intsize;
}stack;
voidcreat(stack*s)
{
s->base=(ElemType*)malloc(sizeof(ElemType));
if(!s->base)
{
exit(0);
}
s->base=s->top;
s->size=stack_init_size;
}
voidpush(stack*s,ElemTypee)
{
if(s->top-s->base>=s->size)
{
s->base=(ElemType*)realloc(s->base,(s->size+increasesize)*sizeof(ElemType));
if(!s->base)
{
exit(0);
}
s->top=s->base+s->size;
s->size+=increasesize;
}
*(s->top)=e;
s->top++;
}
voidpop(stack*s,ElemType*e)
{
if(s->top==s->base)
{
return;
}
*e=*--(s->top);
}
intstacklen(stacks)
{
return(s.top-s.base);
}
intmain()
{
stacks;
intn;
ElemTypee1,e2,d;
inti=1,j=1;
push(&s,i);
push(&s,j);
scanf("%d",&n);
while(n--)
{
pop(&s,&e1);
pop(&s,&e2);
d=e1+e2;
push(&s,e2);
push(&s,d);
}
pop(&s,&d);
printf("%d",d);
return0;
}
I. c語言堆棧編程實現問題
修改完成：
#define MAXLEN 1000
#define EMPTY -1
#define FULL (MAXLEN-1)
#include <stdio.h>
typedef enum boolean
{
false, true
} boolean;
typedef struct stack
{
char s[MAXLEN];
int top;
} stack;
void reset(stack *stk)
{
stk->top = EMPTY;
}
void push(char c, stack *stk)
{
stk->top++;
stk->s[stk->top] = c;
}
char pop(stack *stk)
{
return (stk->s[stk->top--]);
}
void top(const stack *stk)
{
stk->s[stk->top];
}
boolean empty(const stack *stk)
{
return((boolean)(stk->top==EMPTY));
}
boolean full(const stack *stk)
{
return((boolean)(stk->top==FULL));
}
int main(void)
{
char str[] = "my name is laura";
int i;
stack s;
reset(&s);
printf("in the string: %s\n", str);
for (i = 0; str[i] != '\0'; ++i)
if(!full(&s))
push(str[i],&s);
printf("from the stack: ");
while (!empty(&s))
putchar(pop(&s));
putchar('\n');
return 0;
}
J. C語言實現堆棧
做個簡單的例子，其他功能可以自己完善~ typedef struct
{
char *mem ;
int size ;
int poz ;
} Stack ;
Stack *CreateStack(int size)
{
Stack *stack ;
stack = (Stack *)malloc(sizeof (Stack)) ;
if (!stack) return 0 ;
stack->mem = (char *)malloc(size) ;
if (!stack->mem)
{
free(stack) ;
return 0 ;
}
stack->size = size ;
stack->poz = size - 1 ;
return stack ;
}
int ReleaseStack(Stack *stack)
{
if (!stack) return 0 ;
if (stack->mem)
free(stack->mem) ;
stack->mem = 0 ;
stack->size = 0 ;
stack->poz = -1 ;
return 0 ;
}
int Push(Stack *stack, void *souce, int size)
{
int p ;
if (!stack) return 0 ;
if (!stack->mem) return 0 ;
if (stack->poz + 1 < size) return 0 ;
stack->poz -= size ;
for (p = 0 ; p < size ; p++)
stack->mem[stack->poz + p] = ((char *)souce)[p] ;
return 1 ;
}
int Pop(Stack *stack, void *target, int size)
{
int p ;
if (!stack) return 0 ;
if (!stack->mem) return 0 ;
if (stack->poz + 1 == stack->size) return 0 ;
for (p = 0 ; p < size ; p++)
((char *)target)[p] = stack->mem[stack->poz + p] ;
stack->poz += size ;
return 1 ;
}
int PushInt(Stack *stack, int source)
{
return Push(stack, &source, sizeof (int)) ;
}
int PopInt(Stack *stack, int *target)
{
return Pop(stack, target, sizeof (int)) ;
}
void main( )
{
int i ;
Stack *stack = CreateStack(100) ;
for (i = 0 ; i < 10 ; i++)
PushInt(stack, i) ;
for (i = 0 ; i < 10 ; i++)
{
int n ;
PopInt(stack, &n) ;
printf("%d\n", n) ;
}
getch( ) ;
}