stacks and queues
Download
Skip this Video
Download Presentation
Stacks and Queues

Loading in 2 Seconds...

play fullscreen
1 / 85

Stacks and Queues - PowerPoint PPT Presentation


  • 105 Views
  • Uploaded on

Stacks and Queues. Andy Wang Data Structures, Algorithms, and Generic Programming. Abstract Data Type. A collection of data A set of operations on the data or subsets of the data A set of axioms , or rules of behavior governing the interaction of operators

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Stacks and Queues' - akamu


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
stacks and queues

Stacks and Queues

Andy Wang

Data Structures, Algorithms, and Generic Programming

abstract data type
Abstract Data Type
  • A collection of data
  • A set of operations on the data or subsets of the data
  • A set of axioms, or rules of behavior governing the interaction of operators
  • Examples: stack, queue, list, vector, deque, priority queue, table (map), associative array, set, graph, digraph
stack adt
Stack ADT
  • Collections:
    • Elements of some proper type T
  • Operations:
    • void push(T t)
    • void pop()
    • T top()
    • bool empty()
    • unsigned int size()
    • constructor and destructor
stack adt 2
Stack ADT (2)
  • Axioms (for any stack S)
    • S.size, S.empty(), and S.push(t) are always defined
    • S.pop() and S.top() are defined iff S.empty() is false
    • S.empty(), S.size(), S.top() do not change S
    • S.empty() is true iff S.size() == 0
    • S.push(t) followed by S.pop() leaves S unchanged
stack adt 3
Stack ADT (3)
  • Axioms (for any stack S)
    • After S.push(t), S.top() returns t
    • S.push(t) increases S.size() by 1
    • S.pop() decreases S.size() by 1
stack model lifo
Stack Model—LIFO
  • Empty stack S
    • S.empty() is true
    • S.top() not defined
    • S.size() == 0

food chain stack

stack model lifo1
Stack Model—LIFO
  • S.push(“mosquito”)
    • S.empty() is false
    • S.top() == “mosquito”
    • S.size() == 1

food chain stack

stack model lifo2
Stack Model—LIFO
  • S.push(“fish”)
    • S.empty() is false
    • S.top() == “fish”
    • S.size() == 2

food chain stack

stack model lifo3
Stack Model—LIFO
  • S.push(“raccoon”)
    • S.empty() is false
    • S.top() == “raccoon”
    • S.size() == 3

food chain stack

stack model lifo4
Stack Model—LIFO
  • S.pop()
    • S.empty() is false
    • S.top() == “fish”
    • S.size() == 2

food chain stack

derivable behaviors theorems
Derivable Behaviors (Theorems)
  • If (S.size() == n) is followed by k push operations, then S.size() == n + k
  • If (S.size() == n) is followed by k pop operations, then S.size == n – k (k <= n)
  • The last element of S pushed onto S is the top of S
  • S.pop() removes the last element of S pushed onto S
uses of adt stack
Uses of ADT Stack
  • Depth first search / backtracking
  • Evaluating postfix expressions
  • Converting infix to postfix
  • Function calls (runtime stack)
  • Recursion
queue adt
Queue ADT
  • Collection
    • Elements of some proper type T
  • Operations
    • void push(T t)
    • void pop()
    • T front()
    • bool empty()
    • unsigned int size()
    • Constructors and destructors
queue adt1
Queue ADT
  • Axioms (for any Queue Q)
    • Q.size(), Q.empty(), Q.push(t) are always defined
    • Q.pop() and Q.front() are defined iff Q.empty() is false
    • Q.empty(), Q.size(), Q.front() do not change Q
    • Q.empty() is true iff Q.size() == 0
    • Suppose Q.size() == n, and the next element pushed onto Q is t; then, after n elements have been popped from Q, t = Q.front()
queue adt2
Queue ADT
  • Axioms (for any Queue Q)
    • Q.push(t) increases Q.size() by 1
    • Q.pop() decreases Q.size() by 1
    • If t = Q.front() then Q.pop() removes t from Q
queue model fifo
Queue Model—FIFO
  • Empty Q

animal parade queue

queue model fifo1

front

back

Queue Model—FIFO
  • Q.Push(“ant”)

animal parade queue

queue model fifo2

front

back

Queue Model—FIFO
  • Q.Push(“bee”)

animal parade queue

