Containers: Queue and List

Transcription

1 Continers: Queue n List Queue A ontiner in whih insertion is one t one en (the til) n eletion is one t the other en (the he). Also lle FIFO (First-In, First-Out) Jori Cortell n Jori Petit Deprtment of Computer Siene push (enqueue) Queue pop (equeue) Queue usge Queue<int> Q; // Construtor Q.push(); Q.push(8); Q.push(); int n = Q.size(); // n = while (not Q.empty()) { int = Q.front(); out << << enl; Q.pop(); // Inserting few ents // Get the ent // Delete the ent Continers Dept. CS, UPC templte<typenme T> lss Queue { puli: Queue(); ~Queue(); Queue(onst T& Q); The lss Queue // Construtor // Destrutor // Copy onstrutor Queue& opertor= (onst Queue& Q); // Assignment opertor voi push(onst& T x); voi pop(); T front() onst; int size() onst; // Enqueues n ent // Dequeues the ent // Returns the ent // Numer of ents in the queue ool empty() onst; ; // Is the queue empty? Continers Dept. CS, UPC Continers Dept. CS, UPC

2 Implementtion with linke lists lst, lst Implementtion with linke lists, lst lst Q.push() Q.push(8) 8 templte<typenme T> lss Queue { privte: strut Noe { T ; Noe* ; ; Noe *; Noe *lst; int n; // Pointer to the ent // Pointer to the lst ent // Numer of ents Q.push() Q.pop() 8 8 lst lst Continers Dept. CS, UPC Queue: some methos Continers Dept. CS, UPC Queue: onstrutors n estrutor /** Returns the numer of ents. */ int size() onst { return n; /** Cheks whether the queue is empty. */ ool empty() onst { return size() == ; /** Inserts new ent t the en of the queue. */ voi push(onst T& x) { Noe* p = new Noe {x, nullptr; if (n++ == ) = lst = p; else lst = lst-> = p; /** Removes the ent. Pre: the queue is not empty. */ voi pop() { ssert(not empty()); Noe* ol = ; = ->; elete ol; if (--n == ) lst = nullptr; /** Returns the ent. Pre: the queue is not empty. */ T front() onst { ssert(not empty()); return ->; /** Defult onstrutor: n empty queue. */ Queue() : (nullptr), lst(nullptr), n() { /** Copy onstrutor. */ Queue(onst Queue& Q) { opy(q); /** Assignment opertor. */ Queue& opertor= (onst Queue& Q) { if (&Q!= this) { free(); opy(q); return *this; /** Destrutor. */ ~Queue() { free(); privte: /** Frees the linke list of noes in the queue. */ voi free() { Noe* p = ; while (p) { Noe* ol = p; p = p->; elete ol; Continers Dept. CS, UPC Continers Dept. CS, UPC 8

3 Q: *this: Queue: opy (privte) Q. /** Copies queue. */ voi opy(onst Queue& Q) { n = Q.n; if (n == ) { = lst = nullptr; else { Noe* p = Q.; Noe* p = = new Noe {p->; while (p->) { p = p->; p = p-> = new Noe {p->; p-> = nullptr; lst = p; Continers Dept. CS, UPC 9 Implementtion with irulr uffer p p Implementtion with irulr uffer A queue n lso e implemente with n rry (vetor) of ents. It is more effiient representtion if the mximum numer of ents in the queue is known in vne. Continers Dept. CS, UPC Implementtion with irulr uffer re re e fter Q.push(e) Continers Dept. CS, UPC Continers Dept. CS, UPC

4 Implementtion with irulr uffer Implementtion with irulr uffer re e re fter Q.pop() Continers Dept. CS, UPC Implementtion with irulr uffer Continers Dept. CS, UPC The lss Queue templte<typenme T> lss Queue { puli: Queue(int pity = ); ~Queue(); // Construtor (with pity) // Destrutor Queue(onst T& Q); // Copy onstrutor Queue& opertor= (onst Queue& Q); // Assignment opertor re voi push(onst& T x); voi pop(); T front() onst; // Enqueues n ent // Dequeues the ent t the he // Returns the ent int size() onst; // Numer of ents in the queue int pity() onst; // Returns the pity of the queue ool empty() onst; // Is the queue empty? fter Q.push() ool full() onst; ; // Is the queue full? Continers Dept. CS, UPC Continers Dept. CS, UPC

5 The lss Queue (inomplete) The lss Queue (inomplete) templte<typenme T> lss Queue { privte: vetor<t> uffer; int re, ; int n; // The uffer to store ents // The re/ inies // The numer of ents puli: /** Construtor with pity of the queue. */ Queue(int pity=) : uffer(pity), re(), (), n() { /** Returns the size of the queue. */ int size() onst { return n; /** Returns the pity of the queue. */ int pity() onst { return uffer.size(); /** Cheks whether the queue is full. */ ool full() onst { return size() == pity(); /** Enqueues new ent. Pre: the queue is not full. */ voi push(onst T& x) { ++n; ssert(not full()); uffer[] = x; in(); /** Dequeues the ent. Pre: the queue is not empty. */ voi pop() { ssert(not empty()); in(re); --n; /** Returns the ent. Pre: the queue is not empty. */ T front() onst { ssert(not empty()); return uffer[re]; privte: /** Inreses inex irulrly. */ voi in(int& i) { if (++i == pity()) i = ; Continers Dept. CS, UPC Queue: Complexity All opertions in queues n run in onstnt time, exept for: Copy: liner in the size of the list. Delete: liner in the size of the list. Continers Dept. CS, UPC 8 Exerise Exten the vetor-se implementtion of the queue to remove the onstrint on mximum pity. Queues o not llow to ess/inserte/elete ents in the mile of the queue. How: Inrese pity of the vetor. Reorgnize the ents in the queue. Continers Dept. CS, UPC 9 Continers Dept. CS, UPC

6 List List: grphil representtion List: ontiner with sequentil ess. lst It llows to insert/erse ents in the mile of the list in onstnt time. A list n e onsiere s sequene of ents with one or severl s (itertors) pointing t internl ents. For simpliity, we will only onsier lists with one itertor. Chek the STL list: it n e visite y ny numer of itertors L.insert() L.move_right() L.erse() 8 8 Continers Dept. CS, UPC List implementtions Continers Dept. CS, UPC The lss List: privte representtion templte <typenme T> lss List { Two stks Douly linke noes Sentinel : pointer t the noe fter the /** Douly linke noe of the list. */ strut Noe { Noe* prev; /** Pointer to the previous noe. */ T ; /** The ent of the list. */ Noe* ; /** Pointer to the ent. */ ; Noe* sentinel; /** Sentinel of the list. */ Noe* ; /** Noe fter the. */ int n; /** Numer of ents (without sentinel). */ efore the fter the Continers Dept. CS, UPC Continers Dept. CS, UPC

7 The lss List: puli methos The lss List: puli methos puli: /** Construtor of n empty list. */ List() : sentinel(new Noe), (sentinel), n() { sentinel-> = sentinel->prev = sentinel; /** Destrutor. */ ~List() { free(); /** Copy onstrutor. */ List(onst List& L) { opy(l); /** Assignment opertor. */ List& opertor= (onst List& L) { if (&L!= this) { free(); opy(l); return *this; /** Returns the numer of ents in the list. */ int size() onst { return n; /** Cheks whether the list is empty. */ ool empty() onst { return size() == ; puli: /** Cheks whether the is t the eginning of the list. */ ool is_t_front() onst { return == sentinel->; /** Cheks whether the is t the en of the list. */ ool is_t_en() onst { return == sentinel; /** Moves the one position kwr. Pre: the is not t the eginning of the list. */ voi move_kwr() { ssert(not is_t_front()); = ->prev; /** Moves the one position forwr. Pre: the is not t the en of the list. */ voi move_forwr() { ssert(not is_t_en()); = ->; Continers Dept. CS, UPC The lss List: puli methos Continers Dept. CS, UPC The lss List: puli methos puli: /** Moves the to the eginning of the list. */ voi move_to_front() { = sentinel->; /** Moves the to the en of the list. */ voi move_to_en() { = sentinel; /** Inserts n ent x efore the. */ voi insert(onst T& x) { Noe* p = new Noe {->prev, x, ; ->prev = ->prev-> = p; ++n; x x p puli: /** Erses the ent fter the. Pre: is not t the en. */ voi erse() { ssert(not is_t_en()); Noe* p = ; p->->prev = p->prev; = p->prev-> = p->; elete p; --n; /** Returns the ent fter the. Pre: the is not t the en. */ T front() onst { ssert(not is_t_en()); return ->; p Exerises: implement the privte methos opy() n free(). Continers Dept. CS, UPC Continers Dept. CS, UPC 8

8 Exerises for lists Exerises for lists Design the metho reverse() tht reverses the ontents of the list: No uxiliry lists shoul e use. No opies of the ents shoul e performe. Solve the Josephus prolem, for n people n exeuting every k-th person, using irulr list: Design the metho merge(onst List& L) tht merges the list with nother list L, ssuming tht oth lists re sorte. Assume tht pir of ents n e ompre with the opertor <. Design the metho sort() tht sorts the list oring to the < opertor. Consier merge sort n quik sort s possile lgorithms. Exten the previous methos with the ompre funtion s prmeter of eh metho. Continers Dept. CS, UPC 9 Higher-orer funtions A higher-orer funtion is funtion tht n reeive other funtions s prmeters or return funtion s result. Most lnguges support higher-orer funtions (C++, python, R, Hskell, Jv, JvSript, ). The hve ifferent pplitions: sort in STL is higher-orer funtion (the ompre funtion is prmeter). funtions to visit the ents of ontiners (lists, trees, et.) n e psse s prmeters. Mthemtis: funtions for omposition n integrtion reeive funtion s prmeter. et Continers Dept. CS, UPC Higher-orer funtions: exmple templte <typenme T> lss List { /** Trnsforms every ent of the list using f. It returns referene to the list. */ List<T>& trnsform(voi f(t&)); /** Returns list with the ents for whih f is true */ List<T> filter(ool f(onst T&)) onst; /** Applies f sequentilly to the list n returns single vlue. For the list [x, x, x,, x n ] it returns f( f f x, x, x, x n ). If the list hs one ent, it returns x. The list is ssume to e non-empty */ T reue(t f(onst T&, onst T&)) onst; Continers Dept. CS, UPC Continers Dept. CS, UPC

9 Higher-orer funtions: exmple Higher-orer funtions: exmple /** Cheks whether numer is prime */ ool isprime(int n) { /** As two numers */ int (int x, int y) { return x + y; /** Returns the squre of numer */ int squre(int x) { return x*x; /** The following oe omputes: */ x L, x is prime Note: it ssumes tht there is t lest one prime in the list. int n = L.filter(isPrime).trnsform(squre).reue(); Continers Dept. CS, UPC x List<T>& trnsform(voi f(t&)) { Noe* p = sentinel->; while (p!= sentinel) { // Visit ll ents n pply f to eh one f(p->); p = p->; return *this; List<T> filter(ool f(onst T&)) onst { List<T> L; Noe* p = sentinel->; while (p!= sentinel) { // Pik ents only if f is sserte if (f(p->)) L.insert(p->); p = p->; return L; T reue(t f(onst T&, onst T&)) onst { ssert(l.size() > ); T x = sentinel->->; // First ent (n result) Noe* p = sentinel->->; while (p!= sentinel) { x = f(x, p->); // Composition with ent p = p->; return x; Continers Dept. CS, UPC