1. 1 Generic Positional Containers and Double-Ended Queues

2. 2 Generic Positional Container A generic container C that is –Organized and accessed by position The order of elements in container is determined by the order in which they are inserted into container –Sufficient to support either: push_front(), pop_front(), front() or push_back(), pop_back(), back() –Supporting associated iterators C ::Iterator is a “pContainer”, for short –Also known as “sequence containers” Examples: Vector, List, Stack, Queue, and Deque

3. 3 Double-Ended Queue Deque (pronounced ‘Deck’) Deque operations –Push/Pop at either end –Retrieve data from either end –Data of proper type Assumptions on element type T (proper type) –Constructor T() and destructor ~T() –Copy constructor –Assignment operator=

4. 4 Specifying Deque Requirements for Deque –O(1) average runtime, push_front(t), pop_front(), front() push_back(t), pop_back(), back() –O(size()) space –O(1) time and space for iterator operations –Random access iterator (for typical array-based implementation) Bracket operator ([ ]), also known as Pointer arithmetic

5. 5 Deque Implementation Plan Circular array –Protected array content of size content_size –Content wraps around the end of the array to the beginning. –Illusion: content[content_size] == content[0] Relative Indexing –Protected integers begin, end –Bracket [] Operator Similar to Vector Element position relative to begin Front element is content[begin] Back element is content[end – 1] –Size is (end – begin + content_size) % content_size

6. 6 Deque ::iterator Implementation Plan Public interface –Start with the public interface like that of List ::iterator i.e. like the iterator for vector or linked list –Add bracket operator

7. 7 Deque D Illustrated content_size = 8 D.empty() == true 01234567 beginend content

8. 8 Deque D Illustrated (2) content_size = 8 D.push_back(‘M’) 01234567 M beginend content

9. 9 Deque D Illustrated (3) content_size = 8 D.push_back(‘e’) 01234567 Me beginend content

10. 10 Deque D Illustrated (4) content_size = 8 D.push_back(‘r’) 01234567 Mer beginend content

11. 11 Deque D Illustrated (5) content_size = 8 D.push_back(‘r’) 01234567 Merr beginend content

12. 12 Deque D Illustrated (6) content_size = 8 D.push_back(‘y’) 01234567 Merry beginend content

13. 13 Deque D Illustrated (7) content_size = 8 D.pop_front() O(1) 01234567 erry beginend content

14. 14 Deque D Illustrated (8) content_size = 8 D.pop_front() 01234567 rry beginend content

15. 15 Deque D Illustrated (9) content_size = 8 D.push_back(‘G’) 01234567 rryG beginend content

16. 16 Deque D Illustrated (10) content_size = 8 D.push_back(‘o’) D.size() == (7 – 2 + 8) % 8 01234567 rryGo beginend content

17. 17 Deque D Illustrated (11) content_size = 8 D.push_back(‘A’) D.size() = (0 – 2 + 8) % 8 01234567 rryGoA beginend content

18. 18 Deque D Illustrated (12) content_size = 8 D.push_back(‘r’) D.size() = (1 – 2 + 8) % 8 01234567 rrryGoA beginend content

19. 19 Deque D Illustrated (13) D.size() == content_size – 1 Now what? –Return full or –Double the capacity (as with Vector). 01234567 rrryGoA beginend content

