1 / 34

Stacks

top. F E D C B A. 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. Array Implementation.

abla
Download Presentation

Stacks

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. top F E D C B A 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 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 ! stacks, queues

  3. Stack ADT interface Stack { public void clear( ) //remove all ELEM's public void push(Object it) //push ELEM onto stack public Object pop( ) // pop ELEM from top public Object topValue( ) // value of top ELEM public bool isEmpty( ) // TRUE if stack is empty } stacks, queues

  4. size size top 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; } } stacks, queues

  5. top Dynamic Memory Implementation • Simplified version of the linked list implementation • the head and tail pointers of the list implementation are not used 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 stacks, queues

  7. - - wrong - Applications • Checking mathematical expressions • Equal number of left/right (, {, [, ), }, ] 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!! stacks, queues

  9. [ ( ( ( ( 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+ 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 stacks, queues

  12. Infix to Postfix or Prefix • A+B*C : ‘*’ > ‘+’ A+(B*C) : equivalent Α+(ΒC*) : B*C topostfix ABC*+ : postfix • (A+B)*C : (…) > ‘*’ (AB+)*C : A+B topostfix (AB+)C* : (AB+)*C topostfix AB+C* : postfix • Postfix and Prefix have no parenthesis !! 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 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 “(”, “[”, “{”, “)”, “]”, “}” 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 “+” stacks, queues

  16. Symbol ( A + B ) * C Postfix A A AB AB+ AB+ AB+C AB+C* Stack ( ( (+ (+ * * Example: (A + B)*C stacks, queues

  17. stack = 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); } Algorithm stacks, queues

  18. Evaluation of Postfix While (not end of expression) { read symbols from left to right; result = 0 if (symbol == operand) push (stack); else { operand1 = pop(stack); operand2 = pop(stack); result = operand1 operator operand2; push(stack, result); } } result = pop(stack); stacks, queues

  19. Postfix: 6 2 3 + - 3 8 2 / + * 2 $ 3 + Symbol 6 2 3 + - 3 8 2 / + * 2 $ 3 + Operand1 2 6 6 6 6 8 3 1 1 7 7 49 Operand2 3 5 5 5 5 2 4 7 7 2 2 3 Value 5 1 1 1 1 4 7 7 7 49 49 52 stack Operand 6 6,2 6,2,3 6,5 1 1,3 1,3,8 1,3,8,2 1,3,4 1,7 7 7,2 49 49,3 52 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 stacks, queues

  21. rear front enqueue (queue, D) A B C dequeue (queue) A B C D B C D stacks, queues

  22. 4 3 2 1 0 x x 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? stacks, queues

  23. 4 3 2 1 0 4 3 2 1 0 A Condition of empty queue:rear = front Initial values: rear = front = LIST_SIZE - 1 front points to the position proceeding the first element front = 4 rear = 4 front = 4 rear = 0 input A stacks, queues

  24. 4 3 2 1 0 C B Α 4 3 2 1 0 D C B Α 4 3 2 1 0 E D C B Α front = 4 rear = 2 front = 4 rear = 3 The condition of empty queue is true but the queue is not empty  “E” cannot be inserted: The last array positionmust be left empty front = 4 rear = 4 stacks, queues

  25. Insert “E”, “F” Circular list Delete“Α” 4 3 2 1 0 E D front = 2 rear = 0 front = 0 rear = 3 C F 4 3 2 1 0 4 3 2 1 0 D D Delete“B” C C B B Α front = 1 rear = 3 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 } stacks, queues

  27. size front size rear 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; } 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 stacks, queues

  29. front rear 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 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 } 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 stacks, queues

  32. Priority Queue • Ascending: elements in any order but dequeue removes the minimum • Descending: dequeue removes the maximum stacks, queues

  33. 5 4 3 2 1 Ε front = 5 rear = 4 D G Α ascending descending 5 4 3 2 1 5 4 3 2 1 Ε Ε front = 5 rear = 4 front = 5 rear = 4 D D G ? Α Example: Dequeue stacks, queues

  34. 5 4 3 2 1 5 4 3 2 1 Ε E D D G Α Α 5 4 3 2 1 5 4 3 2 1 G Ε E D D Α Α Array Implementation • Problem: dequeue creates empty slots • Solution(1): move elements: Θ(n) operations on dequeue • Solution(2): store elements in ascending (descending) order: Θ(n) operations on enqueue stacks, queues

More Related