1 / 21

Implementing a Queue as a Linked Structure

Implementing a Queue as a Linked Structure. CS 308 – Data Structures. Implementing queues using arrays. Simple implementation The size of the queue must be determined when a stack object is declared Space is wasted if we use less elements

keena
Download Presentation

Implementing a Queue as a Linked Structure

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Implementing a Queue as a Linked Structure CS 308 – Data Structures

  2. Implementing queues using arrays • Simple implementation • The size of the queue must be determined when a stack object is declared • Space is wasted if we use less elements • We cannot "enqueue" more elements than the array can hold

  3. Implementing queues using linked lists • Allocate memory for each new element dynamically • Link the queue elements together • Use two pointers, qFront and qRear, to mark the front and rear of the queue

  4. Queue class specification // forward declaration of NodeType (like function prototype) template<class ItemType> struct NodeType; template<class ItemType> class QueueType { public: QueueType(); ~QueueType(); void MakeEmpty(); bool IsEmpty() const; bool IsFull() const; void Enqueue(ItemType); void Dequeue(ItemType&); private: NodeType<ItemType>* qFront; NodeType<ItemType>* qRear; };

  5. Enqueuing (non-empty queue)

  6. Enqueuing (empty queue) • We need to make qFront point to the new node also qFront = NULL New Node qRear = NULL newNode

  7. Function Enqueue template <class ItemType> void QueueType<ItemType>::Enqueue(ItemType newItem) { NodeType<ItemType>* newNode; newNode = new NodeType<ItemType>; newNode->info = newItem; newNode->next = NULL; if(qRear == NULL) qFront = newNode; else qRear->next = newNode; qRear = newNode; }

  8. Dequeueing (the queue contains more than one element)

  9. Dequeueing (the queue contains only one element) • We need to reset qRear to NULL also qFront After dequeue: qFront = NULL qRear = NULL Node qRear

  10. Function Dequeue template <class ItemType> void QueueType<ItemType>::Dequeue(ItemType& item) { NodeType<ItemType>* tempPtr; tempPtr = qFront; item = qFront->info; qFront = qFront->next; if(qFront == NULL) qRear = NULL; delete tempPtr; }

  11. qRear, qFront revisited • The relative positions of qFront and qRear are important!

  12. Other Queue functions template<class ItemType> QueueType<ItemType>::QueueType() { qFront = NULL; qRear = NULL; } template<class ItemType> void QueueType<ItemType>::MakeEmpty() { NodeType<ItemType>* tempPtr; while(qFront != NULL) { tempPtr = qFront; qFront = qFront->next; delete tempPtr; } qRear=NULL; }

  13. Other Queue functions (cont.) template<class ItemType> bool QueueType<ItemType>::IsEmpty() const { return(qFront == NULL); } template<class ItemType> bool QueueType<ItemType>::IsFull() const { NodeType<ItemType>* ptr; ptr = new NodeType<ItemType>; if(ptr == NULL) return true; else { delete ptr; return false; } }

  14. Other Queue functions (cont.) template<class ItemType> QueueType<ItemType>::~QueueType() { MakeEmpty(); }

  15. A circular linked queue design

  16. Comparing queue implementations • Memory requirements • Array-based implementation • Assume a queue (size: 100) of strings (80 bytes each) • Assume indices take 2 bytes • Total memory: (80 bytes x 101 slots) + (2 bytes x 2 indexes) = 8084 bytes • Linked-list-based implementation • Assume pointers take 4 bytes • Total memory per node: 80 bytes + 4 bytes = 84 bytes

  17. Comparing queue implementations (cont.)

  18. Comparing queue implementations (cont.) • Memory requirements • Array-based implementation • Assume a queue (size: 100) of short integers (2 bytes each) • Assume indices take 2 bytes • Total memory: (2 bytes x 101 slots) + (2 bytes x 2 indexes) = 206 bytes • Linked-list-based implementation • Assume pointers take 4 bytes • Total memory per node: 2 bytes + 4 bytes = 6 bytes

  19. Comparing queue implementations (cont.)

  20. Comparing queue implementations

  21. Exercises • 5, 6

More Related