review of stacks and queues
Skip this Video
Download Presentation
Review of Stacks and Queues

Loading in 2 Seconds...

play fullscreen
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!
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