Ceng-112 Data Structures ITurgut Kalfaoglu 1 Chapter 3 Stacks

Ceng-112 Data Structures I Turgut Kalfaoglu 1

Chapter 3

Stacks


Figure 3-2

Linear Lists

Operations are;1. Insertion2. Deletion3. Retrieval4. Traversal (exception for restristed lists).


Figure 4-1

Stacks

A stack is a Last in First out (LIFO) data structure in which all insertions and deletions are restricted to one end called top.


Figure 4-2

Stack Basic Operations

Overflow?


Figure 4-3


Underflow?


Figure 4-4



Figure 4-5


Figure 4-6

Stack Data Structure


Figure 4-7

Stack Data Structure


Figure 4-8, Part I

Stack Operations


Figure 4-8, Part II

Stack Operations


Create Stack

algorithm createStackAllocates memory for a stack head node from dynamic memory and returns its

address to the caller.Pre NothingPost Head node allocated or error returnedReturn pointer to head node or null pointer if no memory1. if (memory available)

1. allocate (stackPtr)2. stackPtrcount = 03. stackPtrtop = null

2. else1. stackPtr = null

3. return stackPtrend createStack


Figure 4-9

Push Stack


Push Stackalgorithm pushStack(val stack <head pointer>,

val data <data type>)

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.

1. if (stack full)1. success = false

2. else1. allocate (newPtr)

2. newPtrdata= data

3. newPtrnext= stacktop

4. stacktop=newPtr

5. stackcount = stackcount+1

6. Success=true

3. return success

end pushStack


Figure 4-10

Pop Stack


Pop Stackalgorithm popStack(val stack <head pointer>,

val dataOut <data type>)

Pops the item on the top of the stack and returns it to the user.


dataOut is a reference variable to receive the data.

Post data have been returned to the calling algorithm.

1. if (stack empty)1. success = false

2. else1. dltPtr= stacktop

2. dataOut = stacktopdata

3. stacktop = stacktopnext

4. stackcount = stackcount – 1

5. recycle(dltPtr)

6. success=true

3. return success

end popStack


Destroy Stack

algorithm destroyStack(val stack <head pointer>)

This algorithm releases all nodes back to the dynamic memory.


Post stack empty and all nodes recycled

1. if (stack not empty)

1. loop1. temp = stacktop

2. stacktop = stacktoplink

3. recycled(temp)

2. recycled (stack)

3. return null pointer

end destroyStack


Stack Applications

We can be classified stack applications into four categories:

1. Reversing data.

2. Parsing data.

3. Postponing data usage.

4. Backtracking steps.


Stack ApplicationsReversing Data

1 2 3 4 5 5 4 3 2 1

12345Push Pop


Figure 4-11

Stack ApplicationsParsing Data

Breaks the data into independent pieces for further processing.

source program Compiler machine language


Stack ApplicationsParsing Data

3.Pop )2.Push (1.Push (

3.Pop )2.Pop )1.Push (


Stack ApplicationsPosponement

Arithmetic expression can be represent three different formats:

1. Prefix + a b

2. Infix a + b

3. Postfix a b +

Arithmetic precedence;

multiply and divide

before

add and subtract!



A + B * C

Place the paranthesis

( A + ( B * C))

Replace it in postfix format

(A(BC*)+)

Remove all paranthesis

ABC*+

Implementation by computer is too hard!


Figure 4-12, Part I


* and / operators have higher priority than the operator at the top of the stack.


Figure 4-12, Part II



Figure 4-13

Stack ApplicationsEvaluation of Postfix Expression


Excercise

• Change the following infix expression to postfix expression using the algoritmic method (a stack).

a+b*c-d

Solution: abc*+d-


• Infix String : a+b*c-d

• The first character scanned is 'a'. 'a' is added to the Postfix string. The next character scanned is '+'. It being an operator, it is pushed to the stack.

• Next character scanned is 'b' which will be placed in the Postfix string. Next character is '*' which is an operator. Now, the top element of the stack is '+' which has lower precedence than '*', so '*' will be pushed to the stack.

• The next character is 'c' which is placed in the Postfix string. Next character scanned is '-'. The topmost character in the stack is '*' which has a higher precedence than '-'. Thus '*' will be popped out from the stack and added to the Postfix string. Even now the stack is not empty. Now the topmost element of the stack is '+' which has equal priority to '-'. So pop the '+' from the stack and add it to the Postfix string. The '-' will be pushed to the stack.

• Next character is 'd' which is added to Postfix string. Now all characters have been scanned so we must pop the remaining elements from the stack and add it to the Postfix string. At this stage we have only a '-' in the stack. It is popped out and added to the Postfix string. So, after all characters are scanned, this is how the stack and Postfix string will be :

• End result :

• * Infix String : a+b*c-d

• * Postfix String : abc*+d-


Figure 4-14

Stack ApplicationsBackTracking


Figure 4-15


Figure 4-16

Stack ApplicationsBackTracking


Figure 4-17


Figure 4-20

Array Implementation of Stacks

stackstackAry <pointer to array of dataType>count <integer>stackMax <integer>top <index>

end stack


Hw-5

Write a program that accepts parentheses and brackets characters, one per line on standard input. Use a stack to determine whether pairs of characters are matching or not. Therefore complete the body of below function.

bool balanced(const char p[ ], size_t n) // Precondition: p[0]...p[n-1] contains n characters, each of which // is '(', ')', '{' or '}'. // Postcondition: The function returns true if the characters form a // sequence of correctly balanced parentheses with each '(' matching // a ')' and each '{' matching a '}'. Note that a sequence such as // ( { ) } is NOT balanced because when we draw lines to match the // parentheses to their partners, the lines cross each other. On the // other hand, ( { } ) amd { ( ) } are both balanced.

Load your HW-5 to FTP site until 13 Apr. 07 at 09:00 am.


Figure 4-21

Exercises

Projects – 23 page 211, 212


Figure 4-22

Exercises

Projects – 24 page 212

Documents

Ceng-112 Data Structures ITurgut Kalfaoglu 1 Chapter 3 Stacks