Understanding Stack Data Structure and Array Implementation

stack n.w
1 / 57
Embed
Share

Explore the fundamentals of stack data structure, including its real-world examples, linear structure characteristics, and array implementation. Learn about operations such as push, pop, peek, and the algorithm for inserting values. Dive into the concepts of LIFO and FILO with visual representations aiding in comprehension.

  • Data Structure
  • Stack
  • Array
  • Implementation
  • Algorithm
rayaanacharya
ztha Follow

Uploaded on | 0 Views

Download Presentation

Please find below an Image/Link to download the presentation.

The content on the website is provided AS IS for your information and personal use only. It may not be sold, licensed, or shared on other websites without obtaining consent from the author. If you encounter any issues during the download, it is possible that the publisher has removed the file from their server.

You are allowed to download the files provided on this website for personal or commercial use, subject to the condition that they are used lawfully. All files are the property of their respective owners.

Download Presentation

The content on the website is provided AS IS for your information and personal use only. It may not be sold, licensed, or shared on other websites without obtaining consent from the author.

E N D

Presentation Transcript

  1. STACK Some Real World Examples Dr. Jyoti Lakhani 1

  2. STACK A Linear Data Structure 1 Last In First Out (LIFO) / First in Last Out (FILO) 2 TOP Insertion : POP() Deletion : Push() 3

  3. STACK A Linear Data Structure Last In First Out (LIFO) /First in Last Out (FILO) TOP 3 Insertion : POP() Deletion : PUSH( ITEM) 2 PEEK() 1

  4. STACK A Linear Data Structure Last In First Out (LIFO) /First in Last Out (FILO) TOP 3 Insertion : POP() Deletion : PUSH( ITEM) 2 PEEK() 1

  5. STACK [N ] : Array Implementation STACK [ N ] Cases 3 { Empty Stack, Half Full, Full } EMPTY HALF FULL FULL Size -1 Size -1 4 4 Size -1 4 TOP = 4 55 3 3 3 44 2 2 33 2 22 1 1 TOP = 1 22 1 0 0 11 0 11 TOP = -1 5

  6. STACK:: PUSH() Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO 8/14/2020 6

  7. STACK [N ] : Array Implementation INFO = 11 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 2 1 0 TOP = -1 7

  8. STACK [N ] : Array Implementation INFO = 11 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 2 1 0 TOP = -1 8

  9. STACK [N ] : Array Implementation INFO = 11 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 2 1 0 TOP = -1 9

  10. STACK [N ] : Array Implementation INFO = 11 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 2 1 0 TOP = 0 10

  11. STACK [N ] : Array Implementation INFO = 11 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 2 1 0 11 TOP = 0 11

  12. STACK [N ] : Array Implementation INFO = 22 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 2 1 0 TOP = 0 11 12

  13. STACK [N ] : Array Implementation INFO = 22 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 2 1 0 11 TOP = 0 13

  14. STACK [N ] : Array Implementation INFO = 22 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 2 1 TOP = 1 0 11 14

  15. STACK [N ] : Array Implementation INFO = 22 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 2 22 1 TOP = 1 0 11 15

  16. STACK [N ] : Array Implementation INFO = 33 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 2 22 1 TOP = 1 0 11 16

  17. STACK [N ] : Array Implementation INFO = 33 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 2 22 1 TOP = 1 0 11 17

  18. STACK [N ] : Array Implementation INFO = 33 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 2 TOP = 2 22 1 0 11 18

  19. STACK [N ] : Array Implementation INFO = 33 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 TOP = 2 33 2 22 1 0 11 19

  20. STACK [N ] : Array Implementation INFO = 44 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = 5 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 33 2 TOP = 2 22 1 0 11 20

  21. STACK [N ] : Array Implementation INFO = 44 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = 5 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 33 2 TOP = 2 22 1 0 11 21

  22. STACK [N ] : Array Implementation INFO = 44 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = 5 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 TOP = 3 33 2 22 1 0 11 22

  23. STACK [N ] : Array Implementation INFO = 44 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 44 TOP = 3 33 2 22 1 0 11 23

  24. STACK [N ] : Array Implementation INFO = 55 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = 5 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 44 TOP = 3 33 2 22 1 0 11 24

  25. STACK [N ] : Array Implementation INFO = 55 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = 5 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 3 44 TOP = 3 33 2 22 1 0 11 25

  26. STACK [N ] : Array Implementation INFO = 55 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 TOP = 4 3 44 33 2 22 1 0 11 26

  27. STACK [N ] : Array Implementation INFO = 55 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 55 TOP = 4 3 44 33 2 22 1 0 11 27

  28. STACK [N ] : Array Implementation INFO = 66 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 55 TOP = 4 3 44 33 2 22 1 0 11 28

  29. STACK [N ] : Array Implementation INFO = 66 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 55 TOP = 4 3 44 33 2 22 1 0 11 29

  30. STACK [N ] : Array Implementation INFO = 66 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 55 TOP = 4 3 44 33 2 22 1 0 11 30

  31. STACK [N ] : Array Implementation INFO = 66 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 55 TOP = 4 3 44 33 2 22 1 0 11 31

  32. STACK [N ] : Array Implementation INFO = 66 SIZE = 5 EMPTY Algorithm : PUSH ( INFO , SIZE) Input : Accepts a value (INFO) to be inserted in the STACK and SIZE of the STACK Output: STACK with value inserted at the TOP Steps: 1. [CASE 1: STACK is full] If TOP = = Size-1 Print( Stack is Full ) Return Else 2. [CASE 2 -3: Stack is Empty or Half Full] TOP = TOP + 1 STACK [ TOP ] = INFO Size -1 4 55 TOP = 4 3 44 33 2 22 1 0 11 32

  33. STACK:: POP() Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 8/14/2020 33

  34. STACK [N ] : Array Implementation INFO = SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 3 2 1 0 TOP = -1 34

  35. STACK [N ] : Array Implementation INFO = SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 3 2 1 0 TOP = -1 35

  36. STACK [N ] : Array Implementation INFO = SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 3 2 1 0 TOP = -1 36

  37. STACK [N ] : Array Implementation INFO = SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 3 2 1 0 TOP = -1 37

  38. STACK [N ] : Array Implementation INFO = SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 55 TOP = 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 3 44 33 2 22 1 0 11 38

  39. STACK [N ] : Array Implementation INFO = 55 SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 55 TOP = 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 3 44 33 2 22 1 0 11 39

  40. STACK [N ] : Array Implementation INFO = 55 SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 3 44 TOP = 3 33 2 22 1 0 11 40

  41. STACK [N ] : Array Implementation INFO = 55 SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 TOP = 3 3 44 33 2 22 1 0 11 41

  42. STACK [N ] : Array Implementation INFO = 44 SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 TOP = 3 3 33 2 22 1 0 11 42

  43. STACK [N ] : Array Implementation INFO = 44 SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 3 33 2 TOP = 2 22 1 0 11 43

  44. STACK [N ] : Array Implementation INFO = 44 SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 3 33 2 TOP = 2 22 1 0 11 44

  45. STACK [N ] : Array Implementation INFO = 33 SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 3 2 TOP = 2 22 1 0 11 45

  46. STACK [N ] : Array Implementation INFO = 33 SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 3 2 TOP = 1 22 1 0 11 46

  47. STACK [N ] : Array Implementation INFO = 33 SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 3 2 TOP = 1 22 1 0 11 47

  48. STACK [N ] : Array Implementation INFO = 22 SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 3 2 TOP = 1 1 0 11 48

  49. STACK [N ] : Array Implementation INFO = 22 SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 3 2 1 0 TOP = 1 11 49

  50. STACK [N ] : Array Implementation INFO = 22 SIZE = 5 EMPTY Algorithm : POP ( ) Input : Accepts SIZE of the STACK Output: Return value at the TOP of the STACK Size -1 4 Steps: 1. [CASE 1: STACK is Empty] If TOP = = -1 Print( Stack is EMPTY ) Return Else 2. [CASE 2 -3: Stack is Full or Half Full] INFO = STACK [ TOP ] TOP = TOP - 1 3 2 1 0 TOP = 1 11 50

Related


No related presentations.

More Related Content