Chapter 2. Stack & Queues. M hiwa ahmad aziz

Size: px

Start display at page:

Download "Chapter 2. Stack & Queues. M hiwa ahmad aziz"

Roger Conley
5 years ago
Views:

1 . Chapter 2 Stack & Queues M hiwa ahmad aziz 1

2 Stack A stack structure with a series of data elements that Allows access to only the last item inserted. An item is inserted or removed from the stack from one end called the top of the stack. This mechanism is called Last-In-First-Out (LIFO). Adding a data item on the top is called pushing, while removing an item from the top is called popping it. push and pop are the primary stack operations. Top changed -1 to n and in first top=-1. 2

3 Stack If top=-1 stack is empty and if top=n -1stack is full 3

4 stk: Stack top = 3 or count = 4 If stack is represented by top = -1 or count = 0, then an empty stack To add (push) an element, either: Increment top and store the element in stk[top], or Store the element in stk[count-1] and increment count To remove (pop) an element, either: Get the element from stk[top] and decrement top, or Decrement count and get the element in stk[count-1] 4

5 Constructor Constructor in java is a special type of method that is used to initialize the object and field. Java constructor is invoked at the time of object creation. Rules for creating java constructor 1. Constructor name must be same as its class name 2. Constructor must have no explicit return type Types of java constructors 1. Default constructor (no-arg constructor) 2. Parameterized constructor 5

6 Constructor output Default Constructor 6

7 Constructor Constructor Main method 7

