【数据结构】用栈实现的带括号的多位数四则运算器

题目原型: 四则运算器:实现多位整数的带括号的四则运算

现存问题:

1.以下代码利用两个char类型的栈分别存取运算数和运算符,但在结束一次优先级高运算后(考虑到运算精度问题,故在程序中,将每次运算的结果都保存为double型)可能会出现浮点值,这个值必须要压栈,并于下一个优先级产生运算,但这个浮点型值无法压入char型栈中,必须要一位一位存取才可实现,请问有没有比较好的办法解决这个问题,应该怎样将数据压入栈中?

2.程序中出现如图所示错误,麻烦大佬指点一下原因!图片说明

 #include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#define Stack_Size 50

typedef char StackElementType; 
typedef struct
{
    StackElementType elem[Stack_Size];
    int Top;
}SeqStack; 

void InitStack(SeqStack *S);
int Push(SeqStack *S,StackElementType x);
int Pop(SeqStack *S,StackElementType *x);
int GetTop(SeqStack *S,StackElementType *x);
StackElementType Compare(StackElementType ch1,StackElementType ch2);
StackElementType Execute(StackElementType a,StackElementType op,StackElementType b);

int main()
{
    printf("%c",ExpEvaluation()); 
    return(0);
}
StackElementType ExpEvaluation()
{
    SeqStack OPTR,OVS;
    StackElementType n;
    StackElementType a,b,ch,op,x,v;
    InitStack(&OPTR);
    InitStack(&OVS);
    Push(&OPTR,'#');
    printf("Please input an expression(Ending with #):");
    ch=getchar();//为方便,所以数字也以字符形式来存储 
    while(ch!='#'||GetTop(&OPTR,&x)!='#')
    {
        if(ch>='0'&&ch<='9')//不是操作符,是操作数,进OVS栈 
        {
            int temp;
            temp=ch-'0';//先把当前操作数从字符变为数字 
            ch=getchar();
            while(ch>='0'&&ch<='9')//继续判断下一位是否为操作数
            {
                temp=temp*10+ch-'0';
                ch=getchar();
            } 
            Push(&OVS,temp);

        }
        else
        switch(Compare(ch,GetTop(&OPTR,&x)))
        {
            case '>':Push(&OPTR,ch);
              scanf("%d",&ch);
            case '=':Pop(&OPTR,&op);ch=getchar();break;//脱括号 
            case '<':Pop(&OPTR,&op);//形成运算 
            Pop(&OVS,&b);
            Pop(&OVS,&a);
            v=Execute(a,op,b);
            //此处需要将v转换为字符型并且入站 
            Push(&OVS,v);
            break; 
        }
    }
    v=GetTop(&OVS,&x);
    return(v);
} 

//初始化
void InitStack(SeqStack *S)
{
    /*构造一个空栈S*/
    S->top=-1; 
} 
//进栈
int Push(SeqStack *S,StackElementType x)
{
    if(S->top==Stack_Size-1)
     return(FALSE);
    S->top++;
    S->elem[S->top]=x;
    return(TRUE);
} 
//出栈
int Pop(SeqStack *S,StackElementType *x)
{
    if(S->top==-1)
     return(FALSE);
    *x=S->elem[S->top];
    S->top--;
    return(TRUE);
} 
//读栈顶
int GetTop(SeqStack *S,StackElementType *x)
{
    if(S->top==-1)
     return(FALSE);
    else
    {
        *x=S->elem[S->top];
        return(TRUE);
    }
} 


//比较优先级,返回'>','<','=' 
StackElementType Compare(StackElementType ch1,StackElementType ch2)
//ch1为还未进栈的运算符,ch2为当前运算符栈顶元素 
{
    //'('未入栈时,优先级最高,入栈后,优先级最低 
    switch(ch1)
    {
        case '(':ch1=6;break;
        case '*':
        case '/':ch1=5;break;
        case '+':
        case '-':ch1=4;break;
        case ')':ch1=3;break;
    }
    switch(ch2)
    {
        case '*':
        case '/':ch2=5;break;
        case '+':
        case '-':ch2=4;break;
        case ')':ch2=3;break;
        case '(':ch2=2;break;
    }
    if(ch1>ch2)
     return('>');
     else if(ch1=ch2)
      return('=');
      else
       return('<');
}
StackElementType Execute(StackElementType a,StackElementType op,StackElementType b)
{
    double v;
    switch(op)
    {
        case '+':v=(double)a+(double)b;break;
        case '-':v=(double)a-(double)b;break;
        case '*':v=(double)a*(double)b;break;
        case '/':v=(double)a/(double)b;break;
    }
    return((StackElementType)v);
}

1个回答

C语言是大小写敏感的语言
typedef struct
{
StackElementType elem[Stack_Size];
int Top;
}SeqStack;
你注意看,Top是大写的

S->top++;
你这里是小写的。

错误提示都是这个类型的错误

Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
【数据结构】求大佬帮忙看一下这个错误是怎么回事?(用栈实现带括号的多位数四则运算器)

