C ++ Data Structure Learning stack Application

InC ++ Data StructureMedium,StackStack is widely used. The biggest purpose of stack is to solve the Backtracking problem, which also involves eliminating recursion. When you use stack to solve the Backtracking problem, you rarely think of recursion, such as the maze. In addition, the habits of people are also preemptible, such as tree traversal. From the day of study, this is a recursive algorithm. Although the book also teaches how to implement with stacks, the first thing you think of is recursion. Of course, if the language itself does not support recursion (such as BASIC), the stack is the only choice-as if the current advanced language supports recursion.

The following is the definition and implementation of expression classes. expressions can be infix or suffix, and are distinguished by type in the data field of the header node, due to the assignment function of a single-chain table, I did not copy the content of the header node when I wrote it. Therefore, if I assigned a value between two expressions, the information stored in the header node would be lost. You can rewrite the value assignment function of a single-chain table to solve this problem, or you can assign values between two expressions at all.

 
 

  
  
# Ifndef Expression_H 
  
  
# Define Expression_H 
  
  
# Include "List. h" 
  
  
# Include "Stack. h" 
  
  
# Define INFIX 0 
  
  
# Define POSTFIX 1 
  
  
# Define OPND 4 
  
  
# Define OPTR 8 
  
  
 
  
  
Template<ClassType>ClassExpNode
  
  
{
  
  
　Public:
  
  
IntType;
  
  
Union{Type opnd;CharOptr ;};
  
  
ExpNode (): type (INFIX), optr ('='){}
  
  
ExpNode (Type opnd): type (OPND), opnd (opnd ){}
  
  
ExpNode (CharOptr): type (OPTR), optr (optr ){}
  
  
};
  
  
 
  
  
