e.g.m. petrakisstacks, queues1 stacks stack: restricted variant of list elements may by inserted...
Post on 19-Dec-2015
218 views
TRANSCRIPT
E.G.M. Petrakis stacks, queues 1
Stacks
Stack: restricted variant of list elements may by inserted or deleted
from only one end : LIFO lists top: the accessible end of the list operations: “push”, “pop” many applications easy to implement:
arrays linked lists
FEDCBA
top
E.G.M. Petrakis stacks, queues 2
Array Implementation
A simplified version of list implementation array of fixed size top: always the first element current is always the top element push: insert at top ! pop: remove from top !
E.G.M. Petrakis stacks, queues 3
Stack ADT
interface Stack { public void clear( ) //remove all ELEM'spublic void push(Object it) //push ELEM onto stackpublic Object pop( ) // pop ELEM from toppublic Object topValue( ) // value of top ELEMpublic bool isEmpty( ) // TRUE if stack is empty
}
E.G.M. Petrakis stacks, queues 4
class AStack implements Stack { // Array based stack class private static final int defaultSize = 10; private int size; // Maximum size of stack private int top; // Index for top Object private Object [] listarray; // Array holding stack
AStack() { setup(defaultSize); } AStack(int sz) { setup(sz); } private void setup(int sz) { size = sz; top = 0; listarray = new Object[sz]; }
public void clear() { top = 0; } // Clear all Objects public void push(Object it) // Push onto stack { Assert.notFalse(top < size, "Stack overflow"); listarray[top++] = it; } public Object pop() // Pop Object from top { Assert.notFalse(!isEmpty(), "Empty stack"); return listarray[--top]; } public Object topValue() // Return top Object { Assert.notFalse(!isEmpty(), "Empty stack"); return listarray[top-1]; } public boolean isEmpty() { return top == 0; }}
sizetop
size
E.G.M. Petrakis stacks, queues 5
Dynamic Memory Implementation
Simplified version of the linked list implementation the head and tail pointers of the list
implementation are not used
top
E.G.M. Petrakis stacks, queues 6
class LStack implements Stack { // Linked stack class
private Link top; // Pointer to list header
public LStack() { setup(); } // Constructor private void setup() // Initialize stack { top = null; } // Create header node
public void clear() { top = null; } // Clear stack public void push(Object it) // Push Object onto stack { top = new Link(it, top); } public Object pop() { // Pop Object from top Assert.notFalse(!isEmpty(), "Empty stack"); Object it = top.element(); top = top.next(); return it; } public Object topValue() // Get value of top Object { Assert.notFalse(!isEmpty(), "No top value"); return top.element(); } public boolean isEmpty() // True if stack is empty { return top == null; }} // Linked stack class
E.G.M. Petrakis stacks, queues 7
Applications
Checking mathematical expressions Equal number of left/right (, {, [, ), }, ]
2.5))Y)/(43)Y)/(J((X*((X7 -
-
- CAB))(A
C)B)A
B)((A
wrong
E.G.M. Petrakis stacks, queues 8
Algorithm
Read the expression from left to right p: next symbol in expression Repeat until (empty(stack) ) {
read(p); if p = ( or { or [ then push(stack,p);
loop; if p = ) or } or ] then c = pop(stack); if c != p then error!! }
if (not empty(stack) ) then error!!
E.G.M. Petrakis stacks, queues 9
e)]}[(dc*b])[a(y{x
[(((
[(k(je)]}/(h[(dc*b])[a(y{x
(n]))[l(k(je)]}/(h[(dc*b])[a(y{x
n])))[l(k(je)]}/(h[(dc*b])[a(y{x
E.G.M. Petrakis stacks, queues 10
More Applications
Evaluation of arithmetic expressions: convert infix to postfix or prefix evaluate postfix or prefix expression
infix, prefix, postfix: refer to the relative position of the operator with respect to the operands infix : A+B prefix : +AB postfix : AB+
E.G.M. Petrakis stacks, queues 11
Infix to Postfix or Prefix
Read from left to right First convert operations of higher
precedence parenthesis have the highest precedence “^” have precedence over “*”, “/” have the same precedence but higher than “+”, “-” which all have the same precedence
The converted prefix or postfix part is treated as a single operand
If all operators have the same precedence then convert from left to right
E.G.M. Petrakis stacks, queues 12
Infix to Postfix or Prefix
A+B*C : ‘*’ > ‘+’ A+(B*C) : equivalent Α+(ΒC*) : B*C to postfix ABC*+ : postfix
(A+B)*C : (…) > ‘*’ (AB+)*C : A+B to postfix (AB+)C* : (AB+)*C to postfix AB+C* : postfix
Postfix and Prefix have no parenthesis !!
E.G.M. Petrakis stacks, queues 13
Infix to Postfix or Prefix
A+B-C : ΑΒ+C- postfix (A+B)*(C-D) : AB+CD-* Α$Β*C-D+E/F/(G+H) : AB$C*D-EF/GH+/+ A-B/(C*D$E) : ABCDE$*/-
A+B-C : -+ABC prefix (A+B)*(C-D) : *+AB-CD A$B*C-D+E/F/(G+H) : +-*$ABCD//EF+GH A-B/(C*D$E) : -A/B*C$DE
E.G.M. Petrakis stacks, queues 14
Convert infix to postfix
Read expression from left to right output operands push operators to stack higher precedence operators must be above lower
precedence operators before pushing an operator into the stack check the
precedence of operators already in the stack if operator in stack has higher precedence output this
operator and then insert the current operator in the stack
“(”, “[”, “{” have higher precedence, push in stack if “)”, “]”, “}” pop stack until “(”, “[”, “{” is found don’t output “(”, “[”, “{”, “)”, “]”, “}”
E.G.M. Petrakis stacks, queues 15
Infix to Postfix Example
(A + B)*C push “(” in stack output A push “+” in stack output B don’t push “)”, pop all operators output “+”, ignore “(”, “)” “*” push in stack output C output “+”
E.G.M. Petrakis stacks, queues 16
Symbol(A+B)*
C
Postfix
AA
ABAB+AB+
AB+CAB+C*
Stack((
(+(+
*
*
Example: (A + B)*C
E.G.M. Petrakis stacks, queues 17
Algorithmstack = NULL;while (not end of input) { symbol = read next symbol; if (symbol == operand) output(symbol); else {
while(!empty(stack) && (preced (stack(top)) > preced(symbol))
{ top symbol = pop(stack); output(top symbol); } push(stack, symbol); }
}while not_empty(stack) { top symbol = pop(stack); output(top symbol);}
E.G.M. Petrakis stacks, queues 18
Evaluation of PostfixWhile (not end of expression) {
read symbols from left to right;result = 0if (symbol == operand) push (stack);else {
operand1 = pop(stack);operand2 = pop(stack);result = operand1 operator operand2;push(stack, result);
} } result = pop(stack);
E.G.M. Petrakis stacks, queues 19
Postfix: 6 2 3 + - 3 8 2 / + * 2 $ 3 + Symbol623+-382/+*2$3+
Operand1
2666683117749
Operand2
355552477223
Value
511114777
494952
stack Operand 6
6,26,2,36,51
1,31,3,8
1,3,8,21,3,41,77
7,249
49,352
E.G.M. Petrakis stacks, queues 20
Queue
Queue elements may only be inserted at the rear and removed from the front restricted form of list FIFO: first in first out insert: enqueue operation remove: dequeue operator
E.G.M. Petrakis stacks, queues 22
Array Implementation
If the elements are the first n elements of array and the front element is at position 0
enqueue requires Θ(1) operations but,
dequeue requires Θ(n) operations (all elements must be shifted)
Condition of empty queue?
43210 x
x
E.G.M. Petrakis stacks, queues 23
front = 4rear = 4
front = 4rear = 0
43210
A
43210
Condition of empty queue: rear = front Initial values: rear = front = LIST_SIZE - 1
front points to the positionproceeding the first element
input A
E.G.M. Petrakis stacks, queues 24
DCBΑ
43210
EDCBΑ
43210
front = 4rear = 2
front = 4rear = 3
front = 4rear = 4
The condition of empty queue is true but the queue is not empty “E” cannot be inserted: The last array position must be left empty
CBΑ
43210
E.G.M. Petrakis stacks, queues 25
DCBΑΑ
43210
Delete “ΑΑ”
front = 0rear = 3
DCBB
43210
Delete “BB”
front = 1rear = 3
EDC
F
43210
Insert “E”, “F” Circular list
front = 2rear = 0
E.G.M. Petrakis stacks, queues 26
Queue ADT
public interface Queue { // Queue ADT
public void clear(); // Remove all Objects from queue public void enqueue(Object it); // Enqueue Object at rear of
queue public Object dequeue(); // Dequeue Object from front of
queue public Object firstValue(); // Return value of top Object public boolean isEmpty(); // Return TRUE if stack is empty}
E.G.M. Petrakis stacks, queues 27
class AQueue implements Queue { // Array-based queue class
private static final int defaultSize = 10; private int size; // Maximum size of queue private int front; // Index prior to front item private int rear; // Index of rear item private Object [] listArray; // Array holding Objects
AQueue() { setup(defaultSize); } // Constructor: default size AQueue(int sz) { setup(sz); } // Constructor: set size
void setup(int sz) // Initialize queue { size = sz+1; front = rear = 0; listArray = new Object[sz+1]; }
public void clear() // Remove all Objects from queue { front = rear = 0; }
sizefrontrear size
E.G.M. Petrakis stacks, queues 28
public void enqueue(Object it) { // Enqueue Object at rear Assert.notFalse(((rear+1) % size) != front, "Queue is full"); rear = (rear+1) % size; // Increment rear (in circle) listArray[rear] = it; }
public Object dequeue() { // Dequeue Object from front Assert.notFalse(!isEmpty(), "Queue is empty"); front = (front+1) % size; // Increment front return listArray[front]; // Return value }
public Object firstValue() { // Return value of front Object Assert.notFalse(!isEmpty(), "Queue is empty"); return listArray[(front+1) % size]; }
public boolean isEmpty() // Return true if queue is empty { return front == rear; }} // class AQueue
E.G.M. Petrakis stacks, queues 29
Dynamic Memory Implementation
Simple adaptation of the linked list implementation current always points to the first element the head pointer of the list implementation is not
used
front
rear
E.G.M. Petrakis stacks, queues 30
class LQueue implements Queue { // Linked queue class
private Link front; // Pointer to front node private Link rear; // Pointer to rear node
public LQueue() { setup(); } // Constructor public LQueue(int sz) { setup(); } // Constuctor: Ignore sz
private void setup() // Initialize queue { front = rear = null; }
// Remove all Objects from queue public void clear() { front = rear = null; }
public void enqueue(Object it) { // Enqueue Object at rear of queue if (rear != null) { // Queue not empty: add to end rear.setNext(new Link(it, null)); rear = rear.next(); } else front = rear = new Link(it, null); // Empty queue }
E.G.M. Petrakis stacks, queues 31
public Object dequeue() { // Dequeue Object from front Assert.notFalse(!isEmpty()); // Must be something to dequeue Object it = front.element(); // Store dequeued Object front = front.next(); // Advance front if (front == null) rear = null; // Dequeued last Object return it; // Return Object }
public Object firstValue() // Return value of top Object { Assert.notFalse(!isEmpty()); return front.element(); }
public boolean isEmpty() // Return true if queue is empty { return front == null; }} // classes LQueue
E.G.M. Petrakis stacks, queues 32
Priority Queue
Ascending: elements in any order but dequeue removes the minimum
Descending: dequeue removes the maximum
E.G.M. Petrakis stacks, queues 33
ΕDGΑ
54321
front = 5rear = 4
ΕDG
54321
front = 5rear = 4
front = 5rear = 4
ascending descending
ΕD
Α
54321 ?
Example: Dequeue