栈-表达式求值

Naeioi Zhu — Sat, 22 Oct 2011 15:12:00 GMT

所谓表达式求值就是用计算机计算加减乘除式子，说的装逼一点，就是计算中缀表达式的值。
5 + ((1 + 2) * 4) − 3
我们把这个式子添上括号，保持计算顺序不变。
(5+((1+2)*4))-3)
运算符夹在数字中间，“中缀”之名由此得来。
人脑可以很快判断计算先后顺序，其实这个过程不是那么显然。因为*/+-有优先级，括号的加入又会打破这个规则。我们可以找出一个式子中最后进行的一步运算，对它的两边分别计算，在根据运算符进行合并。
(5+((1+2)*4))-3)

下面挂的代码是递归实现的。不要骂我标题党，不久会更新真正的栈实现代码，这需要时间，时间~再说递归才符合思维习惯，也更便于记忆~！//表达式求值（递归实现）

/*Author:naeioi
Prog:C++
Time:11.10.22
*/
#include
#include
using namespace std;

const int maxl=100;
char s[maxl];

#define isnum(a) (a>='0'&&a<='9')
#define isop(a) (a=='+'||a=='-'||a=='*'||a=='/')

int match(int i)
{
    int count=1;
    while(count!=0){
          i++;
          if(s[i]=='(') ++count;
          if(s[i]==')') --count;
    }
    return i;
}

int ston(int p)//下标从p开始
{
    int ans=0,positive=1;//符号
    if(s[p]=='-'){++p; positive=-1;}
    while(isnum(s[p])){
          ans*=10;
          ans+=s[p++]-'0';
    }
    return ans*positive;;
}

int div(int l,int r)//求l~r（下标）表示的式子的值
{
    while(s[l]=='('&&match(l)==r){++l; --r;}//去除多余括号。不能写成s[l]=='('&&s[r]=')'，形如(1+2)*(3+4)的式子会错误
    if(l>r) return 0;

    int pos,prior=3;//优先级，2==*/,1==+-
    for(int i=l;i<=r;i++){//找优先级最小的运算符
        if(s[i]=='(')
           if((i=match(i)+1)>r)
              break;
        if(s[i]=='*'||s[i]=='/')
        {  if(prior>=2){pos=i; prior=2;}}
        else if(s[i]=='+'||s[i]=='-')
                if(prior>=1&&i!=l&&!isop(s[i-1])){pos=i; prior=1;}//-接在运算符后时看成符号。否则看成减号
    }

    if(prior==3)//是一个数
       return ston(l);

    int a=div(l,pos-1),b=div(pos+1,r),ans;
    switch(s[pos])
    {
                  case '+':
                       ans=a+b;
                       break;
                  case '-':
                       ans=a-b;
                       break;
                  case '*':
                       ans=a*b;
                       break;
                  case '/':
                       ans=a/b;
                       break;
    }
    return ans;
}

int main()
{
    freopen("eval.in","r",stdin);
    freopen("eval.out","w",stdout);

    scanf("%s",s);

    printf("%d",div(0,strlen(s)-1));

    fclose(stdin);
    fclose(stdout);
    return 0;
}

Naeioi Zhu 2011-10-22 23:12 发表评论

基本数据结构-高精度

Naeioi Zhu — Fri, 21 Oct 2011 12:13:00 GMT

下个月NOIP复试。初三一年奋战中考直升考，OI基本停滞。暑假宅在家里沉静于异世界也没怎么打代码，只帮人调了几个简单的程序，手生疏得很。于是打算用剩下一个月时间复习基本代码，建立一个标准代码库，让自己重新熟悉那些最最经典的算法实现，同时也为日后编码提供方便。
这个标准代码库我都会亲自编码调试，努力保证正确性，力求简洁易读，注释完整。BUG在所难免，希望大家能在回复中帮助我改进XD.日后会不断更新各个方面（主要是涉及NOI）的基本代码。下面是预计的代码目录。
——————————————————————————————————————————————
1.基本数据结构
高精
二分

哈希（也算查找）
并查集
队列、栈
表达式计算

2.排序、查找
堆
快排
归并排序
选排、插排、冒排（冒牌………）
基数排序
3.图论
宽度、深度优先遍历
Dijkstra、Floyd
Prim、Kruskal
SPFA
最大流&最小最小费用最大流
4.其他
（未完待补充）
——————————————————————————————————————————————————
高精度模板（无压位）