queue model fifo3

front

back

Queue Model—FIFO
  • Q.Push(“cat”)

animal parade queue

queue model fifo4

front

back

Queue Model—FIFO
  • Q.Push(“dog”)

animal parade queue

queue model fifo5

front

back

Queue Model—FIFO
  • Q.Pop()

animal parade queue

queue model fifo6

front

back

Queue Model—FIFO
  • Q.Pop()

animal parade queue

queue model fifo7

front

back

Queue Model—FIFO
  • Q.Push(“eel”)
  • Q.Pop()
  • Q.Pop()

animal parade queue

derivable behaviors theorems1
Derivable Behaviors (Theorems)
  • If (Q.size() == n) is followed by k push operations, then Q.size() == n + k
  • If (Q.size() == n) is followed by k pop operations, then Q.size() == n – k (k <= n)
  • The first element pushed onto Q is the the front of Q
  • Q.pop() removes the front element of Q
uses of adt queue
Uses of ADT Queue
  • Buffers
  • Breadth first search
  • Simulations
depth first search backtracking
Problem

Discover a path from start to goal

Solution

Go deep

If there is an unvisited neighbor, go there

Backtrack

Retreat along the path to find an unvisited neighbor

Outcome

If there is a path from start to goal, DFS finds one such path

Depth First Search—Backtracking

1

start

2

3

4

5

6

7

8

9

10

11

12

goal

depth first search backtracking 2
Depth First Search—Backtracking (2)
  • Stack

1

start

2

3

4

5

6

7

8

9

10

11

12

goal

Push

depth first search backtracking 3
Depth First Search—Backtracking (3)
  • Stack

1

start

2

3

4

5

6

7

8

9

10

11

12

Push

goal

Push

depth first search backtracking 4
Depth First Search—Backtracking (4)
  • Stack

1

start

2

3

4

5

6

7

8

Push

9

10

11

12

Push

goal

Push

depth first search backtracking 5
Depth First Search—Backtracking (5)
  • Stack

1

start

2

3

4

Push

5

6

7

8

Push

9

10

11

12

Push

goal

Push

depth first search backtracking 6
Depth First Search—Backtracking (6)
  • Stack

1

start

Push

2

3

4

Push

5

6

7

8

Push

9

10

11

12

Push

goal

Push

depth first search backtracking 7
Depth First Search—Backtracking (7)
  • Stack

1

start

Pop

2

3

4

Push

5

6

7

8

Push

9

10

11

12

Push

goal

Push

depth first search backtracking 8
Depth First Search—Backtracking (8)
  • Stack

1

start

2

3

4

Pop

5

6

7

8

Push

9

10

11

12

Push

goal

Push

depth first search backtracking 9
Depth First Search—Backtracking (9)
  • Stack

1

start

2

3

4

5

6

7

8

Pop

9

10

11

12

Push

goal

Push

depth first search backtracking 10
Depth First Search—Backtracking (10)
  • Stack

1

start

2

3

4

5

6

7

8

9

10

11

12

Pop

goal

Push

depth first search backtracking 11
Depth First Search—Backtracking (11)
  • Stack

1

start

2

3

4

5

6

7

8

9

10

11

12

Push

goal

Push

depth first search backtracking 12
Depth First Search—Backtracking (12)
  • Stack

1

start

2

3

4

5

6

7

8

Push

9

10

11

12

Push

goal

Push

depth first search backtracking 13
Depth First Search—Backtracking (13)
  • Stack

1

start

2

3

4

Push

5

6

7

8

Push

9

10

11

12

Push

goal

Push

dfs implementation
DFS Implementation

DFS {

stack<location> S;

// mark the start location as visited

S.push(start);

while (S is not empty) {

t = S.top();

if (t == goal) Success(S);

if (// t has unvisited neighbors) {

// choose an unvisited neighbor

// mark n visited;

S.push(n);

} else {

BackTrack(S);

}

}

Failure(S);

}

dfs implementation 2
DFS Implementation (2)

BackTrack(S) {

while (!S.empty() && S.top() has no unvisited neighbors) {

S.pop();

}

}

Success(S) {

// print success

while (!S.empty()) {

output(S.top());

S.pop();

}

}

Failure(S) {

// print failure

while (!S.empty()) {

S.pop();

}

}