# 题目原型: 四则运算器:实现多位整数的带括号的四则运算 # # 现存问题: # 程序中出现如图所示错误,麻烦大佬指点一下原因 # ![图片说明](https://img-ask.csdn.net/upload/201811/28/1543412646_396920.jpg) # ``` #include <stdio.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 #define Stack_Size 50 typedef char StackElementType; //运算符 typedef double StackElementType_num; //运算数 typedef struct { StackElementType elem[Stack_Size]; int top; }SeqStack; //运算符栈 typedef struct { StackElementType_num elem[Stack_Size]; int top; }SeqStack_num; //运算数栈 StackElementType_num ExpEvaluation(); void InitStack(SeqStack *S); int Push(SeqStack *S,StackElementType x); int Push_num(SeqStack *S,StackElementType_num x); int Pop(SeqStack *S,StackElementType *x); int Pop_num(SeqStack *S,StackElementType_num *x); int GetTop(SeqStack *S,StackElementType *x); int GetTop_num(SeqStack *S,StackElementType_num *x); StackElementType Compare(StackElementType ch1,StackElementType ch2); StackElementType Execute(StackElementType_num a,StackElementType op,StackElementType_num b); int main() { printf("%lf",ExpEvaluation()); return(0); } StackElementType_num ExpEvaluation() { char exp[100];//用字符数组将运算表达式存起来 int i=0,count=0; printf("Please input an expression (Ending with #:)"); exp[i]=getchar(); while(exp[i]!='#') { i++;count++; exp[i]=getchar(); } SeqStack OPTR; SeqStack_num OVS; StackElementType ch,op,x; StackElementType_num a,b,v; InitStack(&OPTR); InitStack_num(&OVS); Push(&OPTR,'#'); for(i=0;i<count;i++) { ch=exp[i]; while(ch!='#'||GetTop(&OPTR,&x)!='#') { if(ch>='0'&&ch<='9')//不是操作符,是操作数,进OVS栈 { int temp; temp=ch-'0';//先把当前操作数从字符变为数字 i++; ch=exp[i]; while(ch>='0'&&ch<='9')//继续判断下一位是否为操作数 { temp=temp*10+ch-'0'; i++; ch=exp[i]; } Push_num(&OVS,temp);//压栈 } else switch(Compare(ch,GetTop(&OPTR,&x))) { case '>':Push(&OPTR,ch); i++;ch=exp[i]; case '=':Pop(&OPTR,&op);i++;ch=exp[i];break;//脱括号 case '<':Pop(&OPTR,&op);//形成运算 Pop_num(&OVS,&b); Pop_num(&OVS,&a); v=Execute(a,op,b); Push_num(&OVS,v); break; } } } v=GetTop_num(&OVS,&x); return(v); } //初始化 void InitStack(SeqStack *S) { /*构造一个空栈S*/ S->top=-1; } void InitStack_num(SeqStack_num *S) { /*构造一个空栈S*/ S->top=-1; } //进栈 int Push(SeqStack *S,StackElementType x) { if(S->top==Stack_Size-1) return(FALSE); S->top++; S->elem[S->top]=x; return(TRUE); } int Push_num(SeqStack *S,StackElementType_num x) { if(S->top==Stack_Size-1) return(FALSE); S->top++; S->elem[S->top]=x; return(TRUE); } //出栈 int Pop(SeqStack *S,StackElementType *x) { if(S->top==-1) return(FALSE); *x=S->elem[S->top]; S->top--; return(TRUE); } int Pop_num(SeqStack *S,StackElementType_num *x) { if(S->top==-1) return(FALSE); *x=S->elem[S->top]; S->top--; return(TRUE); } //读栈顶 int GetTop(SeqStack *S,StackElementType *x) { if(S->top==-1) return(FALSE); else { *x=S->elem[S->top]; return(TRUE); } } int GetTop_num(SeqStack *S,StackElementType_num *x) { if(S->top==-1) return(FALSE); else { *x=S->elem[S->top]; return(TRUE); } } //比较优先级,返回'>','<','=' StackElementType Compare(StackElementType ch1,StackElementType ch2) //ch1为还未进栈的运算符,ch2为当前运算符栈顶元素 { //'('未入栈时,优先级最高,入栈后,优先级最低 int m,n; switch(ch1) { case '(':m=6;break; case '*': case '/':m=5;break; case '+': case '-':m=4;break; case ')':m=3;break; } switch(ch2) { case '*': case '/':n=6;break; case '+': case '-':n=5;break; case ')':n=4;break; case '(':n=3;break; } if(ch1>ch2) return('>'); else if(ch1=ch2) return('='); else return('<'); } StackElementType_num Execute(StackElementType_num a,StackElementType op,StackElementType_num b) { StackElementType_num v; switch(op) { case '+':v=a+b;break; case '-':v=a-b;break; case '*':v=a*b;break; case '/':v=a/b;break; } return(v); } ```

栈 数据结构 四则运算

2. 利用栈的数据结构实现一个简单的4则运算计算器(不需要支持括号)。例如, 分析5 * 2 + 3 * 4的执行过程,输出进出栈的顺序(提示:中间结果得到后可继续push到栈中)。 最好能写出代码 并加注释 c语言 不是c++

C语言 用栈实现 括号匹配

符号匹配(50分) 题目内容: 判断输入的括号字符串是否匹配, 括号有()、[]、{}、<>四种, 匹配的定义如下: (1) 空字符串为匹配。 (2) 若S为匹配字符串,则(S)、[S]、{S}、<S>为匹配自串。 (3) 两个匹配字符串串接亦为匹配字符串。 输入格式: 输入第一行为一个数字T,代表测试数据的笔数。 接下来会有T笔测试数据,每一笔测试数据一行。 每一笔测试数据的字符串长度不超过2000字符。 T < 1000 输出格式: 输出一行数字,输出测资中有多少匹配字符串。 输入样例: 5 () <><>[] ([{[]}]) <()){} 输出样例: 4

数据结构用栈实现算术表达式的求值运算