8 Push in Stack public void push(object item) { if(top==stack.length-1) { System.out.println("Stack is Full"); return; //end if stack[++top]=item; 8

9 Pop in Stack public object pop( int stk, int top) { /* return the top element from the stack */ if (top == -1) { System.out.println("Stack is Empty"); return null; return stk [top--]; 9

10 Peek and display and count public Object peek() { if (top == -1) { System.out.println("stack is empty"); return 0; return stack[top];. void count() { System.out.println(top + 1); public void display() { for (int i = top; i >= 0; i--) System.out.println(stack[i] + " "); 10

11 push& pop Example : implement the following operations in sequence from left to right by drawing shapes. Push(15), Push(7), Push(-12), pop(a), pop(b), Push(3) 11

12 Error checking There are two stack errors that can occur: Underflow: trying to pop (or peek at) an empty stack Overflow: trying to push onto an already full stack For underflow, you should throw an exception You could create your own, more informative exception For overflow, you could do the same things Or, you could check for the problem, and copy everything into a new, larger array 12

13 Sharing space Of course, the bottom of the stack could be at the other end stk: top = 6 or count = 4 Sometimes this is done to allow two stacks to share the same storage area. Stk1=n1, stk2= n2 Stks= n1 +n2 stks: topstk1 = 2 topstk2 = 6 13

14 Multiple stack But if more than two stack implemented in an array, The previous method is not applicable. In this case, for the production of n stack in the array S [1... m], n part of our array. For each stack i, b [i] to the lowest element and t [i] refers to the highest element, and if b [i] = t [i] is the i-th stack is empty. 14

15 Multiple stack Example : If the array S [ ] we want to create 4 stack,what is the address of the beginning of each stack? (Assuming the same stack size). t[1]=[495/4](1-1)+1=1 t[2]=[495/4](2-1)+1=124 t[3]=[495/4](3-1)+1=247 t[4]=[495/4](4-1)+1=370 15

16 implement a Stack package stackmethods; import java.util.arrays; class StackMethods { private int top; int size; int[] stack ; public StackMethods(int arraysize){ size=arraysize; stack= new int[size]; top=-1; public void push(int value){ if(top==size-1){ System.out.println("Stack is full, can't push a value"); else{ stack[++ top]=value; { public int pop(){ if(top==-1) System.out.println("Can't pop...stack is empty"); return stack[top - -]; public boolean isempty(){ return top==-1; public void display(){ for(int i=0;i<=top;i++){ System.out.print(stack[i]+ " "); System.out.println(); public static void main(string[] args) StackMethods newstack = new StackMethods(5); newstack.push(10); newstack.push(1); newstack.push(50); newstack.push(20); newstack.push(90); newstack.display(); newstack.pop(); newstack.pop(); newstack.pop(); newstack.pop(); newstack.display(); 16

17 Import java.util.stack The Stack ADT, as provided in java.util.stack: Stack(): the constructor boolean empty() (but also inherits isempty()) Object push(object item) Object peek() Object pop() int search(object o): Returns the 1-based position of the object on this stack 17

18 Other Implement a Stack package arraystack; import java.util.stack; public class ArrayStack { Object stack[]; int top; ArrayStack(int n){ stack=new Object[n]; top=-1; //end constrctor ArrayStack // public void push(object item){ if(top==stack.length-1){ // public Object peek(){ if(isempty()) return null; return stack[top]; //end peek // public boolean isempty(){ return (top==-1); //end isempty // public int size(){ return top+1; //end size // public void reversestring(){ System.out.println("size of stack= "+stk.size()); System.out.println("pop= "+stk.pop()); stk.push('e'); stk.push('f'); System.out.println("top of stack= "+stk.peek()); System.out.print("string after reverse: "); stk.reversestring(); System.out.println(); // TODO code application logic here System.out.println("Stack is Full"); return; //end if top++; stack[top]=item; //end push // public Object pop(){ { if(top==-1) // or can if(isempty()) System.out.println("Stack is Empty"); return null; //end if Object tmp=stack[top]; top--; return tmp; //end pop ArrayStack stk=new ArrayStack(6); String word="abcdef"; for(int i=0;i<word.length();i++) stk.push(word.charat(i)); while(!stk.isempty()) System.out.print(stk.pop()+" "); //end reversestring public static void main(string[] args) { ArrayStack stk=new ArrayStack(4); stk.push('a'); stk.push('b'); stk.push('c'); stk.push('d'); 18

19 application of stack Example: If the sequence numbers 1,2,3,4,5,6, respectively, from left to right stack Which of the following output of the stack is not possible. a) b) c) d) Input: 1, 3, 4, 5, d) a) b) c) d)

20 application of stack Example: the sequence numbers 1,2,3,4,5,6,7,8 respectively, from left to right stack. can the following output with push and pop. Answer : 20

21 Infix to Postfix & prefix Conversion The expression A + B * C + D can be rewritten as ((A + (B * C)) + D) to show that the multiplication happens first, followed by the leftmost addition. A + B * C + D can be written as (((A + B) *C) + D) since the addition operations associate from left parenthesis to prefix expression and right parenthesis to postfix expression. Example : postfix (A + (B * C)) = ABC*+ Prefix: (A + (B * C)) = +A*BC 21

22 Infix to Postfix & prefix Conversion Example: more complex expression: (A + B) * C - (D - E) * (F + G). 22

23 Infix to Postfix & prefix Conversion Example: more complex expression: Postfix prefix 23

24 Infix to Postfix & prefix Conversion Example: more complex expression: (A + B) * C - (D - E) * (F + G). 24

General algorithm for Conversion Infix-to-Postfix Scan the token list from left to right. 1) If the token is an operand, append it to the end of the output list.

25 General algorithm for Conversion Infix-to-Postfix Scan the token list from left to right. 1) If the token is an operand, append it to the end of the output list. 2) If the token is an operator, *, /, +, or -, push it on the stack. However, first remove any operators already on the stack that have higher or equal precedence and append them to the output list. 3) When the input expression has been completely processed, check the stack. Any operators still on the stack can be removed and appended to the end of the output list. 25

26 General Infix-to-prefix Conversion 26

27 General Infix-to-postfix Conversion 27

28 General Infix-to-Postfix Conversion Following figure shows the conversion algorithm working on the expression A * B + C * D. Note that the first * operator is removed upon seeing the + operator. Also, + stays on the stack when the second * occurs, since multiplication has precedence over addition. At the end of the infix expression the stack is popped twice, removing both operators and placing + as the last operator in the postfix expression. 28

29 example We can now handle this result by placing it back on the stack so that it can be used as an operand for the later operators in the expression. When the final operator is processed, there will be only one value left on the stack. Pop and return it as the result of the expression. Ex= * + 29

30 Use the stack for calculate following postfix expression / Example(postfix to infix) 30

31 Example(prefix to infix) Use the stack for calculate following prefix expression. 31

32 Example(prefix to postfix) Use the stack for convert following prefix expression to postfix. 32

33 Queue Queue is an ADT data structure similar to stack, except that the first item to be inserted is the first one to be removed. This mechanism is called First-In-First-Out (FIFO). Placing an item in a queue is called insertion or enqueue, which is done at the end of the queue called rear. Removing an item from a queue is called deletion or dequeue, which is done at the start of the queue called front. Total no of elements in queue= rear front +1 33

34 Queue Applications Some of the applications are : Real-World Applications Cashier lines in any store Check out at a bookstore Bank / ATM Call an airline Computer Science Applications Print lines of a document Printer sharing between computers Recognizing palindromes Shared resource usage (CPU, memory access, ) 34

35 Queue implementation First the queue is empty insert insert insert delete delete

36 When queue is empty FRONT = 0 and REAR = -1 Insertion Adding an element in queue will increased value of REAR by 1 Removal rear = rear + 1 or rear ++ Removing an element from queue will increased value of FRONT by 1 front = front+ 1 or front++ 36

37 Enqueue operation 37

38 Enqueue operation rear==maxsize-1 (front =rear )!!! 38

39 Algorithm Enqueue (item) 1.If (rear = size -1 ) print ( queue overflow ) return 2.else rear ++ Queue [rear] = item 39

40 Dequeue operation que[front++]=null ; 40

41 Dequeue operation (front =rear) is empty or full!!!! 41

42 Algorithm Enqueue (item) 1.if (front =rear && count=0 ) print queue empty ; return; 2. else item = queue [front]; Front ++; Return item ; 42

43 Circuit Queue After a few insert and delete operations the rear might reach the end of the queue and no more items can be inserted although the items from the front of the queue have been deleted and there is space in the queue. To solve this problem, queues implement wrapping around. Such queues are called Circular Queues. Both the front and the rear pointers wrap around to the beginning of the array. It is also called as Ring buffer. Items can inserted and deleted from a queue in O(1) time. 43

44 Circuit Queue for insert in circuit queue 44

45 Empty Circuit Queue : Circuit Queue if (front==rear ) && count==0 queue is empty if (front==rear ) && count==size queue is full 45

46 For know full circuit queue or empty we have to define variable count=0 if insert itrm count++ and if delete item count--. If (count==0) && (rear==front) queue is empty If (count== size) && (rear==front) queue is full If (rear == size -1) means circuit queue and rear=0 For insert que[++rear]=item; and count++ For remove que[front ++]=item; and count-- 46

47 Creat queue & insert package arrayqueue; public class ArrayQueue { int maxsize; Object []que; int front; int rear; int count; ArrayQueue(int s){ maxsize=s; que=new Object[maxsize]; front=0 ; rear=-1; //end ArrayQueue // public void insert(object item){ if (count == size) { System.out.println("queue is full"); return; if (rear == size - 1) { rear = 0; que[rear] = item; else { que[++rear] = item; count++; //end insert 47

48 Remove & peek & empty & display public Object remove(){ if (count == 0) { System.out.println("queue is empty"); return 0; Object item = que[front]; que[front] = null; if (front == size - 1) { front = 0; else { front++; count--; return item; //end remove // public Object peek(){ return que[front]; // public boolean isempty(){ return count==0; // public int size(){ return count; // public void display(){ System.out.print("Queue: "); for(int i=0;i<= rear ;i++) System.out.print(que[i]+" "); System.out.println(); 48

49 public static void main(string[]args){ ArrayQueue q=new ArrayQueue(3); q.insert('a'); q.insert('b'); q.insert('c'); q.display(); System.out.println(q.remove()+" is deleted"); System.out.println("Queue after delete"); q.display(); q.insert('d'); q.display(); Main method System.out.println("peek= "+q.peek()); System.out.println("Queue size= "+q.size()); //end main //end class 49

50 50

Lecture Data Structure Stack

Lecture Data Structure Stack 1.A stack :-is an abstract Data Type (ADT), commonly used in most programming languages. It is named stack as it behaves like a real-world stack, for example a deck of cards