Stacks Chapter 3 Objectives Upon completion you will be able to Explain the design, use, and operation of a stack Implement a stack using a linked list structure Understand the operation of the stack ADT Write application programs using the stack ADT Discuss reversing data, parsing, postponing and backtracking Data Structures: A Pseudocode Approach with C

Introduction A stack is a Last In, First Out (LIFO) data structure in which all insertions and deletion are restricted to one end called a top When data are inserted into a stack and then they are removed, their order would be reversed Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

3-1 Basic Stack Operations The stack concept is introduced and three basic stack operations are discussed. Push Pop Stack Top Data Structures: A Pseudocode Approach with C

3-1 Basic Stack Operations There are 3 basic stack operations 1. push: adds an item at the top of the stack after the push, the new item becomes the top the stack is in an overflow state if there is no room for the new item Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Basic Stack Operations (2) 2. Pop when a stack is popped, the item at the top of the stack is removed and return it to the user as the top item has been removed, the next older item in the stack becomes the top when the last item in the stack is deleted, it must be set to its empty state if pop is called when the stack is empty, then it is in an underflow state Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Basic Stack Operations (3) 3. Stack Top copies the item at the top of the stack it returns the data in the top element to the user but does not delete it stack top can also result in underflow if the stack is empty Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

An Example Figure 3-5 with an empty stack push green into stack push blue into stack pop push red into stack stack top =? Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

3-2 Stack Linked List Implementation In this section we present a linked-list design for a stack. After developing the data structures, we write pseudocode algorithms for the stack ADT. Data Structure Algorithms Data Structures: A Pseudocode Approach with C

Stack-linked-list Implementation (2) There are several data structures that could be used to implement a stack, e.g. array or linked list In this section, we implement it as a linked list To implement the linked-list stack, we need two different structures a head node a data node Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Stack Head and Stack Data Node stack head requires at least 2 attributes a count of the number of elements in the stack a top pointer other stack attributes can be placed in a stack head such as the time the stack was created stack data node also requires at least 2 attributes data pointer to the next node Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Stack Algorithms 8 operations are defined to solve any basic stack problem create stack - empty stack push stack - full stack pop stack - stack count stack top - destroy stack there may be additional stack operations Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

3-3 C Language Implementations This section presents a simple non-ADT implementation of a stack. We develop a simple program that inserts random characters into the stack and then prints them. Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

(Continued) Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

3-4 Stack ADT We begin the discussion of the stack ADT with a discussion of the stack structure and its application interface. We then develop the required functions. Data Structure ADT Implemenation Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

3-5 Stack Applications Three basic application problems-parsing, postponement, and backtracking-are discussed and sample programs developed. In addition, several other stack applications are presented, including the classic Eight Queens problem. Reversing Data Converting Decimal to Binary Parsing Postponement Backtracking Data Structures: A Pseudocode Approach with C

Reversing Data given a set of data, the first and last elements are exchanged with all of the positions between the first and last being relatively exchanged also for example: {1, 2, 3, 4} becomes {4, 3, 2, 1} we examine 2 different reversing applications: reveres a list convert decimal to binary Data Structures: A Pseudocode Approach with C

Algorithm Reverse a number series Algorithm reverseNumber This program reverses a list of integers read from the keyboard by pushing them into a stack and retrieving them one by one 1  stack = createStack 2  print (Enter a number) 3  read (number) Data Structures: A Pseudocode Approach with C

