Review of stacks and queues
1 / 34

Review of Stacks and Queues - PowerPoint PPT Presentation

  • Uploaded on

Review of Stacks and Queues. Dr. Yingwu Zhu. How does a Stack Work?. Last-in-First-out (LIFO) data structure Adding an item Push operation Removing an item Pop operation Properties Ordered collection of items Be accessed at only the top. Building a Stack Class.

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

PowerPoint Slideshow about ' Review of Stacks and Queues' - kairos

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

How does a stack work
How does a Stack Work?

  • Last-in-First-out (LIFO) data structure

  • Adding an item

    • Push operation

  • Removing an item

    • Pop operation

  • Properties

    • Ordered collection of items

    • Be accessed at only the top

Building a stack class
Building a Stack Class

  • Design a stack class  stack.h (header file)

  • Implement the stack class  stack.cpp (implementation file)

Building a stack class1
Building a Stack Class

  • Need to determine the data structure to store data items (array or linked list?)

  • Need to determine the algorithms to perform operations on the data items

Building a stack class2
Building a Stack Class

  • What data items do we need?

    • An array/linked-list to hold stack elements

    • An integer/pointer to indicate the top of stack

  • What operations do we need?

    • Constructor: build an empty stack

    • Empty: check if a stack is empty

    • Push: add an element on the top

    • Top: return the top element

    • Pop: remove the top element

    • Display: show all the stack elements

A static array based stack p327
A Static Array-Based Stack (p327)

  • A static array to hold the stack elements, the position 0 as the bottom of the stack

  • Problem?  the stack capacity cannot be changed during run time (waste of space or insufficient room for more data items)

Dynamic array based stack
Dynamic Array-Based Stack

  • Advantage: allow users to specify the stack capacity in its declaration

  • But, we need to do more ! (Due to the dynamically-allocated memory)

    • Constructor: memory allocation and data member initialization

    • Destructor: reclaim the dynamically-allocated memory, avoid “memory leak”

    • Copy constructor: NO “shallow copy” (p339)

    • Assignment operator: assign one object to another, NO “shallow copy”

Example codes explanation p336
Example Codes Explanation (p336)

  • Figure7.6: const keyword

  • Destructor (p338-9, Figure 7.7)

    • Deallocate array allocated in constructor

    • Avoid memory leak problem

Example codes explanation
Example Codes Explanation

  • Copy constructor (p339)

    • Initialization

    • Passing value parameter

    • Return a function value

    • Creating a temporary storage value

  • Default copy constructor: member-by-member copy

  • Ensure deep copy

Example codes explanation1
Example Codes Explanation

  • Assignment operator (=)

    • The default assignment operator only member-by-member copy, causing “shallow copy” and “memory leak” (by old array)

    • Ensure deep copy

    • Check if it is self-assignment (Fig 7.9, p343)

      • If NO, then destroy the old array, allocate a new one

    • Never forget: return *this;

Let s do it
Let’s do it

typedef int DataType;

class Stack {


int myCapacity;

int myTop;

int* myArray;




Linked list based stack
Linked List-Based Stack

  • Advantage: grow and shrink as needed

  • Need only one data member:

    • Pointer myTop

    • Nodes allocated (but not part of stack class)

  • Node declaration inFig 7.11 (p. 353)

Implementing linked stack operations
Implementing Linked Stack Operations

  • Constructor: simply assign null pointer to myTop

  • Empty: check myTop == NULL (0)

  • Push: insertion at the head of the list

  • Top: return the data to which myTop points

View definitions in Fig. 7.12

Implementing linked stack operations1
Implementing Linked Stack Operations

  • Pop

    • Delete first node in the linked listptr = myTop;myTop = myTop->next;delete ptr;

  • Output