Template<ClassType>ClassExpression: List  > 
  
  
{
  
  
　Public:
  
  
VoidInput ()
  
  
{
  
  
MakeEmpty (); Get ()-> type = INFIX;
  
  
Cout <endl <"Input expression, ending with ="<Endl;
  
  
Type opnd;CharOptr ='';
  
  
　While(Optr! ='=')
  
  
{
  
  
Cin> opnd;
  
  
If(Opnd! = 0)
  
  
{
  
  
ExpNode  Newopnd (opnd ); 
  
  
LastInsert (newopnd );
  
  
}
  
  
Cin> optr;
  
  
ExpNode  Newoptr (optr ); 
  
  
LastInsert (newoptr );
  
  
}
  
  
}
  
  
VoidPrint ()
  
  
{
  
  
First ();
  
  
Cout <endl;
  
  
　For(ExpNode  * P = Next (); p! = NULL; p = Next ()) 
  
  
{
  
  
Switch(P-> type)
  
  
{
  
  
　CaseOPND:
  
  
Cout <p-> opnd;Break;
  
  
　CaseOPTR:
  
  
Cout <p-> optr;Break;
  
  
　Default:Break;
  
  
}
  
  
Cout <'';
  
  
}
  
  
Cout <endl;
  
  
}
  
  
Expression & Postfix ()// Convert an infix expression to a suffix expression 
  
  
{
  
  
First ();
  
  
　If(Get ()-> type = POSTFIX)Return*This;
  
  
Stack <Char> S; s. Push ('=');
  
  
Expression temp;
  
  
ExpNode  * P = Next (); 
  
  
　While(P! = NULL)
  
  
{
  
  
Switch(P-> type)
  
  
{
  
  
　CaseOPND:
  
  
Temp. LastInsert (* p); p = Next ();Break;
  
  
　CaseOPTR:
  
  
　While(Isp (s. GetTop ()> icp (p-> optr ))
  
  
{
  
  
ExpNode  Newoptr (s. Pop ()); 
  
  
Temp. LastInsert (newoptr );
  
  
}
  
  
　If(Isp (s. GetTop () = icp (p-> optr ))
  
  
{
  
  
S. Pop (); p = Next ();Break;
  
  
}
  
  
S. Push (p-> optr); p = Next ();Break;
  
  
　Default:Break;
  
  
}
  
  
}
  
  
*This= Temp;
  
  
PGetFirst ()-> data. type = POSTFIX;
  
  
　Return*This;
  
  
}
  
  
 
  
  
Type Calculate ()
  
  
{
  
  
Expression temp = *This;
  
  
　If(PGetFirst ()-> data. type! = POSTFIX) temp. Postfix ();
  
  
Stack  S; Type left, right; 
  
  
　For(ExpNode  * P = temp. Next (); p! = NULL; p = temp. Next ()) 
  
  
{
  
  
Switch(P-> type)
  
  
{
  
  
　CaseOPND:
  
  
S. Push (p-> opnd );Break;
  
  
　CaseOPTR:
  
  
Right = s. Pop (); left = s. Pop ();
  
  
Switch(P-> optr)
  
  
{
  
  
　Case '+': S. Push (left + right );Break;
  
  
　Case '-': S. Push (left-right );Break;
  
  
　Case '*': S. Push (left * right );Break;
  
  
　Case '/':If(Right! = 0) s. Push (left/right );Else Return0;Break;
  
  
// Case '%': if (right! = 0) s. Push (left % right); else return 0; break; 
  
  
// Case '^': s. Push (Power (left, right); break; 
  
  
　Default:Break;
  
  
}
  
  
Default:Break;
  
  
}
  
  
}
  
  
ReturnS. Pop ();
  
  
}
  
  
 
  
  
Private:
  
  
　IntIsp (CharOptr)
  
  
{
  
  
Switch(Optr)
  
  
{
  
  
　Case '=':Return0;
  
  
　Case '(':Return1;
  
  
　Case '^':Return7;
  
  
　Case '*':Return5;
  
  
　Case '/':Return5;
  
  
　Case '%':Return5;
  
  
　Case '+':Return3;
  
  
　Case '-':Return3;
  
  
　Case ')':Return8;
  
  
　Default:Return0;
  
  
}
  
  
}
  
  
 
  
  
　IntIcp (CharOptr)
  
  
{
  
  
Switch(Optr)
  
  
{
  
  
　Case '=':Return0;
  
  
　Case '(':Return8;
  
  
　Case '^':Return6;
  
  
　Case '*':Return4;
  
  
　Case '/':Return4;
  
  
　Case '%':Return4;
  
  
　Case '+':Return2;
  
  
　Case '-':Return2;
  
  
　Case ')':Return1;
  
  
　Default:Return0;
  
  
}
  
  
}
  
  
};
  
  
 
  
  
# Endif 
 
 

Notes

1. The expressions are stored in a single-chain table. You can see that this linked list contains both operands and operators, if you have read another article about how to link different types of objects to the C ++ linked list, the method here is also a supplement to that article.

2. When an expression is input, the original content is cleared and must be input according to the infix. If you take a closer look at the infix expression, you will find that, except for the brackets, the expression structure is "operand", "operator", "operand ",...... "Operator (=)", in order to unify this rule, and to make the input function simpler, it is required that brackets enter "0 (", ") 0" in this way, "0" cannot appear in the expression as the operand. Because I have not added a fault-tolerant statement to the input function, once an error is entered, the program will be "dead.

3. The process of expression value evaluation is to first convert the expression into a suffix and then use a suffix to represent the value. Because the original book explains these two algorithms, and these two algorithms can be used to complete the evaluation of the infix expression, so I did not write the direct evaluation algorithm of the infix expression.

4. The two lines commented out by Calculate (). "%" is only valid for integer expressions. The "^" Power () function is not completed.

5. isp () and icp () return values. I 'd like to say a few more words. '=' (Expression start and end signs) has the lowest priority outside the stack. '('The maximum outside the stack, the lowest in the stack. ')' The minimum number of times outside the stack is not pushed to the stack. '^' The number of times in the stack is the highest, and the number of times out of the stack is lower than that in the stack. '× Memory %' is lower than '^' in the stack, and the out-of-stack is lower than in the stack. '+-' Stack is lower than '×' stack, and stack is lower than stack. In this way, there are nine priorities.

1. Analysis on C ++ stack usage
2. The database uses the C ++ Data Structure
3. Programmers must read the summary of c ++ pen questions
4. Common c ++ programming tools
5. C ++ Data Structure Learning stack and queue