•	Evaluating a postfix expression using a stack
•	while there are tokens
•	Get the token
•	If token is operand then stack.Add(token)
•	else 
•	stack.Delete(second)
•	stack.Delete(first)
•	result = first token second // token is the operator
•	stack.Add(result)
•	return stack.Top()
•	20 2 * 9 + 14 7 / - 5 3 * +
•	20 and 2 go on top the stack (20, 2)
•	when we come across * we pop two items from the stack
•	second = 2, first = 20; result = 20 * 2 = 40 goes on stack
•	9 goes on top of the stack (40,9)
•	+ pop 9 and 40
•	second = 9, first = 40; result = 40 + 9 = 49 goes on stack (49)
•	14 and 7 go on stack (49,14,7)
•	for division second = 7, first = 14 result = 14 / 7 = 2 goes on stack (49,2)
•	- operator: second = 2, first = 49, result = 49 - 2 = 47 goes on stack (47)
•	5 and 3 on stack (47,5,3)
•	*: second = 3, first = 5, result = 15 goes on stack (47,15)
•	+: second = 15, first = 47, result = 62 (62)
•	no more tokens, stack has the answer: 62
•	Given an infix expression: Priorities for the operators and parantheses. They make things complicated
•	we use stack of operators instead of operands
•	Operators have different priorities in stack and outside the stack
					
Operator	In stack priority	In-coming priority	
)	-	-	
^	3	3	
*,/	2	2	
+, -	1	1	
(	0	4	
while true do
	if we are at the end of expression then
			print the stack and quit
	else
		if x is an operand then
			print x
		else if x = ')' then
			while top of the stack is not equal to '(' do
				Delete an item from the stack 							and print the item deleted
			pop '(' from the stack
		else 
			while the priority of the item on top of the 							stack is not less than priority of x do
				Delete an item from the stack 							and print the item retrieved
			push x on the top of the stack
end {while}
•	(9*3)/(7+(5*4)) + (9 +72)/3^3
•	Output:
•	9 3 * 7 5 4 * + / 9 72 + 3 3 ^ / +
•	( goes on stack [(]
•	9 gets printed, * icp = 2goes on top of ( because in stack priority isp of ( is 0. [(,*]
•	3 gets printed, ) prints out stack as long as (, pops ( without printing it, []
•	/ goes on stack [/], ( icp=4 goes on stack [/,(]
•	7 print, + goes on top of stack isp of ( is 0 [/,(,+]
•	( isp = 4 [/,(,+,(]
•	5 print, * on stack [/,(,+,(,*]
•	4 print, ) print out until (,  repeat for next ) [/]
•	+ can’t go on top / pop and print / [+]
•	see the board for the rest of the details
•	See how the resulting expression was evaluated to 4

Binary Search Trees
•	Binary trees by themselves don’t have inserting and deleting strategies. We had to build the tree from bottom up.
•	Binary expression trees had fixed buidling strategy from prefix expressions
•	Binary expression trees are static in the sense that we cannot keep on adding or deleting nodes to the BXTree once it is built
•	Binary search trees use dynamic insertion and deletion
•	Binary search tree is either empty
•	Or has a root 
•	and left and right subtrees which are binary search tree
•	Every item in the left subtree is smaller than the item in the root
•	Every item in right subtree is larger than the root