breadth first search
Breadth First Search
  • Problem
    • Find a shortest path from start to goal

1

start

2

3

4

5

6

7

8

9

10

11

12

goal

breadth first search 2
Breadth First Search (2)
  • Queue

Push

1

start

2

3

4

5

6

7

8

9

10

11

12

goal

breadth first search 3
Breadth First Search (3)
  • Queue

Pop

1

start

2

3

4

5

6

7

8

9

10

11

12

goal

breadth first search 4
Breadth First Search (4)
  • Queue

Push

Push

Push

1

start

2

3

4

5

6

7

8

9

10

11

12

goal

breadth first search 5
Breadth First Search (5)
  • Queue

Pop

1

start

2

3

4

5

6

7

8

9

10

11

12

goal

breadth first search 6
Breadth First Search (6)
  • Queue

Push

Push

1

start

2

3

4

5

6

7

8

9

10

11

12

goal

breadth first search 7
Breadth First Search (7)
  • Queue

Pop

1

start

2

3

4

5

6

7

8

9

10

11

12

goal

breadth first search 8
Breadth First Search (8)
  • Queue

Push

Push

1

start

2

3

4

5

6

7

8

9

10

11

12

goal

breadth first search 9
Breadth First Search (9)
  • Queue

Pop

1

start

2

3

4

5

6

7

8

9

10

11

12

goal

breadth first search 10
Breadth First Search (10)
  • Queue

Pop

1

start

2

3

4

5

6

7

8

9

10

11

12

goal

breadth first search 11
Breadth First Search (11)
  • Queue

Pop

1

start

2

3

4

5

6

7

8

9

10

11

12

goal

breadth first search 12
Breadth First Search (12)
  • Queue

Push

1

start

2

3

4

5

6

7

8

9

10

11

12

goal

breadth first search 13
Breadth First Search (13)
  • Queue

Pop

1

start

2

3

4

5

6

7

8

9

10

11

12

goal

breadth first search 14
Breadth First Search (14)
  • Queue

Push

1

start

2

3

4

5

6

7

8

9

10

11

12

goal

bfs implementation
BFS Implementation

BFS {

queue<location> Q;

// mark the start location as visited

Q.push(start);

while (Q is not empty) {

t = Q.front();

for (// each unvisited neighbor n) {

Q.push(n);

if (n == goal) Success(S);

}

Q.pop();

}

Failure(Q);

}

evaluating postfix expressions
Evaluating Postfix Expressions
  • Postfix expressions: operands precede operator
  • Tokens: atomics of expressions, either operator or operand
  • Example:
    • z = 25 + x*(y – 5)
    • Tokens: z, =, 25, +, x, *, (, y, -, 5, )
evaluating postfix expressions 2
Evaluating Postfix Expressions (2)
  • Evaluation algorithm:
    • Use stack of tokens
    • Repeat
      • If operand, push onto stack
      • If operator
        • pop operands off stack
        • evaluate operator on operands
        • push result onto stack
      • Until expression is read
      • Return top of stack
evaluating postfix expressions 3
Evaluating Postfix Expressions (3)
  • Most CPUs have hardware support for this algorithm
  • Translation from infix to postfix also uses a stack (software)
evaluating postfix expressions 4
Evaluating Postfix Expressions (4)
  • Original expression: 1 + (2 + 3) * 4 + 5
  • Evaluate: 1 2 3 + 4 * + 5 +
evaluating postfix expressions 5
Evaluating Postfix Expressions (5)
  • Input: 1 2 3 + 4 * + 5 +
  • Push(1)
evaluating postfix expressions 6
Evaluating Postfix Expressions (6)
  • Input: 2 3 + 4 * + 5 +
  • Push(2)
evaluating postfix expressions 7
Evaluating Postfix Expressions (7)
  • Input: 3 + 4 * + 5 +
  • Push(3)
evaluating postfix expressions 8
Evaluating Postfix Expressions (8)
  • Input: + 4 * + 5 +
  • Pop() == 3
  • Pop() == 2
evaluating postfix expressions 9
Evaluating Postfix Expressions (9)
  • Input: + 4 * + 5 +
  • Push(2 + 3)
evaluating postfix expressions 11
Evaluating Postfix Expressions (11)
  • Input: * + 5 +
  • Pop() == 4
  • Pop() == 5
