Queues ArrayBased Queue Definition template class Key Type

Queues

Array-Based Queue Definition template <class Key. Type> class Queue { public: Queue(int Max. Size = Default. Size); ~Queue(); bool Is. Full(); bool Is. Empty(); void Add(const Key. Type& item); Key. Type* Delete(Key. Type& item); }; private: void Queue. Full(); void Queue. Empty(); int head, tail; Key. Type* queue; int Max. Size; // error handling

Queue Implementation : ﺟﺰﺀ ﺳﺎﺯﻧﺪﻩ template <class Key. Type> Queue<Key. Type>: : Queue(int Max. Queue. Size): Max. Size(Max. Queue. Size) { queue = new Key. Type[Max. Size]; head = tail = -1; }

Queue Implementation : ﺟﺰﺀ ﻣﺨﺮﺏ template <class Key. Type> Queue<Key. Type>: : ~Queue() { delete [] queue; head = tail = -1; }

Queue Implementation : Is. Empty() ﻭ Is. Full() template <class Key. Type> bool Queue<Key. Type>: : Is. Full() { return (tail == (Max. Size-1)); } template <class Key. Type> bool Queue<Key. Type>: : Is. Empty() { return (head == tail); }

Queue Implementation : Delete() ﻭ Add() template <class Key. Type> void Queue<Key. Type>: : Add (const Key. Type& item) { if (Is. Full()) {Queue. Full(); return; } else { tail = tail + 1; queue[tail] = item; } } template <class Key. Type> Key. Type* Queue<Key. Type>: : Delete(Key. Type& item) { } if (Is. Empty()) {Queue. Empty(); return 0}; else { head = head + 1; item = queue[head]; return &item; }

Queue Based Job Processing Front Rear Q[0] Q[1] Q[2] Q[3] Comments -1 -1 Initial -1 0 J 1 -1 1 J 2 -1 2 J 1 J 2 J 3 Job 3 Enters 0 2 J 3 0 3 J 2 J 3 Job 1 Leaves Job 4 Enters 1 3 J 3 Max. Size = 4 Job 1 Enters Job 2 Enters J 4 Job 2 Leaves

Queue Shift private void shift. Queue(Key. Type* queue, int & head, int & tail) { int difference = head – (-1); // head + 1 for (int j = head + 1; j < max. Size; j++) { queue[j-difference] = queue[j]; } head = -1; tail = tail – difference; }

Linked Queues Add(Hat) Add(Mat) Front Rear HAT Front MAT Add(Cat) Rear Delete() Rear CAT

Linked Queues Class Queue. Node{ friend class Queue; public: Queue. Node(int d, Queue. Node * l); private: int data; Queue. Node *link; };

Linked Queues class Queue { public: Queue(); ~Queue(); void Add(const int); int* Delete(int&); bool is. Empty(); private: Queue. Node* front; Queue. Node* rear; void Queue. Empty(); }

Linked Queues Queue: : Queue() { front = 0; rear = 0; } bool Queue: : is. Empty() { return (front == 0); } Front Rear 0 0

Linked Queues void Queue: : Add(const int y) { // Create a new node that contains data y // Has to go at end // Set current rear link to new node pointer // Set new rear pointer to new node pointer rear = rear->link = new Queue. Node(y, 0); } Front Rear HAT MAT CAT

Linked Queues int * Queue: : Delete(int & ret. Value) { // handle empty case if (is. Empty()) { Queue. Empty(); return 0; } Queue. Node* to. Delete = front; ret. Value = to. Delete->data; front = to. Delete->link; delete to. Delete; return &ret. Value; } Front to. Delete Front Rear return. Value HAT MAT CAT

Queue Destructor : ﺑﺎﻳﺪ ﺗﻤﺎﻡ ﻋﻨﺎﺻﺮ ﺻﻒ ﺭﺍ ﺣﺬﻑ کﻨﺪ ، ﺟﺰﺀ ﻣﺨﺮﺏ ﺻﻒ Temp Front HAT if (front) { Queue. Node* temp; while (front != rear) { temp = front; front = front -> link; delete temp; } delete front; front = rear = 0; } MAT Front Rear CAT 0 0

Radix Sort: Ones Digit Data: 459 254 472 534 649 239 432 654 477 Bin 0 Bin 1 Bin 2 472 432 Bin 3 Bin 4 254 534 654 Bin 5 Bin 6 Bin 7 477 Bin 8 Bin 9 459 649 239 After Call: 472 432 254 534 654 477 459 649 239

Radix Sort: Tens Digit Data: 472 432 254 534 654 477 459 649 239 Bin 0 Bin 1 Bin 2 Bin 3 432 534 239 Bin 4 649 Bin 5 254 654 459 Bin 6 Bin 7 472 477 Bin 8 Bin 9 After Call: 432 534 239 649 254 654 459 472 477

Radix Sort: Hundreds Digit Data: 432 534 239 649 254 654 459 472 477 Bin 0 Bin 1 Bin 2 239 254 Bin 3 Bin 4 432 459 472 477 Bin 5 534 Bin 6 649 654 Bin 7 Bin 8 Bin 9 Final Sorted Data: 239 254 432 459 472 477 534 649 654