public void Calculate(string[] args)
{
foreach (string token in args)
{
int value;
if (int.TryParse(token, out value))
{
stack.Push(value);
}
else
{
int rhs = stack.Pop();
int lhs = stack.Pop();
switch (token)
{
case "+":
stack.Push(lhs + rhs);
break;
case "-":
stack.Push(lhs - rhs);
break;
default:
throw new ArgumentException("Bad Argument");
}
}
}
Console.WriteLine(stack.Pop());
}
// sorted array by inorder DFS
public T[] ToSortedArray()
{
T[] arr = new T[Count];
int i = 0;
var stack = new Stack.Stack <TreeNode <T> >();
var node = Root;
while (node != null || stack.Count != 0)
{
while (node != null && !IsEdgeSentinel(node))
{
stack.Push(node);
node = node.Left;
}
node = stack.Pop();
arr[i] = node.Data;
++i;
node = node.Right;
}
return(arr);
}
public double Evaluate(List <string> operandsList)
{
foreach (char exp in Expression)
{
_queue.EnQueue(exp);
}
while (!_queue.IsEmpty())
{
var deQueued = (char)_queue.DeQueue();
if (deQueued > 96 && deQueued < 123)
{
var valueString = operandsList.FirstOrDefault(x => x.Contains(deQueued.ToString()));
_stack.Push(double.Parse(valueString.Split(' ')[1]));
}
else
{
var valueA = (double)_stack.Pop();
var valueB = (double)_stack.Pop();
switch (deQueued)
{
case '+':
_stack.Push(valueA + valueB);
break;
case '-':
_stack.Push(valueA - valueB);
break;
case '/':
_stack.Push(valueA / valueB);
break;
case '*':
_stack.Push(valueA * valueB);
break;
}
}
}
return((double)_stack.Pop());
}
public static void Main()
{
Stack.Stack <int> stack = new Stack.Stack <int>();
while (true)
{
string cmd = Console.ReadLine();
if (cmd == "END")
{
break;
}
string[] cmdArgs = cmd.Split(new char[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries);
switch (cmdArgs[0])
{
case "Push":
foreach (var numStr in cmdArgs.Skip(1))
{
stack.Push(int.Parse(numStr));
}
break;
case "Pop":
try
{
stack.Pop();
}
catch (InvalidOperationException)
{
Console.WriteLine("No elements");
}
break;
}
}
for (int i = 0; i < 2; i++)
{
foreach (var num in stack)
{
Console.WriteLine(num);
}
}
}
public PostFix ToPostFix()
{
List <char> operatorsList = new List <char>()
{
'+', '-', '*', '/'
};
List <char> additiveOp = new List <char>()
{
'+', '-'
};
List <char> multiplicativeOp = new List <char>()
{
'*', '/'
};
string returnString = "";
foreach (char input in Expression) //7
{
if (input > 96 && input < 123) //2
{
_queue.EnQueue(input);
continue;
}
if (input == '(') //3
{
_stack.Push(input);
continue;
}
if (input == ')') //4
{
while ((char)_stack.Peek() != '(')
{
_queue.EnQueue(_stack.Pop());
}
_stack.Pop();
continue;
}
if (operatorsList.Contains(input) && (_stack.GetSize() == 0 || (char)_stack.Peek() == '(')) //5
{
_stack.Push(input);
continue;
}
while (!_stack.IsEmpty() && (additiveOp.Contains(input) && multiplicativeOp.Contains((char)_stack.Peek()))) //6
{
if (operatorsList.Contains(input) && !_stack.IsEmpty())
{
if (additiveOp.Contains(input) && multiplicativeOp.Contains((char)_stack.Peek()))
{
_queue.EnQueue(_stack.Pop());
}
else
{
_stack.Push(input);
}
}
}
}
while (!_stack.IsEmpty())
{
_queue.EnQueue(_stack.Pop());
}
while (!_queue.IsEmpty())
{
returnString += _queue.DeQueue();
}
return(new PostFix(returnString));
}