小白一枚,最近用栈实现算术表达式的求值运算结果出现好多问题,单独的加减乘除运算都能够实现,但一旦加上括号运算就停在那命令窗口也不能输入信息,跪求大神指点原因 附上代码和截图:![图片说明](https://img-ask.csdn.net/upload/201511/16/1447681940_987141.png) #include<malloc.h> #include<stdlib.h> #include<stdio.h> #define STACK_INIT_SIZE 100 //存储空间初始分配量; #define S 10 //存储空间分配增量; #define OK 1 #define ERROR 0 typedef int ElemType; typedef struct{ char *base; char *top; int stacksize; }sqstack; //定义运算符类型栈; typedef struct{ int *base; int *top; int stacksize; }stack; //定义运算数栈; void InitStack(sqstack &OPTR) //构建运算符栈; { OPTR.base=(char *)malloc(STACK_INIT_SIZE*sizeof(char)); if(!OPTR.base) printf("Error!\n"); OPTR.top=OPTR.base; OPTR.stacksize=STACK_INIT_SIZE; return; } void Initstack(stack &OPND) //构建运算数栈; { OPND.base=(int *)malloc(STACK_INIT_SIZE*sizeof(int)); if(!OPND.base) printf("ERror!"); OPND.top=OPND.base; OPND.stacksize=STACK_INIT_SIZE; return; } int In(char ch) //判断字符是否是运算符; { int r; switch(ch) { case '+': case '-': case '*': case '/': case '#':r=1;break; default:r=0;break; } return r; } void PuSh(sqstack &OPTR,char ch) //运算符栈插入新的运算符栈顶元素; { if(OPTR.top-OPTR.base>=OPTR.stacksize) //栈满,追加存储空间; { OPTR.base=(char *)realloc(OPTR.base,(OPTR.stacksize+S)*sizeof(char)); if(!OPTR.base) printf("错误!"); OPTR.top=OPTR.base+OPTR.stacksize; OPTR.stacksize+=S; } *OPTR.top++=ch; printf("成功插入(puSh)运算符栈顶元素!\n"); } void PoP(sqstack &OPTR,char &ch) //删除字符的栈顶元素;(!!!!!!!!!!!!!!) { if(OPTR.top==OPTR.base) printf("error"); ch=* --OPTR.top; printf("删除字符栈顶元素!\n"); } char GetTop(sqstack &OPTR) //得到运算符栈顶元素;(!!!!!!!!!!!!!) { char c; if(OPTR.top==OPTR.base) printf("error!"); c=*(OPTR.top-1); printf("运算符栈顶元素正常\n"); return c; } void Push(stack &OPND,int e) //运算数栈插入新的运算数栈顶元素; { if(OPND.top-OPND.base>=OPND.stacksize) //栈满,追加空间; { OPND.base=(int *)realloc(OPND.base,(OPND.stacksize+S)*sizeof(int)); if(!OPND.base) printf("运算数栈错误!"); OPND.top=OPND.base+OPND.stacksize; OPND.stacksize+=S; } *OPND.top++=e; printf("成功插入运算数栈!\n"); } void Pop(stack &OPND,int &e) //删除运算数栈的栈顶元素;(!!!!!!!!!!!!!!!) { if(OPND.top==OPND.base) printf("error"); e=* --OPND.top; printf("成功删除运算数栈!"); } int Gettop(stack &OPND) //得到运算数栈顶元素;(!!!!!!!!!!!!!!!!!!) { int a; if(OPND.top==OPND.base) return 0; else a=*(OPND.top-1); return a; } char compare(char a,char b) //判断运算符的优先级; { int i,j; int array[7][7]= //1表示">",-1表示"<",0表示"=",2表示不可能 { {1,1,-1,-1,-1,1,1}, {1,1,-1,-1,-1,1,1}, {1,1,1,1,-1,1,1}, {1,1,1,1,-1,1,1}, {-1,-1,-1,-1,-1,0,2}, {1,1,1,1,2,1,1}, {-1,-1,-1,-1,-1,2,0} }; switch(a) { case '+':i=0;break; case '-':i=1;break; case '*':i=2;break; case '/':i=3;break; case '(':i=4;break; case ')':i=5;break; case '#':i=6;break; } switch(b) { case '+':j=0;break; case '-':j=1;break; case '*':j=2;break; case '/':j=3;break; case '(':j=4;break; case ')':j=5;break; case '#':j=6;break; } if(array[i][j]==1) return '>'; else if(array[i][j]==-1) return '<'; else if(array[i][j]==0) return '='; else printf("error!"); printf("该函数被调用"); return 1; } int operate(int p,char f,int q) { switch(f) { case '+':return p+q; case '-':return p-q; case '*':return p*q; case '/':return p/q; } return 1; } int EvaluateExpression() { char c,f, d[100],e; int i, num, tmpa, tmpb; sqstack OPTR; stack OPND; InitStack(OPTR);Initstack(OPND); PuSh(OPTR,'#'); c=getchar(); while(c!='#'||(e=GetTop(OPTR))!='#') { if(c>='0'&&c<='9') { i=0; do{ d[i++]=c; c=getchar(); }while(c>='0'&&c<='9'); d[i]='\0'; num=atoi(d); Push(OPND, num); } else if(In(c)) { switch(compare(GetTop(OPTR), c)) { case '<': PuSh(OPTR, c);c=getchar(); break; case '=': PoP(OPTR, f);c=getchar(); break; case '>': PoP(OPTR, f);Pop(OPND, tmpb);Pop(OPND, tmpa); Push(OPND, operate(tmpa, f, tmpb)); break; } } } return Gettop(OPND); } int EvaluateExpression(); //主操作函数 void main() { int r; printf("请输入表达式:"); r=EvaluateExpression(); printf("输出结果为:%d\n",r); }

数据结构题目(c语言),把只能实现带小括号的表达式计算改为可以带小中大括号的表达式计算

[链接里是带小括号表达式计算的代码](https://blog.csdn.net/acm_jl/article/details/51031005 "") ![题目要求](https://img-ask.csdn.net/upload/201811/28/1543365503_20006.jpg) 谢谢各位大佬!

逻辑运算带括号,去括号不改变运算逻辑

(白血病and心脏病)not(年龄>78not高血压) 类似的带括号的逻辑运算通过方法将括号去掉,但是运算逻辑不变,请问有大佬能给点意见吗?最好java的思路

java,目标是控制台实现带括号的加减乘除运算

新手求教!麻烦大触帮我看下代码,多谢~ 第4次改(依旧错 ``` package com.calculator; import java.io.*; import java.util.regex.*; public class calculator { public static StringBuilder first(StringBuilder s){ int a,b; while(s.indexOf("(")!=-1){ a=s.lastIndexOf(")"); b=s.indexOf(")",a); s.replace(0,b+1,second(new StringBuilder(s.substring(a+1,b))).toString()); } return s; } public static StringBuilder second(StringBuilder s){ Pattern p=Pattern.compile("[-+*/]"); String[] st=p.split(s.toString()); char[] stll=new char[s.length()]; int j=0; for(int i=0;i<s.length();i++){ if(s.charAt(i)=='*') stll[j++]='*'; else if(s.charAt(i)=='/') stll[j++]='/'; else if(s.charAt(i)=='+') stll[j++]='+'; else if(s.charAt(i)=='-') stll[j++]='-'; } char[] st1=new char[j]; System.arraycopy(stll,0,st1,0,j); String[] str=new String[st.length]; int x=0; if(st1[0]=='*'){ str[x]=String.valueOf(Double.parseDouble(st[0])*Double.parseDouble(st[1])); st[1]=str[x]; } else if(st1[0]=='/'){ str[x]=String.valueOf(Double.parseDouble(st[0])/Double.parseDouble(st[1])); st[1]=str[x]; } else if(st1[0]=='+'){ str[x]=st[0]; str[++x]="+"; str[++x]=st[1]; } else if(st1[0]=='-'){ str[x]=st[0]; str[++x]="-"; str[++x]=st[1]; } j=2; for(int i=1;i<st1.length;i++){ if(st1[i]=='*'){ str[++x]=String.valueOf(Double.parseDouble(st[j])*Double.parseDouble(st[++j])); st[j]=str[x]; }else if(st1[i]=='/'){ str[++x]=String.valueOf(Double.parseDouble(st[j])*Double.parseDouble(st[++j])); st[j]=str[x]; }else if(st1[i]=='+'){ str[++x]="+"; str[++x]=st[++j]; }else if(st1[i]=='-'){ str[++x]="-"; str[++x]=st[++j]; } } StringBuilder ss=new StringBuilder(); for(int i=0;i<=x;i++){ ss.append(str[x]); } if(ss.indexOf("+")!=-1||ss.indexOf("-")!=-1){ ss=third(ss); } return ss; } public static StringBuilder third(StringBuilder s){ Pattern p=Pattern.compile("[+-]"); String[] st=p.split(s.toString()); int j=0; for(int i=0;i<s.length();i++){ if(s.charAt(i)=='+'){ j++; st[j]=String.valueOf(Double.parseDouble(st[j-1])+Double.parseDouble(st[j])); } else if(s.charAt(i)=='-'){ j++; st[j]=String.valueOf(Double.parseDouble(st[j-1])-Double.parseDouble(st[j])); } } return new StringBuilder(st[j].trim()); } public static void main(String[] args) { try { BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); String s=in.readLine(); StringBuilder ss=new StringBuilder(s); if(ss.indexOf("(")!=-1) ss=first(ss); else if(ss.indexOf("*")!=-1||ss.indexOf("/")!=-1) ss=second(ss); else ss=third(ss); System.out.println("="+ss); }catch(NumberFormatException e){ System.err.println("NumberFormatException"); e.printStackTrace(); }catch(ArrayIndexOutOfBoundsException e){ System.err.println("ArrayIndexOutOfBoundsException"); e.printStackTrace(); }catch (IOException e) { System.err.println("IOException"); e.printStackTrace(); }catch(Exception e){ System.err.println("Exception"); e.printStackTrace(); } } } ``` 加减运算没问题,第二优先级1步运算没问题,2步开始出错: 2*2*2 > ArrayIndexOutOfBoundsException > java.lang.ArrayIndexOutOfBoundsException: 3 > at com.calculator.calculator.second(calculator.java:50) > at com.calculator.calculator.main(calculator.java:94) (2+3)*2 > Exception > java.lang.StringIndexOutOfBoundsException: String index out of range: -1 > at java.lang.AbstractStringBuilder.substring(Unknown Source) > at java.lang.StringBuilder.substring(Unknown Source) > at com.calculator.calculator.first(calculator.java:10) > at com.calculator.calculator.main(calculator.java:93)

数据结构题目,四则运算

用户从键盘输入一个计算表达式,用栈实现四则运算。表达式中含有数字,加减乘除,小括号。输出表达式的结果。用c语言实现

实现以下四则运算计算器的设计:

优化界面布局及控件的合理使用 优化操作体验 合理的代码结构 必要的语法检查逻辑(括号配对、运算符号重叠、运算数丢失) ![图片说明](https://img-ask.csdn.net/upload/201906/25/1561451033_253514.png) 希望程序可以具体一点。

c++新手求用栈解括号匹配

括号必须有等级排列,例:{([ ] ) }。则不叫匹配成功。 样例输入1:{[()]} 样例输出1:yes 样例输入2:{([])} 样例输出2 : no

关于数据结构括号匹配的问题

程序写完了,但是一运行就崩了,我不知道错误在哪,求大神指教!下面贴出我的代码: #include<stdio.h> #include<stdlib.h> #include<iostream> using namespace std; #define SIZE 100 typedef struct StackNode{ char data; struct StackNode *next; }StackNode,*LinkStack; void InitStack(LinkStack &S); void Push(LinkStack &S,char e); void Pop(LinkStack &S,char &e); bool StackEmpty(LinkStack &S); char GetTop(LinkStack &S); void Matching(char Carray[]); void mud(LinkStack &S,char Carray[]); void main(){ LinkStack S; char Carray[SIZE]; cout<<"请输入一串括号并以#号结束:"; gets(Carray); puts(Carray); Matching(Carray); // if(!StackEmpty(S)) cout<<"栈已空"; //else cout<<"未空"; } void InitStack(LinkStack &S){ //构造一个空栈 S=NULL; } void Push(LinkStack &S,char e){ //压入栈 LinkStack p; p=new StackNode; p->data=e; p->next=S; S=p; } void Pop(LinkStack &S,char &e){ //弹出栈 LinkStack p; if(S==NULL){ printf("该栈已空\n"); exit(1); } p=S; e=S->data; S=S->next; delete p; } bool StackEmpty(LinkStack &S){ //判断栈是否已空 if(S==NULL) return true; else return false; } char GetTop(LinkStack &S){ //返回桟顶元素 return S->data; } void Matching(char Carray[]){ char x; int flag=1,i=0; LinkStack S; InitStack(S); while(Carray[i]!='#'&&flag){ switch(Carray[i]){ case '[' || '(': Push(S,Carray[i]); break; case ']': x=GetTop(S); if(x=='[') Pop(S,x); else flag=0; break; case ')': x=GetTop(S); if(x=='(') Pop(S,x); else flag=0; break; } i++; } if(!StackEmpty(S)&& flag) cout<<"括号匹配"; else cout<<"括号不匹配"; }

汇编语言实现带括号计算器

只要求实现加,减,乘三种运算,要求要进行符号运算,求大神帮助,注释最好多一点

c++如何用栈实现计算表达式?

要求用栈,表达式可以输入加减乘除,小括号,小数点,可以计算两位数以上的,可以接收负数。

使用双栈实现中缀表达式求值一个字符栈一个数字栈

程序写好没输出啊,急求啊......主要BUG 在Nibolansuanfa()这个自定义函数里面前面的可以忽略..... /*核心函数*/ double Nibolansuanfa(char *str,stack *s) { initstack(&s);//初始化栈 char st[20],tc,xy;//st[20]里面放数字字符串 int j=0,i=0,yxcount=0; double d; while(str[j]!='\0') { /*数字字符拷贝*/ if(Isnum(str[i])) { while(Isnum(str[i])) { st[i]=str[j];//将数字字符串放到st数组 i++; j++; } /*数字字符转换并进数字栈*/ i=0; d=atof(st); pushdb(s,d); st[20]=0; continue; } /*非数字字符进字符栈*/ else if(!IsRxz(str[j])&&!Isnum(str[j])) { pushchar(s,str[j]); j++; } else if(Isysf(str[j])) { tc=popchar(s); pushchar(s,tc); Cmpysf(str[j],tc); if(Cmpysf(str[j],tc)) YsStackdb(str[j],s); else pushchar(s,str[j]); j++; } else if(IsRxz(str[j]))//遇到右限制处理 { if(str[j]==')')//遇到小括号 while((tc=popchar(s))!='(') { if(Isysf(tc)) { xy=popchar(s); pushchar(s,xy); if(Isysf(xy)) { if(Cmpysf(tc,xy)) YsStackdb(tc,s); else pushchar(s,tc); } j++; } else { printf("中缀表达式格式错误!"); exit(0); } } if(str[j]==']')//遇到中括号 while((tc=popchar(s))!='[') { if(Isysf(tc)) { xy=popchar(s); pushchar(s,xy); if(Isysf(xy)) { if(Cmpysf(tc,xy)) YsStackdb(tc,s); else pushchar(s,tc); } j++; } else { printf("中缀表达式格式错误!"); exit(0); } } if(str[j]=='}')//遇到大括号 while((tc=popchar(s))!='{') { if(Isysf(tc)) { xy=popchar(s); pushchar(s,xy); if(Isysf(xy)) { if(Cmpysf(tc,xy)) YsStackdb(tc,s); else pushchar(s,tc); } j++; } else { printf("中缀表达式格式错误!"); exit(0); } } } else { printf("中缀表达式格式错误!"); exit(0); } } if(--(s->topdb)==s->bottomdb) return popdb(s); else return 0; } /*全部完整程序*/ #include<stdio.h> #include<math.h> #include<stdlib.h> #include<ctype.h> #define STACKSIZE 100 #define STACKADD 10 /*运算符优先级数据结构*/ struct Yxsz { char ysf; int yxj; } ysz[]={{'(',6},{')',0},{'[',6},{']',1},{'{',6},{'}',2},{'#',3},{'^',3},{'*',4},{'/',4},{'+',5},{'-',5}}; /*char类型与double类型的双栈结构*/ typedef struct { char *topchar; char *bottomchar; int charStackSize; double *topdb; double *bottomdb; int doubleStackSize; }stack; /*初始化栈*/ void initstack(stack *s) { s->bottomchar=(char*)malloc(STACKSIZE*sizeof(char)); if(!s->bottomchar) exit(0); s->topchar=s->bottomchar; s->charStackSize=STACKSIZE; s->bottomdb=(double *)malloc(STACKSIZE*sizeof(double)); if(!s->bottomdb) exit(0); s->topdb=s->bottomdb; s->doubleStackSize=STACKSIZE; } /*字符入栈*/ void pushchar(stack *s,char a) { if(s->topchar-s->bottomchar>=STACKSIZE) { s->bottomchar=(char*)realloc(s->bottomchar,(s->charStackSize+STACKADD)*sizeof(char)); if(!s->bottomchar) exit(0); } *(s->topchar)=a; s->topchar++; } /*数字入栈*/ void pushdb(stack *s,double b) { if(s->topdb-s->bottomdb>=STACKSIZE) { s->bottomdb=(double *)realloc(s->bottomdb,(s->doubleStackSize+STACKADD)*sizeof(double)); if(!s->bottomdb) exit(0); } *(s->topdb)=b; s->topdb++; } /*字符出栈*/ char popchar(stack *s) { char i; if(!s&&s->topchar==s->bottomchar) exit(0); i=*(--s->topchar); return i; } /*数字出栈*/ double popdb(stack *s) { double i; if(!s&&s->topdb==s->bottomdb) exit(0); i=*(--s->topdb); return i; } /*清空栈*/ int Cealenstack(stack *s) { if(!s) return 0; s->topchar=s->bottomchar; s->topdb=s->bottomdb; return 1; } /*销毁栈*/ void Destorystack(stack *s) { int lenchar=stackcharLen(s),lendb=stackdblen(s); if(!s) exit(0); while(lenchar) { *(--s->topchar)=NULL; lenchar--; } while(lendb) { *(--s->topdb)=0; lendb--; } } /*计算字符栈长度*/ int stackcharLen(stack *s) { return(s->topchar-s->bottomchar); } /*计算数字栈长度*/ int stackdblen(stack *s) { return (s->topdb-s->bottomdb); } /*以下为程序核心*/ /*将中缀字符串转换成后缀然后求值这个函数有点复杂,定义在主函数下面*/ double Nibolansuanfa(char *str,stack *s); /*字符是右限制符号*/ int IsRxz(char i) { if(i==')'||i==']'||i=='}') return 1; else return 0; } /*字符是运算符*/ int Isysf(char i) { if(i=='*'||i=='/'||i=='^'||i=='#'||i=='+'||i=='-') return 1; else return 0; } /*字符是数字字符*/ int Isnum(char i) { if(i>='0'&&i<='9'||i=='.') return 1; else return 0; } /*比较栈里上下两个运算符的优先级如果前一个优先级比后一个大或者同级返回前一个字符,别的返回0*/ char Cmpysf(char a,char b) { int j=0,i=0; while(ysz[j].ysf!=a) j++; while(ysz[i].ysf!=b) i++; if(ysz[j].yxj<=ysz[i].yxj) return a; else return 0; } /*遇到运算符直接在数字栈里面处理并计算*/ void YsStackdb(char i,stack *s) { int k,j; switch(i) { case '#': k=popdb(s); j=popdb(s); pushdb(s,pow(j,1.0/k)); break; case '^': k=popdb(s); j=popdb(s); pushdb(s,pow(j,k)); break; case'*': k=popdb(s); j=popdb(s); pushdb(s,j*k); break; case'/': k=popdb(s); j=popdb(s); pushdb(s,j/k); break; case'+': k=popdb(s); j=popdb(s); pushdb(s,j+k); break; case'-': k=popdb(s); j=popdb(s); pushdb(s,j-k); break; } return; } /*主函数*/ int main(void) { stack *sk; char str[100]; printf("请输入一个中缀表达式:"); scanf("%s",str); printf("结果:%lf\n",Nibolansuanfa(str,sk)); return 0; } /*核心函数*/ double Nibolansuanfa(char *str,stack *s) { initstack(&s);//初始化栈 char st[20],tc,xy;//st[20]里面放数字字符串 int j=0,i=0,yxcount=0; double d; while(str[j]!='\0') { /*数字字符拷贝*/ if(Isnum(str[i])) { while(Isnum(str[i])) { st[i]=str[j];//将数字字符串放到st数组 i++; j++; } /*数字字符转换并进数字栈*/ i=0; d=atof(st); pushdb(s,d); st[20]=0; continue; } /*非数字字符进字符栈*/ else if(!IsRxz(str[j])&&!Isnum(str[j])) { pushchar(s,str[j]); j++; } else if(Isysf(str[j])) { tc=popchar(s); pushchar(s,tc); Cmpysf(str[j],tc); if(Cmpysf(str[j],tc)) YsStackdb(str[j],s); else pushchar(s,str[j]); j++; } else if(IsRxz(str[j]))//遇到右限制处理 { if(str[j]==')')//遇到小括号 while((tc=popchar(s))!='(') { if(Isysf(tc)) { xy=popchar(s); pushchar(s,xy); if(Isysf(xy)) { if(Cmpysf(tc,xy)) YsStackdb(tc,s); else pushchar(s,tc); } j++; } else { printf("中缀表达式格式错误!"); exit(0); } } if(str[j]==']')//遇到中括号 while((tc=popchar(s))!='[') { if(Isysf(tc)) { xy=popchar(s); pushchar(s,xy); if(Isysf(xy)) { if(Cmpysf(tc,xy)) YsStackdb(tc,s); else pushchar(s,tc); } j++; } else { printf("中缀表达式格式错误!"); exit(0); } } if(str[j]=='}')//遇到大括号 while((tc=popchar(s))!='{') { if(Isysf(tc)) { xy=popchar(s); pushchar(s,xy); if(Isysf(xy)) { if(Cmpysf(tc,xy)) YsStackdb(tc,s); else pushchar(s,tc); } j++; } else { printf("中缀表达式格式错误!"); exit(0); } } } else { printf("中缀表达式格式错误!"); exit(0); } } if(--(s->topdb)==s->bottomdb) return popdb(s); else return 0; }

c语言栈的应用【括号匹配问题】

代码运行结果永远是正确,弄了好久没解决 ``` #include<stdio.h> #define MaxSize 50 typedef struct//顺序栈 { char data[MaxSize]; int top; }SqStack; bool StackEmpty(SqStack &S)//判断栈空 { if(S.top==-1) return true; else return false; } bool Push(SqStack &S,char x)//压栈 { if(S.top==MaxSize) return false; S.data[++S.top]=x; return true; } bool Pop(SqStack &S,char x)//出栈 { if(S.top==-1) return false; x=S.data[S.top--]; return true; } bool GetTop(SqStack &S,char x)//读取栈顶元素 { if(S.top==-1) return false; x=S.data[S.top]; return true; } void InitStack(SqStack &S)//栈的初始化 { S.top=-1; } void main() { int i,x; SqStack S; char a[20]; InitStack(S); for(i=0;i<20;i++) { scanf("%c",&a[i]); } for(i=0;i<20;i++) { if(a[i]=='{'||a[i]=='['||a[i]=='(') Push(S,a[i]); if(a[i]=='}'||a[i]==']'||a[i]==')') if(StackEmpty(S)) { printf("右括号比左括号多"); return; } else { GetTop(S,x); if(x=='{'&&a[i]=='}'||x=='['&&a[i]==']'||x=='('&&a[i]==')') { Pop(S,x); Pop(S,x); continue; } else { printf("左右括号配对次序不正确"); return; } } } if(StackEmpty(S)) { printf("左右括号配对正确"); return; } else { printf("左括号比右括号多"); return; } } ```

用栈判断表达式中的括号是否匹配(c语言)

//判断一个算术表达式的圆括号是否正确配对 #include <stdio.h> #define MAXSIZE 1000 typedef char datatype; typedef struct Stack{ datatype elements[MAXSIZE]; int Top; }stacky; stacky *SetnullS(stacky *S){ S->Top=-1; return S; } int Empty(stacky *S){ if(S->Top==0) return 1; else return 0; } stacky *push(stacky *S,datatype e){ if(S->Top>=MAXSIZE-1){ printf ("overflow"); return NULL; } else { S->Top++; S->elements[S->Top]=e; } return S; } stacky*pop(stacky *S){ S->Top--; return S; } int Scan(stacky *S,char a[]){ int i; for(i=0;i<7;i++){ if(a[i]=='(') push(S,a[i]); else if(a[i]==')'){ pop(S); } } if(S->Top==0) return 1; else return 0; } void main(){ int key; char a[100]={'(',')','(',')'}; stacky *S; SetnullS(S); //gets(a); key=Scan(S,a); if(key==1) printf("match"); else printf("unmatch"); } 请问这个程序哪里出错了呢··运行不了

c++ 堆栈四则运算括号操作程序查错的问题

这个程序可以输入例如((80+50)*3) 但是为什么会停止工作?这是书上的例程啊... #include<cctype> #include<cstdlib> #include<cstring> #include<iostream> #include<stack> using namespace std; double read_and_evaluate(istream& ins); void evaluate_stack_tops(stack<double>& numbers, stack<char>& operations); int main() { double answer; cout<<"TYPE expression"<<endl; answer = read_and_evaluate(cin); cout << "that evaluates to" << answer << endl; system("pause"); } double read_and_evaluate(istream& ins) { const char DECIMAL = '.'; const char RIGHT_PARENTHESIS = ')'; stack<double> numbers; stack<char> operations; double number; char symbol; while(ins && ins.peek()!='\n') { if(isdigit(ins.peek()) || (ins.peek() == DECIMAL)) { ins >> number; numbers.push(number); } else if(ins.peek() == RIGHT_PARENTHESIS) { ins.ignore(); evaluate_stack_tops(numbers, operations); } else ins.ignore(); } return numbers.top(); } void evaluate_stack_tops(stack<double>& numbers, stack<char>& operations) { double operand1,operand2; operand2=numbers.top(); numbers.pop(); operand1=numbers.top(); numbers.pop(); switch(operations.top()) { case '+': numbers.push(operand1+operand2); break; case '-': numbers.push(operand1-operand2); break; case '*': numbers.push(operand1 * operand2); break; case '/': numbers.push(operand1/operand2); break; } operations.pop(); }

怎样用c实现链栈的算术表达式运算,不得使用stl模板

按照严蔚敏版的书上的算法,用c语言链栈实现,不让使用stl模板,有没有原代码

整数四则运算, 无括号, 求验证所写程序是否正确

``` package test; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); // 非负整数 小于10000 // 2+3*4-2+5+3*2-100 String line; String right; String left; String middle; String sign1; String sign2; line = in.nextLine(); int lineLength = line.length(); if (lineLength > 0) { do { // 获取最右边的加减号 int addIndex = line.lastIndexOf("+"); int subIndex = line.lastIndexOf("-"); int mulIndex = line.lastIndexOf("*"); int divIndex = line.lastIndexOf("/"); // 加减乘除 不存在, // 或者只有最前面的负号, 则终止循环, 输出结果 if (addIndex == -1 && mulIndex == -1 && divIndex == -1) { // end start if (subIndex == -1) { break; } else if (subIndex != -1) { int subSecondIndex = line.lastIndexOf("-", subIndex - 1); if (subIndex == 0 && subSecondIndex == -1) { break; } } } // end end if (addIndex == -1 && subIndex == -1) { // 加减 无 if (divIndex == -1 && mulIndex == -1) { // 加减 乘除 无 System.out.println(line); } else { // 乘除 只有 line = getMulDivResult(line); } } else { // 加减 有 // 以最右边的加减号为断点, 开始截取字符串 int asIndex = getMaxIndex(addIndex, subIndex); if (divIndex == -1 && mulIndex == -1) { // 加减 只有 line = getAddSubResult(line); } else { // 加减乘除 都有 // 从最后一个加减号截取来的字符串 String str2 = line.substring(asIndex + 1); middle = String.valueOf(line.charAt(asIndex)); left = line.substring(0, asIndex); int mdIndex = getMaxIndex(mulIndex, divIndex); right = str2; if (mdIndex > asIndex) { // 在最后一个加减号的后面还存在乘除 right = getMulDivResult(str2); line = left + middle + right; } else if (mdIndex < asIndex) { // 在最后一个加减号的后面, 只是单个数字 // 查找最后一个加减号之前, 即紧挨着的加减号, 截取其中的乘除字符串 int add2Index = line.lastIndexOf("+", asIndex - 1); int sub2Index = line.lastIndexOf("-", asIndex - 1); // 在最后一个加减号, 左边全是乘除, 右边随意 if (add2Index == -1 && sub2Index == -1) { left = line.substring(0, asIndex); left = getMulDivResult(left); right = line.substring(asIndex + 1); middle = String.valueOf(line.charAt(asIndex)); line = left + middle + right; } else { // 有加减 有乘除 int leftIndex = getMaxIndex(line.lastIndexOf("+", mdIndex - 1), line.lastIndexOf("-", mdIndex - 1)); int rightIndex = getMinIndex(line.indexOf("+", mdIndex + 1), line.indexOf("-", mdIndex + 1)); if (leftIndex != -1) { sign1 = String.valueOf(line.charAt(leftIndex)); left = line.substring(0, leftIndex); } else { sign1 = ""; left = ""; } if (rightIndex != -1) { sign2 = String.valueOf(line.charAt(rightIndex)); } else { sign2 = ""; } middle = line.substring(leftIndex + 1, rightIndex); middle = getMulDivResult(middle); right = line.substring(rightIndex + 1); line = left + sign1 + middle + sign2 + right; } } } } } while (line.indexOf("+") != -1 || line.indexOf("-") != -1 || line.indexOf("*") != -1 || line.indexOf("/") != -1); System.out.println(line); } // end if in.close(); // 提示:一种可能的做法是,将整个式子作为字符串读入, // 然后找出其中最后一个+或-,在此位置将其截成两段, // 分别计算后再做+或-,以此类推。 // 另,用Integer.parseInt(s)可以从一个字符串得到整数。 } /** * 单纯乘除计算 * * @param line * @return */ public static String getMulDivResult(String line) { String retStr = null; String leftStr = null; String endStr = null; do { if (endStr != null) { line = leftStr + endStr; } int index = getMinIndex(line.indexOf("*"), line.indexOf("/")); String sign = String.valueOf(line.charAt(index)); leftStr = line.substring(0, index); int index2 = getMinIndex(line.indexOf("*", index + 1), line.indexOf("/", index + 1)); String rightStr = null; if (index2 != -1) { rightStr = line.substring(index + 1, index2); endStr = line.substring(index2); } else if (index2 == -1) { rightStr = line.substring(index + 1); endStr = line.substring(index + rightStr.length() + 1); } switch (sign) { case "*": leftStr = String.valueOf(Integer.parseInt(leftStr) * Integer.parseInt(rightStr)); break; case "/": leftStr = String.valueOf(Integer.parseInt(leftStr) / Integer.parseInt(rightStr)); break; } retStr = leftStr + endStr; } while (endStr.length() > 1); return retStr; } /** * 单纯加减计算 * * @param line * 10-4+5 * @return */ public static String getAddSubResult(String line) { String retStr = null; String leftStr = null; String endStr = null; do { if (endStr != null) { line = leftStr + endStr; } int index = getMinIndex(line.indexOf("+"), line.indexOf("-")); if (index == 0) { index = getMinIndex(line.indexOf("+", index + 1), line.indexOf("-", index + 1)); } String sign = String.valueOf(line.charAt(index)); leftStr = line.substring(0, index); int index2 = getMinIndex(line.indexOf("+", index + 1), line.indexOf("-", index + 1)); String rightStr = null; if (index2 != -1) { rightStr = line.substring(index + 1, index2); endStr = line.substring(index2); } else if (index2 == -1) { rightStr = line.substring(index + 1); endStr = line.substring(index + rightStr.length() + 1); } switch (sign) { case "+": leftStr = String.valueOf(Integer.parseInt(leftStr) + Integer.parseInt(rightStr)); break; case "-": leftStr = String.valueOf(Integer.parseInt(leftStr) - Integer.parseInt(rightStr)); break; } retStr = leftStr + endStr; } while (endStr.length() > 1); return retStr; } /** * 获取非-1, 较大数字的下标 * * @param index1 * @param index2 * @return */ public static int getMaxIndex(int index1, int index2) { int max = -1; // 提前假设两者都是-1 if (index1 > index2) { max = index1; } if (index1 < index2) { max = index2; } return max; } /** * 获取非-1, 较小数字的下标 * * @param index1 * @param index2 * @return */ public static int getMinIndex(int index1, int index2) { int ret = 1; if (index1 == -1) { ret = index2; } else if (index2 == -1) { ret = index1; } else if (index1 > index2) { ret = index2; } else if (index1 < index2) { ret = index1; } return ret; } } ```

在中国程序员是青春饭吗?

今年,我也32了 ,为了不给大家误导,咨询了猎头、圈内好友,以及年过35岁的几位老程序员……舍了老脸去揭人家伤疤……希望能给大家以帮助,记得帮我点赞哦。 目录: 你以为的人生 一次又一次的伤害 猎头界的真相 如何应对互联网行业的「中年危机」 一、你以为的人生 刚入行时,拿着傲人的工资,想着好好干,以为我们的人生是这样的: 等真到了那一天,你会发现,你的人生很可能是这样的: ...

程序员请照顾好自己,周末病魔差点一套带走我。

程序员在一个周末的时间,得了重病,差点当场去世,还好及时挽救回来了。

C++(数据结构与算法)78:---分而治之

一、分而治之的思想 分而治之方法与软件设计的模块化方法非常相似 分而治之通常不用于解决问题的小实例,而要解决一个问题的大实例。一般步骤为: ①把一个大实例分为两个或多个更小的实例 ②分别解决每个小实例 ③把这些小实例的解组合成原始大实例的解 二、实际应用之找出假币 问题描述 一个袋子有16个硬币,其中只有一个是假币,这个假币比其他的真币重量轻(其他所有真币的重量都是相同的)...

springboot+jwt实现token登陆权限认证

一 前言 此篇文章的内容也是学习不久,终于到周末有时间码一篇文章分享知识追寻者的粉丝们,学完本篇文章,读者将对token类的登陆认证流程有个全面的了解,可以动态搭建自己的登陆认证过程;对小项目而已是个轻量级的认证机制,符合开发需求;更多精彩原创内容关注公主号知识追寻者,读者的肯定,就是对作者的创作的最大支持; 二 jwt实现登陆认证流程 用户使用账号和面发出post请求 服务器接受到请求后使用私...

技术大佬:我去,你写的 switch 语句也太老土了吧

昨天早上通过远程的方式 review 了两名新来同事的代码,大部分代码都写得很漂亮,严谨的同时注释也很到位,这令我非常满意。但当我看到他们当中有一个人写的 switch 语句时,还是忍不住破口大骂:“我擦,小王,你丫写的 switch 语句也太老土了吧!” 来看看小王写的代码吧,看完不要骂我装逼啊。 private static String createPlayer(PlayerTypes p...

win10暴力查看wifi密码

刚才邻居打了个电话说:喂小灰,你家wifi的密码是多少,我怎么连不上了。 我。。。 我也忘了哎,就找到了一个好办法,分享给大家: 第一种情况:已经连接上的wifi,怎么知道密码? 打开:控制面板\网络和 Internet\网络连接 然后右击wifi连接的无线网卡,选择状态 然后像下图一样: 第二种情况:前提是我不知道啊,但是我以前知道密码。 此时可以利用dos命令了 1、利用netsh wlan...

女程序员,为什么比男程序员少???

昨天看到一档综艺节目,讨论了两个话题:(1)中国学生的数学成绩,平均下来看,会比国外好?为什么?(2)男生的数学成绩,平均下来看,会比女生好?为什么?同时,我又联想到了一个技术圈经常讨...

副业收入是我做程序媛的3倍,工作外的B面人生是怎样的?

提到“程序员”,多数人脑海里首先想到的大约是:为人木讷、薪水超高、工作枯燥…… 然而,当离开工作岗位,撕去层层标签,脱下“程序员”这身外套,有的人生动又有趣,马上展现出了完全不同的A/B面人生! 不论是简单的爱好,还是正经的副业,他们都干得同样出色。偶尔,还能和程序员的特质结合,产生奇妙的“化学反应”。 @Charlotte:平日素颜示人,周末美妆博主 大家都以为程序媛也个个不修边幅,但我们也许...

MySQL数据库面试题(2020最新版)

文章目录数据库基础知识为什么要使用数据库什么是SQL?什么是MySQL?数据库三大范式是什么mysql有关权限的表都有哪几个MySQL的binlog有有几种录入格式?分别有什么区别?数据类型mysql有哪些数据类型引擎MySQL存储引擎MyISAM与InnoDB区别MyISAM索引与InnoDB索引的区别?InnoDB引擎的4大特性存储引擎选择索引什么是索引?索引有哪些优缺点?索引使用场景(重点)...

如果你是老板,你会不会踢了这样的员工?

有个好朋友ZS,是技术总监,昨天问我:“有一个老下属,跟了我很多年,做事勤勤恳恳,主动性也很好。但随着公司的发展,他的进步速度,跟不上团队的步伐了,有点...

我入职阿里后,才知道原来简历这么写

私下里,有不少读者问我:“二哥,如何才能写出一份专业的技术简历呢?我总感觉自己写的简历太烂了,所以投了无数份,都石沉大海了。”说实话,我自己好多年没有写过简历了,但我认识的一个同行,他在阿里,给我说了一些他当年写简历的方法论,我感觉太牛逼了,实在是忍不住,就分享了出来,希望能够帮助到你。 01、简历的本质 作为简历的撰写者,你必须要搞清楚一点,简历的本质是什么,它就是为了来销售你的价值主张的。往深...

程序员写出这样的代码,能不挨骂吗?

当你换槽填坑时,面对一个新的环境。能够快速熟练,上手实现业务需求是关键。但是,哪些因素会影响你快速上手呢?是原有代码写的不够好?还是注释写的不够好?昨夜...

带了6个月的徒弟当了面试官,而身为高级工程师的我天天修Bug......

即将毕业的应届毕业生一枚,现在只拿到了两家offer,但最近听到一些消息,其中一个offer,我这个组据说客户很少,很有可能整组被裁掉。 想问大家: 如果我刚入职这个组就被裁了怎么办呢? 大家都是什么时候知道自己要被裁了的? 面试软技能指导: BQ/Project/Resume 试听内容: 除了刷题,还有哪些技能是拿到offer不可或缺的要素 如何提升面试软实力:简历, 行为面试,沟通能...

优雅的替换if-else语句

场景 日常开发,if-else语句写的不少吧??当逻辑分支非常多的时候,if-else套了一层又一层,虽然业务功能倒是实现了,但是看起来是真的很不优雅,尤其是对于我这种有强迫症的程序"猿",看到这么多if-else,脑袋瓜子就嗡嗡的,总想着解锁新姿势:干掉过多的if-else!!!本文将介绍三板斧手段: 优先判断条件,条件不满足的,逻辑及时中断返回; 采用策略模式+工厂模式; 结合注解,锦...

!大部分程序员只会写3年代码

如果世界上都是这种不思进取的软件公司,那别说大部分程序员只会写 3 年代码,恐怕就没有程序员这种职业。

离职半年了,老东家又发 offer,回不回?

有小伙伴问松哥这个问题,他在上海某公司,在离职了几个月后,前公司的领导联系到他,希望他能够返聘回去,他很纠结要不要回去? 俗话说好马不吃回头草,但是这个小伙伴既然感到纠结了,我觉得至少说明了两个问题:1.曾经的公司还不错;2.现在的日子也不是很如意。否则应该就不会纠结了。 老实说,松哥之前也有过类似的经历,今天就来和小伙伴们聊聊回头草到底吃不吃。 首先一个基本观点,就是离职了也没必要和老东家弄的苦...

2020阿里全球数学大赛:3万名高手、4道题、2天2夜未交卷

阿里巴巴全球数学竞赛( Alibaba Global Mathematics Competition)由马云发起,由中国科学技术协会、阿里巴巴基金会、阿里巴巴达摩院共同举办。大赛不设报名门槛,全世界爱好数学的人都可参与,不论是否出身数学专业、是否投身数学研究。 2020年阿里巴巴达摩院邀请北京大学、剑桥大学、浙江大学等高校的顶尖数学教师组建了出题组。中科院院士、美国艺术与科学院院士、北京国际数学...

为什么你不想学习?只想玩?人是如何一步一步废掉的

不知道是不是只有我这样子,还是你们也有过类似的经历。 上学的时候总有很多光辉历史,学年名列前茅,或者单科目大佬,但是虽然慢慢地长大了,你开始懈怠了,开始废掉了。。。 什么?你说不知道具体的情况是怎么样的? 我来告诉你: 你常常潜意识里或者心理觉得,自己真正的生活或者奋斗还没有开始。总是幻想着自己还拥有大把时间,还有无限的可能,自己还能逆风翻盘,只不是自己还没开始罢了,自己以后肯定会变得特别厉害...

男生更看重女生的身材脸蛋,还是思想?

往往,我们看不进去大段大段的逻辑。深刻的哲理,往往短而精悍,一阵见血。问:产品经理挺漂亮的,有点心动,但不知道合不合得来。男生更看重女生的身材脸蛋,还是...

为什么程序员做外包会被瞧不起?

二哥,有个事想询问下您的意见,您觉得应届生值得去外包吗?公司虽然挺大的,中xx,但待遇感觉挺低,马上要报到,挺纠结的。

当HR压你价,说你只值7K,你该怎么回答?

当HR压你价,说你只值7K时,你可以流畅地回答,记住,是流畅,不能犹豫。 礼貌地说:“7K是吗?了解了。嗯~其实我对贵司的面试官印象很好。只不过,现在我的手头上已经有一份11K的offer。来面试,主要也是自己对贵司挺有兴趣的,所以过来看看……”(未完) 这段话主要是陪HR互诈的同时,从公司兴趣,公司职员印象上,都给予对方正面的肯定,既能提升HR的好感度,又能让谈判气氛融洽,为后面的发挥留足空间。...

面试:第十六章:Java中级开发

HashMap底层实现原理,红黑树,B+树,B树的结构原理 Spring的AOP和IOC是什么?它们常见的使用场景有哪些?Spring事务,事务的属性,传播行为,数据库隔离级别 Spring和SpringMVC,MyBatis以及SpringBoot的注解分别有哪些?SpringMVC的工作原理,SpringBoot框架的优点,MyBatis框架的优点 SpringCould组件有哪些,他们...

早上躺尸,晚上干活:硅谷科技公司这么流行迟到?

硅谷科技公司上班时间OPEN早已不是什么新鲜事,早九晚五是常态,但有很多企业由于不打卡,员工们10点、11点才“姗姗来迟”的情况也屡见不鲜。 这种灵活的考勤制度为人羡慕,甚至近年来,国内某些互联网企业也纷纷效仿。不过,硅谷普遍弹性的上班制度是怎么由来的呢?这种“流行性迟到”真的有那么轻松、悠哉吗? 《动态规划专题班》 课程试听内容: 动态规划的解题要领 动态规划三大类 求最值/计数/可行性 常...

面试阿里p7,被按在地上摩擦,鬼知道我经历了什么?

面试阿里p7被问到的问题(当时我只知道第一个):@Conditional是做什么的?@Conditional多个条件是什么逻辑关系?条件判断在什么时候执...

Python爬虫,高清美图我全都要(彼岸桌面壁纸)

爬取彼岸桌面网站较为简单,用到了requests、lxml、Beautiful Soup4

无代码时代来临,程序员如何保住饭碗?

编程语言层出不穷,从最初的机器语言到如今2500种以上的高级语言,程序员们大呼“学到头秃”。程序员一边面临编程语言不断推陈出新,一边面临由于许多代码已存在,程序员编写新应用程序时存在重复“搬砖”的现象。 无代码/低代码编程应运而生。无代码/低代码是一种创建应用的方法,它可以让开发者使用最少的编码知识来快速开发应用程序。开发者通过图形界面中,可视化建模来组装和配置应用程序。这样一来,开发者直...

面试了一个 31 岁程序员,让我有所触动,30岁以上的程序员该何去何从?

最近面试了一个31岁8年经验的程序猿,让我有点感慨,大龄程序猿该何去何从。

大三实习生,字节跳动面经分享,已拿Offer

说实话,自己的算法,我一个不会,太难了吧

程序员垃圾简历长什么样?

已经连续五年参加大厂校招、社招的技术面试工作,简历看的不下于万份 这篇文章会用实例告诉你,什么是差的程序员简历! 疫情快要结束了,各个公司也都开始春招了,作为即将红遍大江南北的新晋UP主,那当然要为小伙伴们做点事(手动狗头)。 就在公众号里公开征简历,义务帮大家看,并一一点评。《启舰:春招在即,义务帮大家看看简历吧》 一石激起千层浪,三天收到两百多封简历。 花光了两个星期的所有空闲时...

Java岗开发3年,公司临时抽查算法,离职后这几题我记一辈子

前几天我们公司做了一件蠢事,非常非常愚蠢的事情。我原以为从学校出来之后,除了找工作有测试外,不会有任何与考试有关的事儿。 但是,天有不测风云,公司技术总监、人事总监两位大佬突然降临到我们事业线,叫上我老大,给我们组织了一场别开生面的“考试”。 那是一个风和日丽的下午,我翘着二郎腿,左手端着一杯卡布奇诺,右手抓着我的罗技鼠标,滚动着轮轴,穿梭在头条热点之间。 “淡黄的长裙~蓬松的头发...

立即提问
相关内容推荐