20. 20 Defining Deque template class Deque { public: // type definitions typedef T value_type; typedef DequeIterator iterator; // constructors, destructor Deque(); Deque(size_t, const T&); Deque(const Deque &);// copy Deque(Deque &&);// move ~Deque(); // member operators Deque & operator = (const Deque &); // copy assignment Deque & operator=(Deque &&);// move assignment T& operator [] (size_t) const; // generic display methods void Display (ostream& os, char ofc = ‘ ') const; void Dump (ostream& os) const;

21. 21 Defining Deque (2) // Container class protocol int Empty () const; size_t Size () const; int push_front (const T&); int pop_front (); int push_back (const T&); int pop_back (); void Clear (); T& Front () const; T& Back () const; // and move version of push_front and push_back // iterator support friend class DequeIterator ; iterator begin() const; iterator end() const; protected: // classic circular array implementation T* content; size_t content_size, begin, end; };

22. 22 Defining Deque (3) // operator overloads (friend status not required) template ostream& operator & a); template int operator==(const Deque &, const Deque &); template int operator!=(const Deque &, const Deque &);

23. 23 Defining DequeIterator template class DequeIterator { friend class Deque ; public: // terminology support typedef T value_type; // constructors DequeIterator(); DequeIterator(const Deque & Q); DequeIterator(const DequeIterator & I); // information/access T& retrieve() const; // return ptr to current Tval int valid() const; // cursor is valid element

24. 24 Defining DequeIterator (2) // various operators int operator==(const DequeIterator & I2) const; int operator!=(const DequeIterator & I2) const; T& operator*() const; // return reference to current Tval T& operator[] (size_t i) const; //return reference to Tval at index i DequeIterator & operator=(const DequeIterator & I); DequeIterator & operator++(); // prefix DequeIterator operator++(int); // postfix DequeIterator & operator--(); // prefix DequeIterator operator--(int); // postfix

25. 25 Defining DequeIterator (3) // pointer arithmetic long operator-(const DequeIterator & I2) const; DequeIterator & operator+=(long n); DequeIterator & operator-=(long n); DequeIterator operator+(long n) const; DequeIterator & operator+=(int n); DequeIterator & operator-=(int n); DequeIterator operator+(int n) const; DequeIterator & operator+=(unsigned long n); DequeIterator & operator-=(unsigned long n); DequeIterator operator+(unsigned long n) const; DequeIterator & operator+=(unsigned int n); DequeIterator & operator-=(unsigned int n); DequeIterator operator+(unsigned int n) const;

26. 26 Defining DequeIterator (3) // Initializers void Initialize (const Deque & Q); void rInitialize (const Deque & Q); protected: const Deque * Qptr; size_t index; };

27. 27 Implementing Deque Default constructor template Deque ::Deque() : content{nullptr}, begin{0}, end{0}, content_size{0} { content = new (nothrow) T[default_content_size]; if (content == nullptr) { // error } content_size = default_content_size; } static const size_t default_content_size = 10; // another way, using exception handling // try { // content = new T[default_content_size]; // } // catch (bad_alloc&) { // report error // }

28. 28 Implementing Deque (2) Copy and move constructors template Deque ::Deque(const Deque & Q) : content_size(Q.content_size), begin(Q.begin), end(Q.end) { content = new T[content_size]; // error handling if memory is not properly allocated. for (size_t j = 0; j < content_size; j++) { content[j] = Q.content[j]; } Template Deque ::Deque(Deque &&Q) : content_size(Q.content_size), begin(Q.begin), end(Q.end), content(Q.content) { Q.content = nullptr; Q.content_size = 0; Q.begin = Q.end = 0; }

29. 29 Implementing Deque (3) Copy and move assignment opeators template Deque & Deque ::operator=(const Deque & Q) { if (this != &Q) { T* newcontent = new T[Q.content_size]; // check for allocation delete[] content; content = newcontent; content_size = Q.content_size; begin = Q.begin; end = Q.end; // copy queue elements } return *this; } template Deque & Deque ::operator=(Deque && Q) { std::swap(content, Q.content); std::swap(content_size, Q.content_size); std::swap(begin, Q.begin); std::swap(end, Q.end); return *this; }

30. 30 Implementing Deque (4) Index operator template T& Deque ::operator[] (size_t i) const { if (size() <= i) { // error } return content[(i + begin) % content_size]; } Display functions template void Deque ::Display(ostream& os, char ofc) const { for (size_t j = 0; j < size(); ++j) { os << operator[](j); os << ofc; } template void Deque ::Dump(ostream& os) const { for (size_t j = 0; j < content_size; ++j) { // print } }

31. 31 Implementing Deque (5) operator overloads template ostream operator & Q) { Q.Display(os); return(os); } template int operator==(const Deque & Q1, const Deque & Q2) { if (Q1.size() != Q2.size()) { return 0; } for (size_t j = 0; j < Q1.size(); ++j) { if (Q1[j] != Q2[j]) { return 0; } } return 1; } template int operator!=(const Deque & Q1, const Deque & Q2) { return !(Q1 == Q2); }

32. 32 Implementing Deque (6) Container class protocol template size_t Deque ::Size() const { return (end – begin + content_size) % content_size; } template int Deque ::empty() const { return begin == end; } template void Deque ::Clear() { begin = end = 0; }

33. 33 Implementing Deque (7) template T& Deque ::front() const { // check for empty deque… return content[begin]; } template T& Deque ::back() const { // check for empty deque… if (end == 0) return content[content_size - 1]; return content[end - 1]; // or return content[(end – 1 + content_size) % content_size]; }

34. 34 Implementing Deque (8) template int Deque ::push_back(const T& Tval) { if (size() + 1 >= content_size) { // deque is full unsigned j, k; size_t newcontent_size = 2 * content_size; if (content_size == 0) newcontent_size = 2; T* newcontent = new T[newcontent_size]; // check for allocation error for (j = k = begin; j != end; j = (j + 1) % content_size, ++k) { newcontent[k] = content[j]; } if (end < begin) {end += content_size; } delete[] content; content = newcontent; content_size = newcontent_size; } content[end] = Tval; end = (end + 1) % content_size; return 1; } How to implement the move version of the push_back function?

35. 35 Implementing Deque (9) template int Deque ::push_front(const T& Tval) { if (size() + 1 >= content_size) { // deque is full unsigned j, k; size_t newcontent_size = 2 * content_size; if (content_size == 0) newcontent_size = 2; T* newcontent = new T[newcontent_size]; // check for allocation error for (j = k = begin; j != end; j = (j + 1) % content_size, ++k) { newcontent[k] = content[j]; } if (end < begin) { end += content_size; } delete[] content; content = newcontent; content_size = newcontent_size; } begin = (begin – 1 + content_size) % content_size; content[begin] = Tval; return 1; } How to implement the move version of push_front()?

36. 36 Implementing Deque (10) template int Deque ::pop_front() { if (begin == end) return 0; begin = (begin + 1) % content_size; return 1; } template int Deque ::pop_back() { if (begin == end) return 0; end = (end – 1 + content_size) % content_size; return 1; }

37. 37 Implementing Deque (11) Iterator support template DequeIterator Deque ::begin() const { Deque ::iterator I; I.Qptr = this; I.index = 0; return I; } template DequeIterator Deque ::end() const { Deque ::iterator I; I.Qptr = this; I.index = size(); return I; }

38. 38 Implementing DequeIterator Constructors template DequeIterator ::DequeIterator() : Qptr{nullptr}, index{0} { } template DequeIterator ::DequeIterator(const Deque & Q) : Qptr{&Q}, index{0} { } template DequeIterator ::DequeIterator(const DequeIterator & I) : Qptr{I.Qptr}, index{I.index} { }

39. 39 Implementing DequeIterator (2) Initialization routines template void DequeIterator ::Initialize(const Deque & Q) { Qptr = &Q; index = 0; } template void DequeIterator ::rInitialize(const Deque & Q) { Qptr = &Q; index = Q.size() – 1; }

40. 40 Implementing DequeIterator (3) Helper functions template int DequeIterator ::valid() const { if (Qptr == nullptr) return 0; if (index >= Qptr->size()) return 0; return 1; } template T& DequeIterator ::operator[] (size_t i) const { if (!Qptr) { // error } return Qptr->operator[](index + i); }

41. 41 Implementing DequeIterator (4) Helper functions template T& DequeIterator ::retrieve() const { if (Qptr == nullptr) { // error } if (Qptr->size() == 0) { // error } return Qptr->operator[](index); } template T& DequeIterator ::operator* () const { // check for validity return Qptr->operator[](index); }

42. 42 Implementing DequeIterator (5) Comparators template int DequeIterator ::operator==(const DequeIterator & I2) const { if (Qptr != I2.Qptr) return 0; if (index != I2.index) return 0; return 1; } template int DequeIterator ::operator!=(const DequeIterator & I2) const { return !(*this == I2); }

43. 43 Implementing DequeIterator (6) Assignment template DequeIterator & DequeIterator ::operator=(const DequeIterator & I) { if (this != &I) { Qptr = I.Qptr; index = I.index; } return *this; }

44. 44 Implementing DequeIterator (7) Various operators template DequeIterator & DequeIterator ::operator++() { // prefix ++index; return *this; } template DequeIterator DequeIterator ::operator++(int) { // postfix DequeIterator I(*this); operator ++(); return I; }

45. 45 Implementing DequeIterator (8) Various operators template DequeIterator & DequeIterator ::operator--() { // prefix --index; return *this; } template DequeIterator DequeIterator ::operator--(int) { // postfix DequeIterator I(*this); operator --(); return I; }

46. 46 Implementing DequeIterator (9) Various operators template long DequeIterator ::operator-(const DequeIterator & I2) const { // return the distance between the two iterators return index – I2.index; } template DequeIterator DequeIterator ::operator+(long n) const { // advance the iterator by n DequeIterator I(*this); return I += n; }

47. 47 Implementing DequeIterator (10) Various operators template DequeIterator & DequeIterator ::operator+=(long n) { index += n; return *this; } template DequeIterator & DequeIterator ::operator-=(long n) { index -= n; return *this; }

48. 48 Reading assignment Chapter 4 Trees