    • Traverse the listfor (ptr = myTop; ptr != 0; ptr = ptr->next) out << ptr->data << endl;

View definitions in Fig. 7.12

Stack h

typedef int DataType;

class Stack {public: Stack(); Stack(const Stack& org); void push(const DataType& v); void pop(); DataType top() const; ~Stack();

private: class Node { public: DataType data; Node* next; Node(DataType v, Node* p) : data(v), next(0) { }


typedef Node* NodePtr; NodePtr myTop;


Exercises implementation
Exercises: implementation

  • Close Textbook and Notes

  • Assignment Operator?

  • Destructor?

Implementing linked stack operations2
Implementing Linked Stack Operations

  • Destructor (p. 361)

    • Traverse list to deallocate nodes

    • “Never burn bridges before crossing them”

  • Copy constructor (p. 360)

    • Traverse linked list, copying each into new node

    • Deep copy

    • Watch for the empty object to be copied

Implementing linked stack operations3
Implementing Linked Stack Operations

  • Assignment operator (=), p.361

    • Rule out self-assignment

    • Destroy the old list, this->~Stack(); code reuse

    • Similar to copy constructor

Application of stack function calls
Application of Stack – Function Calls

Consider events when a function begins execution

  • Activation Record (AR) created: store the current environment for the function

  • Contents

Run time stack
Run-time Stack

  • Functions may call other functions

    • Interrupt their own execution

  • Must store the ARs to be recovered

    • System reset when the first function resumes execution

  • LIFO data structure

  • Run-time stack is used (Example in p.367)

Use of run time stack
Use of Run-time Stack

  • When a function is called, p.368

    • An AR pushed onto the run-time stack

    • Arguments copied into parameter space

    • Control transferred to starting address of body of the function being called

Use of run time stack1
Use of Run-time Stack

When a function terminates:

  • Run-time stack popped: get the address of instruction from AR

  • AR used to restore environment of the interrupted function

  • Interrupted function resumes execution

Introduction to queue
Introduction to Queue

  • A sequence of data items (FIFO)

    • Items can be removed only at the front

    • Items can be added only at the back

Introduction to queue1
Introduction to Queue

  • Basic operations

    • Construct a queue

    • Check if empty

    • Enqueue: add an element to back

    • Dequeue: remove an element from front

    • Front: return the first element

  • Skip array-based queues

  • Linked-list based queues

    • Data members?

    • Operations: above

Linked list based queue chp 8 3
Linked List-Based Queue (Chp. 8.3)

  • Advantage: grow and shrink as needed

  • Two data members: myFont, myBack

    • Why need myBack?

      • Avoid list traversal when enqueue()

Queue h

typedef int DataType;

class Queue {public: //constructor

//… member functions private: class Node { public: DataType data; Node* next; Node(DataType v, Node* p) : data(v), next(0) { }


typedef Node* NodePtr; NodePtr myFront, myback;


Linked queue p 418
Linked Queue, p.418

  • Constructor: initializesmyFront and myBack

  • Front, p420

    • return myFront->data

  • Dequeue, p421

    • Delete the first node (watch for empty queue)

  • Equeue, p420

    • Insert the node at the back

Linked queue
Linked Queue

  • Copy constructor: deep copy, p418

  • Assignment operator, p419

    • Watch for self-assignment

    • Deep copy

    • Avoid memory leak

  • Destructor: reclaim memory, p418

Circular linked queue p423
Circular Linked Queue, p423

  • Treat the linked list as circular

    • Last node points to the first node

    • Alternatively keep pointer to last node rather than first node, so only needs one data member!

Implementing circular list queue
Implementing Circular List Queue

  • Can you implement it?

Application of queues
Application of Queues

  • Disk Scheduling in OS

    • Disk requests from OS

    • Disk has a queue

    • Disk serves requests in queue by FIFO

    • In reality, it may be not always FIFO, priority?

Question time
Question Time

  • Any Question? 

Lecture reviews
Lecture Reviews

  • Difference between Stacks and Queues as ADT

  • Different implementations of Stacks and Queues

    • (Dynamic) Array or Linked List

    • Strengths and weakness

  • When we need copy constructor, destructor, assignment operator?

  • Undertand Stacks and Queues via their applications