//高精无压位
/*Author:naeioi
Prog:C++
Time:11-10-20
*/
#include <cstdio>
#include <string.h>
//#include
using namespace std;

const int maxlen=105+1;
#ifndef max
        #define max(a,b) ((a)>(b)?a:b)
#endif
/*结构说明
1.len代表实际长度
2.s[]从1开始逆序存储
3.默认长度105
*/
/*注意事项
1.一定要将clear()函数放在赋值函数头，将数据清零
2. 赋值运算符优先级低，跟比较运算符在一起注意打括号
3.基本函数定义形式
   Bign operator *(const Bign &b)const{}
   注意返回Bign以及那两个const防改写
4. 函数都应写在struct里面
*/

struct Bign{//函数后打//的是二级函数
       int len,s[maxlen];
       //函数部分
       //初始化
       void clear(){len=1;memset(s,0,sizeof(s));}//必要，赋值前必须清空
       Bign(){clear();}
       //赋值
       Bign operator = (const char *a){
            clear();//只需在此clear()，其他所有赋值函数都要调用它
            len=strlen(a);
            for(int i=1;i<=len;i++)
                    s[i]=a[len-i]-'0';
            return *this;
       }
       Bign operator = (int num){//用sprintf巧妙转化，减少代码量
            char tmp[maxlen];
            sprintf(tmp,"%d",num);
            return *this=tmp;
       }

       Bign(int num){*this=num;}//
       Bign(const char *a){*this=a;}//

       //运算符
       //c++备注：形参const表示不改变形参，末尾const表示不改变*this.运算返回bign供操作
        Bign operator + (const Bign &b)const{
             Bign c=*this;
             c.len=max(len,b.len);
             for(int i=1;i<=c.len;i++)
                     if((c.s[i]+=b.s[i]) >= 10){//!!!赋值运算符比比较运算符优先度低!!!
                        c.s[i+1]+=c.s[i]/10;
                        c.s[i]%=10;
                     }
             if(c.s[c.len+1]>0) c.len++;
             return c;
        }
        Bign operator += (const Bign &b){
             return (*this=*this+b);
        }//
        Bign operator + (int b)const{
             Bign t=b;
             return t+*this;
        }//
        Bign operator - (const Bign &b)const{//须保证b比*this小
             Bign c=*this;
             for(int i=1;i<=len;i++)
                     if((c.s[i]-=b.s[i]) < 0){
                        c.s[i+1]--;
                        c.s[i]+=10;
                     }
             while(c.s[c.len]==0) c.len--;
             return c;
        }
        Bign operator - (int b)const{
             Bign t=b;
             return *this-t;
        }//
        Bign operator * (const Bign &b)const{
             Bign c;
             c.len=len+b.len;

             for(int i=1;i<=len;i++)
                     for(int j=1;j<=b.len;j++)
                             if((c.s[i+j-1]+=s[i] * b.s[j]) >= 10){
                                c.s[i+j]+=c.s[i+j-1]/10;
                                c.s[i+j-1]%=10;
                             }
             if(c.s[c.len]==0) c.len--;
             return c;
        }
        Bign operator *= (const Bign &b){
             return (*this=*this*b);
        }//
        Bign operator / (int b)const{//必须整除（TODO:另用函数实现取余)
             Bign t=*this,c;
             c.len=len;
             for(int i=len;i>=1;i--){
                 t.s[i-1]+=(t.s[i]%b)*10;
                 c.s[i]=t.s[i]/b;
             }
             while(c.s[c.len]==0) c.len--;

             //remain=t.s[0];
             return c;
        }
        int operator % (int b)const{
             Bign t=*this,c;
             c.len=len;
             for(int i=len;i>=2;i--){
                 t.s[i-1]+=(t.s[i]%b)*10;
                 t.s[i-1]%=b;//优化防溢出
             }
             return t.s[1]%b;
        }
        //大小比较
        bool operator > (const Bign &b)const{
             if(len>b.len)
                 return 1;
             else if(len<b.len)
                     return 0;
             else{
                  for(int i=len;i>=1;i--)
                      if(s[i]>b.s[i])
                         return 1;
                  return 0;
             }
        }
        bool operator > (int b)const{
             Bign t=b;
             return *this>t;
        }//

        //输出并换行
        void print(){
             for(int i=len;i>=1;i--)
                     printf("%d",s[i]);
             printf("\n");
        }
};//OK

Naeioi Zhu 2011-10-21 20:13 发表评论

C++博客-Naeioi-随笔分类-标准代码库

栈-表达式求值

基本数据结构-高精度