栈的一些应用
1.数制转换
2.括号匹配
3.表达式求值
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include <stdlib.h>
#include <windows.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
char JJ[]={"0123456789ABCDEF"};
typedef struct tagWTNumber {
int intbits; /* 整数数位*/
int floatbits; /* 小数有效数位*/
char infinite; /* 无穷大*/
char sign; /* 符号*/
char intpart[1000]; /* 整数部分*/
char floatpart[1000]; /* 小数部分*/
} WTNumber;
typedef struct node
{
struct node *next;
char c;
double k;
char str[100];
}stack;
int IsEmpty(stack *s);
void Creatstack(stack **s);
void PushChar(stack **s,char c);
char PopChar(stack **s);
char GetTop(stack *s);
void Creatstack(stack **s);
void Push(stack **s,char *str);
char * Pop(stack **s);
char * Opera(char x, char *src1, char *src2);
int Precede(char src1,char src2);
void DisplayMenu();
void Convey();
void Calculate();
void MatchingCheck();
/* 算术函数指针类型.*/
typedef void (*PFNCALC)(const WTNumber* pn1,const WTNumber* pn2,WTNumber* pRes);
/* 初始化WTNumber为0.*/
void InitWTNumberToZero(WTNumber *pNum);
/* 判断需要多少个字符空间存储WTNumber转换的字符串.*/
int CharArrLenByWTNumber(const WTNumber* pNum);
/* 从字符串转换到WTNumber.*/
void CharArrToWTNumber(const char *arr,WTNumber *pNum);
/* 从WTNumber转换到字符串.*/
void WTNumberToCharArr(char *szBuf,const WTNumber *pNum);
/* 调节数位,删除最高整数位是0的和最低小数位是0的数位.*/
void AdjustBits(WTNumber *pNum);
/* 移动小数点,deta=0不移动,deta<0往左移动,deta>0往右移动.*/
void MoveFloatPoint(WTNumber *pNum,int deta);
/* 使无穷大 */
void MakeInfinite(WTNumber *pNum);
/* 根据算术函数返回结果 */
char *Result(const char *val1,const char *val2,PFNCALC pfnCalc);
/* 比较2个数大小 */
int WTCompare(const WTNumber* pn1,const WTNumber* pn2);
/* 判断是否为0 */
int IsZero(const WTNumber *pNum);
/* 加法*/
void WTAdd(const WTNumber* pn1,const WTNumber* pn2,WTNumber* pRes);
/* 乘法*/
void WTMultiply(const WTNumber* pn1,const WTNumber* pn2,WTNumber* pRes);
/* 减法*/
void WTSubtract(const WTNumber* pn1,const WTNumber* pn2,WTNumber* pRes);
/* 除法*/
void WTDivide(const WTNumber* pn1,const WTNumber* pn2,WTNumber* pRes);
///*/////////////////////////////////////////////////////////////////////
///*/////////////////////////////////////////////////////////////////////
///*/////////////////////////////////////////////////////////////////////
int main()
{
int choice;
while(1)
{
DisplayMenu();
scanf("%d",&choice);
switch(choice)
{
case 1:
Convey();
break;
case 2:
MatchingCheck();
break;
case 3:
Calculate();
break;
case 4:
exit (ERROR);
break;
default:
break;
}
}
return 0;
}
///*/////////////////////////////////////////////////////////////////////
///*/////////////////////////////////////////////////////////////////////
///*/////////////////////////////////////////////////////////////////////
int IsEmpty(stack *s)
{
return s->next == NULL;
}
void Creatstack(stack **s)
{
*s = (stack *)malloc(sizeof(stack));
if(*s == NULL)
{
printf("mermory error\n");
exit (0);
}
(*s)->next = NULL;
}
void Push(stack **s,char *str)
{
stack *temp;
temp = (stack *)malloc(sizeof(stack));
if(temp == NULL)
{
printf("mermory error\n");
exit (0);
}
strcpy(temp->str,str);
temp->next = (*s)->next;
(*s)->next = temp;
}
void PushChar(stack **s,char c)
{
stack *temp;
temp = (stack *)malloc(sizeof(stack));
if(temp == NULL)
{
printf("mermory error\n");
exit (0);
}
temp->c = c;
temp->next = (*s)->next;
(*s)->next = temp;
}
char PopChar(stack **s)
{
stack *temp;
char x;
temp = (*s)->next;
x = temp->c;
(*s)->next = (*s)->next->next;
free(temp);
return x;
}
char * Pop(stack **s)
{
stack *temp;
char *str;
temp = (stack *)malloc(sizeof(stack));
temp = (*s)->next;
str = (char *)malloc((strlen(temp->str) + 1)*sizeof(char) );
strcpy(str,temp->str);
(*s)->next = (*s)->next->next;
free(temp);
return str;
}
char GetTop(stack *s)
{
if(s->next == NULL)
{
printf("stack empty\n");
exit (0);
}
else
{
return s->next->c;
}
}
void DisplayMenu()
{
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_BLUE);
printf("|-------------------------------|\n");
printf("|\t1.数制转换 \t\t|\n");
printf("|\t2.括弧匹配\t\t|\n");
printf("|\t3.表达式求值\t\t|\n");
printf("|\t4.退出\t\t\t|\n");
printf("|-------------------------------|\n");
}
///*/////////////////////////////////////////////////////////////////////
///*/////////////////////////////////////////////////////////////////////
///*/////////////////////////////////////////////////////////////////////
///*/////////////////////////////////////////////////////////////////////
void Convey()
{
int src,dest;
stack *s;
int temp, flag = 0;
char t;
Creatstack(&s);
printf("请输入一个数字和要转换的进制(2-16): ");
scanf("%d %d",&src,&dest);
if(src == 0)
{
PushChar(&s,'0');
}
else
{
if(src < 0)
{
flag = 1;
src = - src;
}
while(src != 0)
{
temp = src % dest;
t = JJ[temp];
PushChar(&s,t);
src /= dest;
}
}
if(flag == 1)
{
printf("-");
}
while( !IsEmpty(s))
{
t = PopChar(&s);
printf("%c",t);
}
printf("\n\n");
}
void MatchingCheck()
{
char str[100], *p;
stack *s;
Creatstack(&s);
printf("请输入要检验的括号串,以#结束 \n");
scanf("%s",str);
p = str;
while(*p != '#')
{
switch(*p)
{
case '(':
case '{':
case '[':
PushChar(&s,*p);
break;
case ')':
if( GetTop(s) != '(' || IsEmpty(s))
{
printf("括号不匹配\n\n");
return ;
}
else
{
PopChar(&s);
}
break;
case ']':
if( GetTop(s) != '[' || IsEmpty(s))
{
printf("括号不匹配\n\n");
return ;
}
else
{
PopChar(&s);
}
break;
case '}':
if( GetTop(s) != '{' || IsEmpty(s))
{
printf("括号不匹配\n\n");
return ;
}
else
{
PopChar(&s);
}
break;
default :
break;
}
p++;
}
IsEmpty(s) ? printf("括号匹配! \n\n") : printf("括号不匹配\n\n") ;
}
void Calculate()
{
stack *oped;
stack *oper;
Creatstack(&oper);
Creatstack(&oped);
char str[1000],temp[1000], *a, *b, c,*p,s1[2];
PushChar(&oper,'#');
printf("请输入一段计算表达式，支持1000位大数和四则运算，以#结束\n");
scanf("%s", &str);
p = str;
strcpy(temp,"\0");
while( *p != '#' || GetTop(oper) != '#')
{
if( (*p <= '9' && *p >= '0' ) || *p == '.' )
{
s1[0] = *p;
s1[1] = '\0';
strcat(temp,s1);
p++;
if( !((*p <= '9' && *p >= '0' ) || *p == '.' ) )
{
Push(&oped,temp);
strcpy(temp,"\0");
}
}
else
{
switch(Precede(GetTop(oper),*p))
{
case -1:
PushChar(&oper, *p);
p++;
break;
case 0:
PopChar(&oper);
p++;
break;
case 1:
c = PopChar(&oper);
a = Pop(&oped);
b = Pop(&oped);
Push(&oped, Opera(c, b, a));
break;
}
}
}
printf("%s\n", Pop(&oped));
}
///#//////////////////////////////////////////////////////////////
///#//////////////////////////////////////////////////////////////
char * Opera(char x, char *src1, char *src2)
{
if(x == '+')
return Result(src1,src2,WTAdd);
else if(x == '-')
return Result(src1,src2,WTSubtract);
else if(x == '*')
return Result(src1,src2,WTMultiply);
else if(x == '/')
return Result(src1,src2,WTDivide);
}
int Precede(char src1,char src2)
{
int ret = 0;
switch(src1)
{
case '*':
case '/': if(src2 == '(' )
ret = -1;
else
ret = 1;
break;
case '+':
case '-': if(src2 == '(' || src2 == '*' || src2 =='/')
ret = -1;
else
ret = 1;
break;
case '(': if(src2 == ')')
ret = 0;
else
ret = -1;
break;
case ')': ret = 1;
break;
case'#': if(src2 == '#')
ret = 0;
else
ret = -1;
break;
default:
break;
}
return ret;
}
///#//////////////////////////////////////////////////////////////
///#//////////////////////////////////////////////////////////////
///#//////////////////////////////////////////////////////////////
///#//////////////////////////////////////////////////////////////
///#//////////////////////////////////////////////////////////////
///#//////////////////////////////////////////////////////////////
void InitWTNumberToZero(WTNumber *pNum)
{
memset(pNum,0,sizeof(WTNumber));
}
void AdjustBits(WTNumber *pNum)
{
while(pNum->intbits>1&&pNum->intpart[pNum->intbits-1]==0) pNum->intbits--;
while(pNum->floatbits&&pNum->floatpart[pNum->floatbits-1]==0) pNum->floatbits--;
}
void MoveFloatPoint(WTNumber *pNum,int deta)
{
/* deta<0则往左移动小数点,deta>0则向右移动小数点 */
if(deta)
{
WTNumber n=*pNum;
InitWTNumberToZero(pNum);
pNum->sign=n.sign;
if(deta<0)
{
int i;
deta=-deta;
for(i=deta;i<n.intbits;i++)
{
pNum->intpart[pNum->intbits++]=n.intpart[i];
}
for(i=deta-1;i>=0;i--)
{
pNum->floatpart[pNum->floatbits++]=n.intpart[i];
}
for(i=0;i<n.floatbits;i++)
{
pNum->floatpart[pNum->floatbits++]=n.floatpart[i];
}
}
else
{
int i;
for(i=deta;i<n.floatbits;i++) /* 处理小数部分*/
{
pNum->floatpart[pNum->floatbits++]=n.floatpart[i];
}
for(i=deta-1;i>=0;i--) /* 小数到整数的部分*/
{
pNum->intpart[pNum->intbits++]=n.floatpart[i];
}
for(i=0;i<n.intbits;i++) /* 整数部分*/
{
pNum->intpart[pNum->intbits++]=n.intpart[i];
}
}
}
AdjustBits(pNum);
}
int CharArrLenByWTNumber(const WTNumber* pNum)
{
int len = pNum->floatbits+pNum->intbits+1;
if(pNum->intbits==0) len++; /* .1 --> 0.1*/
if(pNum->floatbits) len++; /* '.'*/
if(pNum->sign) len++; /* '-'*/
if(pNum->infinite) return 11; /* #INFINITE */
return len;
}
void CharArrToWTNumber(const char *arr,WTNumber *pNum)
{
char *point;
InitWTNumberToZero(pNum);
if(*arr=='-') /* 如果是负数*/
{
arr++;
pNum->sign=1;
}
point=strchr(arr,'.');
if(point) /* 找到小数点 */
{
int n=pNum->intbits=point-arr; /* 计算出整数数位 */
while(n) /* 整数数位不==0则循环 */
{
pNum->intpart[pNum->intbits-n]=arr[n-1]-'0'; /* 将数字低位存在低下标元素*/
n--;
}
while(*++point)
{
pNum->floatpart[pNum->floatbits]=*point-'0';
pNum->floatbits++;
}
}
else /* 说明没写小数点,全是整数.*/
{
int n=pNum->intbits=strlen(arr);
while(n)
{
pNum->intpart[pNum->intbits-n]=arr[n-1]-'0';
n--;
}
}
AdjustBits(pNum);
/* 处理-0 和0的情况*/
if(pNum->floatbits==0)
{
if(pNum->intbits==0 || pNum->intbits==1&&pNum->intpart[0]==0)
pNum->sign=0;
}
}
void WTNumberToCharArr(char *szBuf,const WTNumber* pNum)
{
int n=pNum->intbits,c;
memset(szBuf,0,CharArrLenByWTNumber(pNum));
if(pNum->sign) /* 如果是负数*/
{
*szBuf++='-';
}
if(pNum->infinite)
{
strcat(szBuf,"#INFINITE");
return;
}
while(n)
{
szBuf[pNum->intbits-n]=pNum->intpart[n-1]+'0';
n--;
}
c=0; /* 是否加了0*/
if(pNum->intbits==0) {
strcat(szBuf,"0");
c=1;
}
if(pNum->floatbits) strcat(szBuf,".");
n=0;
while(n<pNum->floatbits)
{
szBuf[pNum->intbits+1+n+c]=pNum->floatpart[n]+'0';
n++;
}
}
char *Result(const char *val1,const char *val2,PFNCALC pfnCalc)
{
static char *s_szRes=NULL;
WTNumber n1,n2,res;
if(s_szRes) {
/*delete [] s_szRes;*/
free(s_szRes);
s_szRes=NULL;
}
CharArrToWTNumber(val1,&n1);
CharArrToWTNumber(val2,&n2);
pfnCalc(&n1,&n2,&res);
/* s_szRes = new char[CharArrLenByWTNumber(&res)];*/
s_szRes=(char*)malloc(CharArrLenByWTNumber(&res)*sizeof(char));
WTNumberToCharArr(s_szRes,&res);
return s_szRes;
}
int WTCompare(const WTNumber* pn1,const WTNumber* pn2)
{
/* 首先是比较符号*/
if(pn1->sign==0&&pn2->sign!=0) /* pn1是正数,pn2是负数*/
return 1; /* >*/
else if(pn1->sign!=0&&pn2->sign==0) /* pn1是负数,pn2是正数*/
return -1; /* <*/
else /* 同号状态*/
{
/* 比较整数部分*/
if(pn1->intbits>pn2->intbits) /* pn1整数数位多*/
return pn1->sign?-1:1;
else if(pn1->intbits<pn2->intbits)
return pn1->sign?1:-1;
else /* 整数数位相同*/
{
int i=pn1->intbits-1; /*指到最高位*/
while(i>=0)
{
if(pn1->intpart[i]>pn2->intpart[i])
return pn1->sign?-1:1;
else if(pn1->intpart[i]<pn2->intpart[i])
return pn1->sign?1:-1;
else i--;
}
/* 整数部分相同,比较小数部分*/
for(i=0;i<pn1->floatbits&&i<pn2->floatbits;)
{
if(pn1->floatpart[i]>pn2->floatpart[i])
return pn1->sign?-1:1;
else if(pn1->floatpart[i]<pn2->floatpart[i])
return pn1->sign?1:-1;
else i++;
}
if(i<pn1->floatbits) return pn1->sign?-1:1;
if(i<pn2->floatbits) return pn1->sign?1:-1;
return 0; /* 相等*/
}
}
}
void MakeInfinite(WTNumber *pNum)
{
pNum->infinite=1;
}
int IsZero(const WTNumber* pNum)
{
if(pNum->floatbits==0&&pNum->intbits==0) return 1;
if(pNum->floatbits==0&&pNum->intbits==1&&pNum->intpart[0]==0) return 1;
return 0;
}
void WTAdd(const WTNumber* pn1,const WTNumber* pn2,WTNumber* pRes)
{
InitWTNumberToZero(pRes);
if(pn1->sign^pn2->sign) /*异号*/
{
WTNumber n2=*pn2;
n2.sign=pn1->sign;
WTSubtract(pn1,&n2,pRes);
}
else /*同号*/
{
int maxfloatbits=pn1->floatbits>pn2->floatbits?pn1->floatbits:pn2->floatbits;
int addbit=0; /* 进位值*/
int i,j;
for(i=maxfloatbits-1;i>=0;i--)
{
int value=pn1->floatpart[i]+pn2->floatpart[i]+addbit;
addbit=value/10; /* 看看是否超过10. 设置进位值*/
pRes->floatpart[i]=value%10;
}
pRes->floatbits=maxfloatbits;
/* 到此,小数部分计算完毕.*/
for(j=0;j<pn1->intbits||j<pn2->intbits;j++)
{
int value=pn1->intpart[j]+pn2->intpart[j]+addbit;
addbit=value/10;
pRes->intpart[j]=value%10;
pRes->intbits++;
}
if(addbit>0)
{
pRes->intpart[j]=addbit;
pRes->intbits++;
}
pRes->sign=pn1->sign; /*决定符号*/
AdjustBits(pRes);
}
}
void WTMultiply(const WTNumber* pn1,const WTNumber* pn2,WTNumber* pRes)
{
WTNumber z1=*pn1,z2=*pn2;
WTNumber sum={0};
int i,j;
InitWTNumberToZero(pRes);
MoveFloatPoint(&z1,z1.floatbits);
MoveFloatPoint(&z2,z2.floatbits);
/* 计算z1*z2 */
for(i=0;i<z2.intbits;i++)
{
WTNumber tmp={0}; /* 存放临时乘积*/
int addbit=0;
tmp.intbits=z1.intbits+i;
for(j=0;j<z1.intbits;j++)
{
int value = z2.intpart[i]*z1.intpart[j]+addbit;
addbit=value/10;
tmp.intpart[j+i]=value%10;
}
if(addbit)
{
tmp.intpart[j+i]=addbit;
tmp.intbits++;
}
WTAdd(&sum,&tmp,pRes);
sum=*pRes;
}
*pRes=sum;
MoveFloatPoint(pRes,-(pn1->floatbits+pn2->floatbits));
/* 判断符号,异号为负*/
if(pn1->sign^pn2->sign) pRes->sign=1;
}
void WTSubtract(const WTNumber* pn1,const WTNumber* pn2,WTNumber* pRes)
{
InitWTNumberToZero(pRes);
if(pn1->sign^pn2->sign) /* 异号情况*/
{
WTNumber n2=*pn2;
n2.sign=pn1->sign;
WTAdd(pn1,&n2,pRes);
}
else /* 同号情况*/
{
int cmp=WTCompare(pn1,pn2);
int swapflag,i,maxfloatbits,subtractbit;
if(cmp==0) return; /* 相等就没必要再减了.*/
swapflag=pn1->sign==0?cmp==-1:cmp==1;
if(swapflag)
{
const WTNumber* p=pn1;
pn1=pn2;
pn2=p;
}
maxfloatbits=pn1->floatbits>pn2->floatbits?pn1->floatbits:pn2->floatbits;
subtractbit=0; /* 退位值*/
/* 先计算小数部分*/
for(i=maxfloatbits-1;i>=0;i--)
{
if(pn1->floatpart[i]-subtractbit<pn2->floatpart[i])
{
int value=pn1->floatpart[i]-pn2->floatpart[i]-subtractbit+10;
subtractbit=1;
pRes->floatpart[i]=value;
}
else
{
int value=pn1->floatpart[i]-pn2->floatpart[i]-subtractbit;
subtractbit=0;
pRes->floatpart[i]=value;
}
}
pRes->floatbits=maxfloatbits;
/* 至此小数部分计算完毕.*/
for(i=0;i<pn1->intbits||i<pn2->intbits;i++)
{
if(pn1->intpart[i]-subtractbit<pn2->intpart[i])
{
int value=pn1->intpart[i]-pn2->intpart[i]-subtractbit+10;
subtractbit=1;
pRes->intpart[i]=value;
}
else
{
int value=pn1->intpart[i]-pn2->intpart[i]-subtractbit;
subtractbit=0;
pRes->intpart[i]=value;
}
pRes->intbits++;
}
pRes->sign=swapflag?!pn1->sign:pn1->sign; /*决定符号*/
AdjustBits(pRes);
}
}
void WTDivide(const WTNumber* pn1,const WTNumber* pn2,WTNumber* pRes)
{
WTNumber z1=*pn1,z2=*pn2;
int deta=z2.floatbits-z1.floatbits;
MoveFloatPoint(&z1,z1.floatbits);
MoveFloatPoint(&z2,z2.floatbits);
InitWTNumberToZero(pRes);
if(IsZero(pn1)) return ;
if(IsZero(pn2)) {
pRes->sign=pn1->sign;
MakeInfinite(pRes);
return ;
}
z1.sign=z2.sign=0; /*统一符号,便于比较大小*/
while(z1.intbits!=z2.intbits) { /*确保数位相等,这步耗费很多时间*/
if(z1.intbits<z2.intbits) {
MoveFloatPoint(&z1,1);
deta--;
} else {
MoveFloatPoint(&z2,1);
deta++;
}
}
while(pRes->floatbits<(1000/2)) {
int cmp=WTCompare(&z1,&z2);
int n=10;
WTNumber mulres={0},subres={0};
if(cmp==-1) { /*z1<z2*/
MoveFloatPoint(&z1,1);
pRes->floatpart[pRes->floatbits++]=0;
continue;
} else if(cmp==0) { /*z1==z2*/
pRes->floatpart[pRes->floatbits++]=1;
break;
}
do { /*找商*/
WTNumber tmp={0};
tmp.intpart[0]=--n;
tmp.intbits=1;
WTMultiply(&z2,&tmp,&mulres);
} while((cmp=WTCompare(&mulres,&z1))==1);
pRes->floatpart[pRes->floatbits++]=n;
if(cmp==0) break;
WTSubtract(&z1,&mulres,&subres);
MoveFloatPoint(&subres,1);
z1=subres;
}
MoveFloatPoint(pRes,1);
MoveFloatPoint(pRes,deta);
/* 判断符号,异号为负*/
if(pn1->sign^pn2->sign) pRes->sign=1;
}