Algorithm Reverse a number series (2) Fill stack 4  loop ( not end of data AND stack not full) 1 pushStack (number ) 2 prompt (Enter next number: <EOF> to stop) 3 read( number ) Print numbers in reverse 5  loop (not emptyStack (stack) 1 popStack (stack, dataOut) 2 print (dataOut) 6  stack = destroyStack (stack) end reverseNumber Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

(continued) Data Structures: A Pseudocode Approach with C

Convert Decimal to Binary 1 read (number) 2 loop (number > 0) 1 digit = number modulo 2 2 print (digit) 3 number = number / 2 Data Structures: A Pseudocode Approach with C

Algorithm Convert decimal to binary algorithm decimalToBinary This algorithm reads an integer from the keyboard and print its binary equivalent. It uses a stack to reverse the order of 0’s and 1’s produces. 1 stack = createStack 2  prompt (Enter a decimal to convert to binary) 3  read (number) 4  loop (number > 0) 1 digit = number modulo 2 2 pushOK = push (stack,digit) 3 if (pushOK false) 1 print (Stack overflow creating digit) 2 quit algorithm 4 number = number/2 Data Structures: A Pseudocode Approach with C

Algorithm Convert decimal to binary (2) Binary number create in stack. Now print it. 5  loop (not emptyStack(stack)) 1 popStack (stack,digit) 2 print(digit) Binary number create. Destroy stack and return 6 destroy(stack) end decimalToBinary Data Structures: A Pseudocode Approach with C

Parsing any logic that breaks data into independent pieces for further processing for example, to translate a source program to machine language, a compiler must parse the program into individual parts such as keywords, names, and tokens one common programming problem, unmatched parentheses in an algebraic expression Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Postponement When we used a stack to reverse a list, the entire list was read before we began outputting the results Often the logic of an application requires that the usage of data be deferred until some later point A stack can be useful when the application requires that data’s use be postponed for a while two stack postponement applications: infix to postfix translation postfix expression evaluation Data Structures: A Pseudocode Approach with C

Infix To Postfix Transformation An arithmetic expression can be represented in 3 different formats infix: the operator comes between the 2 operands postfix: the operator comes after the 2 operands prefix: the operator comes before the 2 operands Infix: a + b Postfix: a b + Prefix: + a b Data Structures: A Pseudocode Approach with C

Transformation Using Stack Can we use stack to handle infix to postfix transformation? What happen if we push operators into a stack and after the whole infix expression has been read, we pop the stack? A * B = A B * Data Structures: A Pseudocode Approach with C

Transformation Using Stack (2) Priority 2: * / Priority 1: + - Priority 0: ( Data Structures: A Pseudocode Approach with C

Example 3 Given the expression: A + B * C Using the following rules copy operand A to output expression push operator + into stack copy operand B t output expression push operator * into stack (*’s priority is higher than +’s) copy operand C to output expression pop operator * and copy to output expression pop operator + and copy to output expression A result is: A B C * + Data Structures: A Pseudocode Approach with C

Example 4 Given the expression: A + B * C – D / E The result is Data Structures: A Pseudocode Approach with C

Figure 3-12, Part I: Infix transformations Data Structures: A Pseudocode Approach with C

รูปที่ 3-12, ส่วนที่ 2 : การแปลงนิพจน์ infix ให้เป็น postfix Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Example 5 Given the expression: A * B – (C + D) + E Data Structures: A Pseudocode Approach with C

Table 3-1 Example: convert infix to postfix Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Evaluating Postfix Expressions Given the expression A B C + * assuming that A = 2 B= 4 C = 6 Data Structures: A Pseudocode Approach with C

Figure 3-13: Evaluation of postfix expression Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Backtracking found in applications such as computer gaming, decision analysis, and expert systems in this section, we examine a backtracking application called goal seeking Data Structures: A Pseudocode Approach with C

Goal Seeking one way to portray the problem is to layout the steps in the form of a graph that contains several alternate paths in it only one of the pats in the figure leads us to a desired goal while we can immediately see the correct path when we look at the figure, the computer needs an algorithm to determine the correct path Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Goal Seeking (2) what do we put into the stack? if all we wanted to do was to located the node that contains the goal, we would just put the branch point nodes into the stack as we want to print out the path that leads us to our goal, we must put the nodes in the valid path into the stack Data Structures: A Pseudocode Approach with C

Figure 3-15: Backtracking stack operation Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

(continued) Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

3-6 How Recursion Works This section discusses the concept of the stack frame and the use of stacks in writing recursive software Enqueue Dequeue Queue Front Queue Rear Queue Example Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

Data Structures: A Pseudocode Approach with C

3-7 Array Implementation of Stacks if we know a stack’s maximum size, an array implementation of a stack is more efficient than linked list implementation with array implementation, the base is index 0 (in C) the top moves up and down as data are inserted or deleted to push an element, we add one to top and use it as the array index to pop, we copy at index location top and then subtract one from top Data Structures: A Pseudocode Approach with C

Figure 3-20: Stack array implementation Data Structures: A Pseudocode Approach with C

Algorithm Stack array definition Stack Definitions for Array Implementation stack stackAry <pointer to array of dataType> count <integer> stackMax <integer> top <index> end stack Data Structures: A Pseudocode Approach with C

Algorithm Create stack array algorithm createStack (stackElem <integer>) Allocates memory for a stack head node from dynamic memory and returns its address to the caller. Pre stackElem contains size of stack Post Head node and array allocated or error returned Return pointer to head node or null pointer if no memory 1 if (memory not available) 1 stackPtr = null 2 else 1 allocate (stackPtr) Data Structures: A Pseudocode Approach with C

Algorithm Create stack array (2) Head allocated. Now initialize and allocate stack array. 2 stackPtr -> count = 0 3 stackPtr -> top = -1 4 stackPtr -> stackMax = stackElem 5 if (memory not available) 1 recycle (stackPtr) 2 stackPtr = null 6 else Allocate memory for stack array 1 allocate (stackPtr -> stackAry) 3 return stackPtr end createStack Data Structures: A Pseudocode Approach with C

Algorithm Push stack array algorithm pushStack (val stack <head pointer>, val data <dataType>) Insert (push) one item into the stack. Pre stack is a pointer to the stack head structure data contains data to be pushed into stack Post data have been pushed in stack Return true if successful; false if memory overflow Data Structures: A Pseudocode Approach with C

Algorithm Push stack array (2) 1 if (stack -> count is at maximum) 1 success = false 2 else 1 stack -> count = stack -> count + 1 2 stack -> top = stack -> top + 1 3 stack -> stackAry[stack -> top] = data 4 success = true 3 return success end pushStack Data Structures: A Pseudocode Approach with C

Algorithm Pop stack algorithm popStack (val stack <head point>, ref dataOut <dataType>) This algorithm pops the item on the top of the stack and returns it to the user. Pre stack is a pointer to the stack head structure dataOut is a reference variable to receive the data Post Data have been returned to calling algorithm Return true if successful; false if underflow Data Structures: A Pseudocode Approach with C

Algorithm 3-19 Pop stack (2) 1 if (stack empty) 1 success = false 2 else 1 dataOut = stack -> stackAry [stack -> top] 2 stack -> top = stack -> top – 1 3 stack -> count = stack -> count – 1 4 success = true 3 return success end popStack Data Structures: A Pseudocode Approach with C

Algorithm Stack top algorithm stackTop (val stack <head pointer>, ref dataOut <dataType>) This algorithm retrieves the data from the top of the stack without changing the stack. Pre stack is a pointer to the stack head structure Post data have been returned to calling algorithm Return true if data returned, false if underflow Data Structures: A Pseudocode Approach with C

Algorithm Stack top (2) 1 if (stack -> count zero) 1 success = false 2 else 1 dataOut = stack -> stackAry [stack -> top].data 2 success = true 3 return success end stackTop Data Structures: A Pseudocode Approach with C

Algorithm Empty stack algorithm emptyStack (val stack <head pointer>) Determines if stack is empty and return a Boolean. Pre stack is a pointer to the stack head structure Post returns stack status Return Boolean, true: stack empty, false: stack contains data 1 if (stack -> count > 0) 1 result = false 2 else 1 result = ture 3 return result end emptyStack Data Structures: A Pseudocode Approach with C

Algorithm Full stack algorithm fullStack (val stack <head pointer>) Determines if stack is full and return a Boolean. Pre stack is a pointer to the stack head structure Post returns stack status Return Boolean, true: stack full, false: memory available 1 if (stack ->count < MAX_STACK) 1 result = false 2 else 1 result = true 3 return result end fullStack Data Structures: A Pseudocode Approach with C

Algorithm Stack count algorithm stackCount (val stack <head pointer>) Return the number of elements currently in stack. Pre stack is a pointer to the stack head structure Post returns stack count Return integer count of number of elements in stack 1 return (stack->count) end stackCount Data Structures: A Pseudocode Approach with C

Algorithm 3-24 Destroy stack algorithm destroyStack (val stack <typeStack>) This algorithm releases all nodes back to the dynamic memory. Pre stack is a pointer to the stack head structure Post head structure and array recycled Return null pointer 1 if (stack not empty) 1 recycle (stack->stackAry) 2 recycle (stack) 2 return null pointer end destroyStack Data Structures: A Pseudocode Approach with C