evaluating postfix expressions 12
Evaluating Postfix Expressions (12)
  • Input: * + 5 +
  • Push(5 * 4)
evaluating postfix expressions 13
Evaluating Postfix Expressions (13)
  • Input: + 5 +
  • Pop() == 20
  • Pop() == 1
evaluating postfix expressions 14
Evaluating Postfix Expressions (14)
  • Input: + 5 +
  • Push(1 + 20)
evaluating postfix expressions 16
Evaluating Postfix Expressions (16)
  • Input: +
  • Pop() == 21
  • Pop() == 5
postfix evaluation implementation
Postfix Evaluation Implementation

Evaluate(postfix expression) {

// use stack of tokens;

while(// expression is not empty) {

t = next token;

if (t is operand) {

// push onto stack

} else {

// pop operands for t off stack

// evaluate t on these operands

// push result onto stack

}

}

// return top of stack

}

runtime stack
Runtime Stack
  • Runtime environment
    • Static
      • Executable code
      • Global variables
    • Stack
      • Push for each function call
      • Pop for each function return
    • Heap
      • Dynamic new and delete

heap

stack

static

program memory

recursion
Recursion
  • Order 1: function calls itself
  • Order 2: f() calls g(), and g() calls f()
  • Facilitated by stack
adaptor class
Adaptor Class
  • Adapts the public interface of another class
  • Adaptee: the class being used
  • Adaptor: the new class being defined
  • Uses protected object of the adaptee type
  • Uses the adaptee’s methods to define adaptor methods
  • Stack and Queue implemented via adaptor classes
stack adaptor requirements
Stack Adaptor Requirements
  • Stack
    • PushBack()
    • PopBack()
    • Back()
    • Empty()
    • Size()
  • Can use TDeque, TList, TVector
queue adaptor requirements
Queue Adaptor Requirements
  • Queue
    • PushBack()
    • PopFront()
    • Front()
    • Empty()
    • Size()
  • Can use TDeque, TList
class cstack
Class CStack

template <typename T, class Container>

class CStack {

protected:

Container c;

public:

typedef T value_type;

void Push(const value_type& x) { c.PushBack(x); }

void Pop() { c.PopBack(); }

value_type Top() const { return c.Back(); }

int Empty() const { return c.Empty(); }

unsigned int Size() const { return c.Size(); }

void Clear() { c.Clear(); }

void Display(ostream& os, char ofc) const;

};

class cstack 2
Class CStack (2)

template <typename T, class Container>

void CStack<T, Container>::Display(std::ostream& os, char ofc) const {

typename Container::Iterator I;

if (ofc == ‘\0’) {

for (I = c.Begin(); I != c.End(); ++I) {

os << *I;

}

} else {

for (I = c.Begin(); I != c.End(); ++I) {

os << *I << ofc;

}

}

}

template <typename T, class Container>

std::ostream& operator<<(std::ostream& os, const CStack<T, Container>& s) {

s.Display(os);

return os;

}

declarations
Declarations
  • CStack<float, TList<float> > floatStack;
  • CStack<int, TDeque<int> > intStack;
class cqueue
Class CQueue

template <typename T, class Container>

class CQueue {

protected:

Container c;

public:

typedef T value_type;

void Push(const value_type& x) { c.PushBack(x); }

void Pop() { c.PopFront(); }

value_type Front() const { return c.Front(); }

int Empty() const { return c.Empty(); }

unsigned int Size() const { return c.Size(); }

void Clear() { c.Clear(); }

void Display(ostream& os, char ofc) const;

};

class cqueue 2
Class CQueue (2)

template <typename T, class Container>

void CQueue<T, Container>::Display(std::ostream& os, char ofc) const {

typename Container::Iterator I;

if (ofc == ‘\0’) {

for (I = c.Begin(); I != c.End(); ++I) {

os << *I;

}

} else {

for (I = c.Begin(); I != c.End(); ++I) {

os << *I << ofc;

}

}

}

template <typename T, class Container>

std::ostream& operator<<(std::ostream& os, const CQueue<T, Container>& s) {

s.Display(os);

return os;

}

example usage
Example Usage
  • Functionality Testing
    • fcstack.cpp
    • fcqueue.cpp
  • Performance Testing
    • qrace.cpp
    • srace.cpp
    • dragstrp.h
    • timer.h
    • datetime.h
    • xran.h
ad