Kontenery, algorytmy - Politechnika Śląska

Transkrypt

Kontenery, algorytmy
Zaawansowane biblioteki programistyczne
Sebastian Deorowicz
Politechnika Śląska
2008–10–23
Sebastian Deorowicz (PŚl)
2008–10–23
1 / 84
Plan wykładu
1
Kontenery sekwencyjne
Kontener deque
Adaptatory kontenerów
Adaptator kontenera queue
Adaptator kontenera stack
Adaptator kontenera priority queue
2
Kontenery asocjacyjne
Klasa pair
Kontener set
Kontener multiset
Kontener bitset
2008–10–23
2 / 84
Plan wykładu
1
Kontener deque
2
Klasa pair
Kontener set
Kontener multiset
Kontener bitset
2008–10–23
3 / 84
Kontener deque
Czym jest kontener deque?1
Kontener sekwencyjny
Podobny do kontenera vector w tym, że wspiera bezpośredni dostęp do elementów
a czas wstawiania i usuwania elementów ze środka jest liniowy
Podobny do kontenera list w tym, że czas wstawiania i usuwania elementów
z początku i końca jest stały
1
Dostępna w pliku nagłówkowym deque
2008–10–23
4 / 84
Kontener deque
Konstruktory
Analogiczne jak w list i vector
Przypisania
Metody assign analogiczne jak w list i vector
Operator przypisania również analogiczny
Metody zwracające iteratory
Dostępne metody begin, end, rbegin, rend zwracające iteratory o takim samym
znaczeniu jak w innych kontenerach sekwencyjnych
Metody związane z rozmiarem
Dostępne metody size, max size, resize, empty o takim samym znaczeniu jak
w innych kontenerach sekwencyjnych
2008–10–23
5 / 84
Kontener deque — dostęp swobodny do elementów
reference operator[](size_type n)
const_reference operator[](size_type n) const
Działanie: Zwraca referencję (stałą referencję) do n-tego elementu kontenera
Parametr:
n — numer elementu
Zwracana wartość: Referencja (stała referencja) do elementu
Złożoność: O(1)
Uwaga: Brak kontroli zakresu, więc możliwe zachowanie niezdefiniowane jeśli podany
błędny indeks
2008–10–23
6 / 84
reference at(size_type n)
const_reference at(size_type n) const
Działanie: Zwraca referencję (stałą referencję) do n-tego elementu kontenera
Parametr:
n — numer elementu
Zwracana wartość: Referencja (stała referencja) do elementu
Złożoność: O(1)
Uwaga: Kontrola zakresu, więc jeśli podany błędny indeks to generuje wyjątek
out_of_range
2008–10–23
7 / 84
reference front()
const_reference front() const
reference back()
const_reference back() const
Działanie: Zwraca referencję (stałą referencję) do pierwszego (ostatniego) elementu
kontenera
Parametry: brak
Zwracana wartość: Referencja (stała referencja) do elementu kontenera
Złożoność: O(1)
Uwaga: Brak kontroli zakresu, więc jeśli kontener jest pusty to zachowanie
niezdefiniowane
2008–10–23
8 / 84
Kontener deque — operacje na końcach
void push_front(const T& x)
void push_back(const T& x)
Działanie: Dodaje element na początek (koniec) kontenera
Parametr:
x — wstawiany element
Zwracana wartość: brak
Złożoność: O(1)
void pop_front()
void pop_back()
Działanie: Usuwa element z początku (końca) kontenera
Parametry: brak
Złożoność: O(1)
2008–10–23
9 / 84
Kontener deque — wstawianie i usuwanie elementów
Wstawianie elementów
Dostępne 3 metody insert o identycznych parametrach i działaniu jak dla
kontenera vector i list
Złożoność: O(n), gdzie n to rozmiar kontenera
Usuwanie elementów
Dostępne 2 metody erase o identycznych parametrach i działaniu jak dla
Inne
Metoda clear identyczna jak dla innych kontenerów (złożoność O(n))
Metoda swap identyczna jak dla innych kontenerów (złożoność O(1))
2008–10–23
10 / 84
Usuwanie elementów
Inne
2008–10–23
10 / 84
Usuwanie elementów
Inne
2008–10–23
10 / 84
Kontener deque — przykład
Przykład
# include < deque >
using namespace std ;
const int MAX = 10;
int main ( int argc , char * argv [])
{
int tab [ MAX ] = {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10};
deque < int > di ( tab , tab +5);
ShowC ollection ( di );
// 1
2
3
4
5
di . insert ( di . begin ()+3 , tab +7 , tab +10);
// 1
2
3
8
9
di . pop_front ();
// 2
3
8
9
10
di . push_front (12);
// 12
2
3
8
9
10
4
4
5
10
5
4
5
}
2008–10–23
11 / 84
Kontenery vector, list, deque częściowo mogą być używane zamiennie ale zawsze
pewnym kosztem
Nie można żadnej z nich zbudować w oparciu o inną bez utraty wydajności
Adaptatory
Często przydają się także inne kontenery sekwencyjne
Ponieważ można je oprzeć na jednej z tych 3 podstawowych, to nie są one
implementowane osobno, a jako adaptacje jednego z kontenrów podstawowych
2008–10–23
12 / 84
Adaptator queue
Składnia2
template < class T ,
class Collection = deque <T > >
class queue {
...
};
Opis
Implementuje kolejkę FIFO
Nie udostępnia operacji „nie kolejkowych”
Kontener domyślnie oparty o deque ale można użyć dowolnego kontenera
dostarczającego metod front, back, push back, pop front (czyli nie vector)
2
Dostępna w pliku nagłówkowym queue
2008–10–23
13 / 84
Adaptator queue — konstruktor
queue(const Collection& = Collection())
Działanie: Tworzy pustą kolejkę (jeśli brak parametru) lub kolejkę zainicjalizowaną
zawartością przekazanego kontenera
Parametr:
Kontener inicjalizujący kolejkę
Złożoność: Stała jeśli nie ma parametru bądź liniowa jeśli jest parametr
2008–10–23
14 / 84
Adaptator queue — operacje kolejkowe
Implementacja
bool
size_type
reference
c onst_r e fe re nce
reference
void
void
empty () const
size () const
front ()
front () const
back ()
back () const
push ( const value_type & x )
pop ()
{ return c . empty ();}
{ return c . size ();}
{ return c . front ();}
{ return c . back ();}
{ c . push_back ( x );}
{ c . pop_front ();}
2008–10–23
15 / 84
Adaptator queue — inne operacje
Inne operacje
Dostępne operatory porównywania kontenerów działające identycznie jak dla
kontenera, na którym jest oparta kolejka
2008–10–23
16 / 84
Adaptator queue — przykład
Przykład
# include < iostream >
# include < list >
# include < queue >
const int MAX = 10;
template < class Queue > void ShowQueue ( Queue q ) {
for (; ! q . empty (); q . pop ())
std :: cout << q . front () << " " ;
std :: cout << std :: endl ;
}
{
int tab [ MAX ] = {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10};
queue < int > qdi ( di );
// Sh owCollection ( qdi );
// Błąd kompilacji :
ShowQueue ( qdi );
//
// Błąd kompilacji : vector nie ma metody pop !
// queue < int , vector < int > > qvi ( vector < int >( tab ,
// ShowQueue ( qvi );
list < int > li ( tab , tab +10);
li . reverse ();
queue < int , list < int > > qli ( li );
ShowQueue ( qli );
//
brak metod begin () i end ()
1 2 3 4 5 6 7 8 9 10
tab +10));
10 9 8 7 6 5 4 3 2 1
}
2008–10–23
17 / 84
Adaptator stack
Składnia3
class Collection = deque <T > >
class stack {
...
};
Opis
Implementuje stos
Nie udostępnia operacji „nie stosowych”
Kontener domyślnie oparty o deque ale można użyć dowolnego kontenera
dostarczającego metod back, push back, pop back (czyli np. vector, list, deque)
3
Dostępna w pliku nagłówkowym stack
2008–10–23
18 / 84
Adaptator stack — konstruktor
stack(const Collection& = Collection())
Działanie: Tworzy pusty stos (jeśli brak parametru) lub stos zainicjalizowany
zawartością przekazanego kontenera
Parametr:
Kontener inicjalizujący stos
Złożoność: Stała jeśli nie ma parametru bądź liniowa jeśli jest parametr
2008–10–23
19 / 84
Adaptator stack — operacje stosowe
Implementacja
bool
size_type
reference
void
void
empty () const
size () const
top ()
top () const
push ( const value_type & x )
pop ()
{ c . push_back ( x );}
{ c . pop_back ();}
2008–10–23
20 / 84
Adaptator stack — inne operacje
Inne operacje
Dostępne operatory porównywania stosów działające identycznie jak dla kontenera,
na którym jest oparta stos
2008–10–23
21 / 84
Adaptator stack — przykład
Przykład
# include < vector >
# include < stack >
const int MAX = 10;
template < class Stack > void ShowStack ( Stack q ) {
for (; ! q . empty (); q . pop ())
std :: cout << q . top () << " " ;
std :: cout << std :: endl ;
}
{
int tab [ MAX ] = {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10};
vector < int > vi ( tab , tab +10);
stack < int , vector < int > > svi ( vi );
ShowStack ( svi );
// 10 9 8 7 6 5 4 3 2 1
stack < int > sdi ( di );
ShowStack ( sdi );
sdi . push (10);
ShowStack ( sdi );
// 10 9 8 7 6 5 4 3 2 1
// 10 10 9 8 7 6 5 4 3 2 1
}
2008–10–23
22 / 84
Adaptator priority queue
Składnia4
class Collection = vector <T > ,
class Compare = less < typename Collection :: value_type > >
class pri ority_queue {
...
};
Opis
Implementuje kolejkę priorytetową, czyli taką kolejkę, w której elementy są
umieszczane według priorytetu
Nie udostępnia operacji „nie kolejkowych” ani operatorów porównania kontenerów
Kontener domyślnie oparty o vector ale można użyć dowolnego kontenera
dostarczającego metod front, push back, pop back oraz iteratorów dostępu
swobodnego (czyli np. vector, deque, ale nie list)
Ostatni parametr wzorca określa kryterium porównywania dla ustalenia priorytetu —
domyślnie przy użyciu operatora <
Wewnętrznie implementowana za pomocą kopca
4
Dostępna w pliku nagłówkowym queue
2008–10–23
23 / 84
Adaptator priority queue — konstruktory
priority_queue(const Compare& comp = Compare(),
const Collection& = Collection())
Działanie: Tworzy pustą kolejkę priorytetową i inicjalizuje ją (jeśli jest parametr)
zawartością kontenera przekazanego jako drugi parametr
Parametry:
pierwszy — określa kryterium sortowania
drugi — zawiera dane do inicjalizacji kontenera
Złożoność: Stała jeśli nie ma parametru bądź O(n) jeśli jest parametr
Uwaga: Po inicjalizacji kolejki wywoływana jest funkcja STL:
make_heap(c.begin(), c.end(), comp)
2008–10–23
24 / 84
Adaptator priority queue — konstruktory
priority_queue(InputIterator first, InputIterator last,
const Compare& comp = Compare(),
const Collection& y = Collection())
Działanie: Tworzy pustą kolejkę priorytetową i inicjalizuje ją zawartością określoną
przekazanymi iteratorami: [first, last)
Parametry:
first, last — iteratory specyfikujące zakres kontenera używanego do inicjalizacji
kolejki priorytetowej
trzeci — określa kryterium sortowania
czwarty — zawiera dane do inicjalizacji kolekcji
Złożoność: O(n)
Uwaga: Po inicjalizacji kolejki wywoływana jest funkcja STL:
make_heap(c.begin(), c.end(), comp)
2008–10–23
25 / 84
Adaptator priority queue — operacje kolejkowe
Implementacja
bool
size_type
void
void
empty () const
size () const
top () const
push ( const value_type & x );
pop ();
Złożoność
empty, size, top — w zależności od złożoności tych operacji dla kontenera,
na którym jest oparta kolejka priorytetowa; dla wektora będzie to O(1)
push, pop — O(log n)
Uwaga
Zachowanie metod top i pop dla pustej kolejki jest niezdefiniowane
2008–10–23
26 / 84
Adaptator priority queue — przykład
Przykład
# include < queue >
# include < vector >
# include < deque >
# include < functional >
# include < string >
const int MAX = 10;
template < class PQ > void ShowPQ ( PQ & pq ) {
for (; ! pq . empty (); pq . pop ())
cout << pq . top () << " " ;
cout << endl ;
}
int main ( int argc , char * argv []) {
int tab [ MAX ] = {5 , 6 , 8 , 1 , 2 , 3 , 4 , 10 , 7 , 9};
vector < int > vi ( tab , tab +10);
priority_queue < int , vector < int > , less < int > > pqvi1 ( less < int >() , vi );
ShowPQ ( pqvi1 );
// 10 9 8 7 6 5 4 3 2 1
priority_queue < int , vector < int > > pqvi2 ( tab , tab +10);
ShowPQ ( pqvi2 );
// 10 9 8 7 6 5 4 3 2 1
priority_queue < int , deque < int > , greater < int > > pqdi1 ( greater < int >() ,
deque < int >( tab , tab +10));
ShowPQ ( pqdi1 );
// 1 2 3 4 5 6 7 8 9 10
priority_queue < string , vector < string > > pqs ;
pqs . push ( " Ola " ); pqs . push ( " Jola " ); pqs . push ( " Iza " );
ShowPQ ( pqs );
// Ola Jola Iza
}
2008–10–23
27 / 84
Plan wykładu
1
Kontener deque
2
Klasa pair
Kontener set
Kontener multiset
Kontener bitset
2008–10–23
28 / 84
Klasa pair
Opis5
Grupuje dwie wartości różnych typów w ramach jednej struktury
Jest wykorzystywana w kontenerach i algorytmach STL
Definicja
template < class T1 , class T2 >
struct pair {
typedef T1 first_type ;
typedef T2 second_type ;
T1 first ;
T2 second ;
pair ();
pair ( const T1 & x , const T2 & y );
template < class U , class V > pair ( const pair <U , V > & p );
};
5
Klasa zdefiniowana w pliku utility
2008–10–23
29 / 84
Klasa pair — konstruktory
pair()
Działanie: Inicjalizuje parę domyślnymi wartościami typów składowych
pair(const T1& x, const T2& y)
Działanie: Inicjalizuje parę wartościami x i y
template <class U, class V> pair(const pair<U, V> &p)
Działanie: Inicjalizuje parę wartością pary p
2008–10–23
30 / 84
Klasa pair — operator porównania
bool operator==(const pair<T1, T2>& x, const pair<T1, T2>& y)
Działanie: Porównuje dwie pary za pomocą operatorów == wywoływanych dla
pierwszych i drugich składowych
Parametry:
x, y — porównywane pary
Zwracana wartość: x.first == y.first && x.second == y.second
Złożoność: O(1)
2008–10–23
31 / 84
Klasa pair — funkcja make pair
template <class T1, class T2>
pair<T1, T2> make_pair(T1 x, T2 y)
Działanie: Tworzy obiekt pary
Parametry:
x, y — pierwszy i drugi element pary
Zwracana wartość: obiekt pary zawierający x i y
Złożoność: O(1)
Uwaga: Funkcja umożliwia niepodawanie w sposób jawny typów, w odróżnieniu
od wywołania konstruktora:
std::pair<int,double>(10,5.6)
std::make_pair(10,5.6)
2008–10–23
32 / 84
Klasa pair — przykład
Przykład
# include < utility >
template < class Pair >
void ShowPair ( Pair p )
{
cout << " * " << p . first << " *
}
" << p . second << endl ;
{
pair < string , int > p1 ;
ShowPair ( p1 );
// **
0
pair < string , float > p2 ( " Test " , 10);
ShowPair ( p2 );
// * Test *
ShowPair ( make_pair (10 , 5.7));
// *10*
ShowPair ( make_pair ( " Zuzia " , 5.7));
// * Zuzia *
10
5.7
5.7
}
2008–10–23
33 / 84
Kontener set
Opis6
Kontener umożliwia przechowywanie elementów
W odróżnieniu od kontenerów sekwencyjnych, w kontenerze set porządek elementów
nie jest określany przez pozycję, na której są one wstawiane
Elementy są uporządkowywane automatycznie zgodnie z określonym kryterium
sortowania
Kontener umożliwia przechowywanie tylko jednej kopii elementu (powtórzenia są
zabronione)
Kontener jest dostosowany do wymagań algorytmów realizujących operacje zbiorowe
(suma, przecięcie, itd.)
6
Dostępna w pliku nagłówkowym set
2008–10–23
34 / 84
Kontener set
Kryterium sortowania
Uporządkowanie ścisłe słabe:
Jeśli prawdziwe x < y , to y < x jest nieprawdziwe
Jeśli x < y i y < z, to musi zachodzić x < z
x < x jest zawsze fałszywe
2008–10–23
35 / 84
Kontener set — konstruktory
set(const Compare &comp = Compare(), const Allocator& = Allocator())
Działanie: Tworzy pusty zbiór
Parametry:
comp — kryterium sortowania (domyślnie less<T>)
Allocator — obiekt alokatora
Złożoność: O(1)
2008–10–23
36 / 84
set(InputIterator first, InputIterator last,
const Compare& comp = Compare(), const Allocator& = Allocator())
Działanie: Tworzy zbiór i inicjalizuje go elementami z zakresu [first, last)
Parametry:
first, last — iteratory wejściowe specyfikujące zakres
comp — kryterium sortowania (domyślnie less<T>)
Allocator — obiekt alokatora
Złożoność (n — liczba elementów w zakresie):
O(n) jeśli elementy posortowane
O(n log n) jeśli elementy nieposortowane
2008–10–23
37 / 84
set(const set<Key, Compare, Allocator>& x)
Działanie: Tworzy zbiór i inicjalizuje go elementami ze zbioru x
Parametr:
x — zbiór użyty do zainicjalizowania tworzonego kontenera
Złożoność: liniowa względem liczby elementów x
2008–10–23
38 / 84
Kontener set — przykład
Przykład
# include < set >
# include < functional >
const int MAX = 10;
typedef enum { poniedzialek , wtorek , sroda , czwartek , piatek , sobota ,
niedziela } t_days ;
int tab [ MAX ] = {1 , 52 , 31 , 25 , 4 , 8 , 65 , 45 , 65 , 10};
set < int > si , si2 ( tab , tab +10);
ShowC ollection ( si );
//
ShowC ollection ( si2 );
// 1 4 8 10
25
31
45
52
65
set < t_days > sd ;
set < t_days , greater < t_days > > sd2 ;
sd . insert ( wtorek );
ShowC ollection ( sd );
sd2 . insert ( sroda );
ShowC ollection ( sd2 );
sd . insert ( piatek );
// 1
sd2 . insert ( sobota );
// 5
4
2
set < t_days , greater < t_days > > sd3 ( sd2 );
// 5 2
set < t_days , greater < t_days > > sd4 ( sd . begin () , sd . end ());
// 4 1
}
2008–10–23
39 / 84
Kontener set — przypisanie
set<Key, Compare, Allocator >& operator =
(const set<Key, Compare, Allocator>& x)
Działanie: Operator przypisania, kopiujący zawartość kontenera
Parametr:
x — kopiowany zbiór
Złożoność: liniowa względem sumy liczby elementów kopiowanego zbioru i liczby
elementów zbioru bieżącego (elementy z bieżącego zbioru muszą być usunięte)
2008–10–23
40 / 84
Kontener set — inne metody
Metody zwracające iteratory
Dostępne metody begin, end, rbegin, rend zwracające iteratory analogiczne
do iteratorów dla kontenerów sekwencyjnych
Złożoność: O(1)
Uwaga: kolejność elementów określana przez kryterium sortowania
Metody związane z rozmiarem
Dostępne metody empty, size, max size analogiczne jak dla kontenerów
sekwencyjnych
Złożoność: O(1)
Operatory
Dostępne operatory ==, !=, <, <=, >=, > porównujące zbiory
Złożoność: liniowa względem rozmiaru mniejszego ze zbiorów
Uwaga: kolejność wstawiania elementów do porównywanych zbiorów nie ma
znaczenia — liczy się tylko ich zawartość
2008–10–23
41 / 84
Kontener set — wstawianie elementów
pair<iterator, bool> insert(const value_type& x)
Działanie: Wstawia element do zbioru
Parametr:
Zwracana wartość: Para opisująca wynik wstawiana; składowe oznaczają:
first — iterator do wstawionego elementu lub do elementu już istniejącego jeśli
próbujemy wstawiać element już istniejący
second — wartość logiczna określająca czy element udało się wstawić (true) czy też
taki element już istniał (false)
Złożoność: O(log n), gdzie n jest liczbą elementów w kontenerze
Przykład
# include < set >
std :: set < int > si ;
std :: pair < std :: set < int >:: iterator , bool > status ;
status = si . insert (5);
std :: cout << status . second << std :: endl ;
status = si . insert (5);
std :: cout << status . second << std :: endl ;
}
// 1
// 0
2008–10–23
42 / 84
iterator insert(iterator position, const value_type& x)
Działanie: Wstawia element do zbioru
Parametry:
position — wskazówka dla metody gdzie rozpocząć poszukiwanie miejsca dla
wstawianego elementu;
Zwracana wartość: Iterator do wstawionego (bądź istniejącego już wcześniej
w zbiorze) elementu
Złożoność: O(log n), gdzie n to liczba elementów w kontenerze
Uwaga: Elementy są posortowane wewnątrz kontenera, więc podanie jako parametr
miejsca bliskiego docelowemu pozwala na szybsze wstawianie — nawet w czasie
O(1)
2008–10–23
43 / 84
void insert(InputIterator first, InputIterator last)
Działanie: Wstawia do zbioru elementy z zakresu [first, last)
Parametry:
first, last — iteratory specyfikujące zakres wstawianych elementów
Złożoność (n oznacza liczbę wstawianych elementów, s oznacza liczbę elementów
w kontenerze):
O(n + log s) jeśli elementy z zakresu są posortowane
O(n log n + log s) jeśli elementy z zakresu nie są posortowane
2008–10–23
44 / 84
Kontener set — usuwanie elementów
void erase(iterator position)
Działanie: Usuwa element wskazywany przez iterator
Parametr:
position — iterator wskazujący element do usunięcia
Złożoność: O(1)
Uwaga: Jeśli position nie jest iteratorem wskazującym na istniejący element, to
zachowanie niezdefiniowane
2008–10–23
45 / 84
size_type erase(const key_type& x)
Działanie: Usuwa element x ze zbioru
Parametr:
x — element do usunięcia
Zwracana wartość: liczba usuniętych elementów (0 bądź 1)
Złożoność: O(log n) gdzie n oznacza liczbę elementów w zbiorze
2008–10–23
46 / 84
iterator erase(iterator first, iterator last)
Działanie: Usuwa elementy z zakresu [first, last)
Parametry:
first, last — iteratory specyfikujące zakres
Złożoność: O(last − first)
2008–10–23
47 / 84
Kontener set — usuwanie elementów i zamiana zbiorów
void clear()
Działanie: Usuwa wszystkie elementy ze zbioru
Parametry: brak
Złożoność: O(n)
void swap(set<Key, Compare, Allocator>&)
Działanie: Zamienia zbiór ze zbiorem podanym jako parametr
Parametr: zbiór do zamiany
Złożoność: O(1)
2008–10–23
48 / 84
Kontener set — wyszukiwanie
iterator find(const key_type& x)
const_iterator find(const key_type& x) const
Działanie: Wyszukuje element x w zbiorze
Parametr:
x — wyszukiwany element
Zwracana wartość: Iterator (stały iterator) do pozycji zawierającej element x lub
iterator do pozycji za ostatnim elementem (wynik działania end()) jeśli elementu
nie ma w zbiorze
Złożoność: O(log n), gdzie n to liczebność kontenera
2008–10–23
49 / 84
Kontener set — zliczanie
size_type count(const key_type& x) const
Działanie: Zwraca liczbę elementów x w zbiorze
Parametr:
x — wyszukiwany element
Zwracana wartość: Liczba wystąpień x w zbiorze (0 lub 1)
2008–10–23
50 / 84
Przykład
# include < set >
const int MAX = 5;
{
int tab [ MAX ] = {1 , 2 , 3 , 4 , 5};
set < int > si ( tab , tab + MAX ) , si2 ( tab , tab + MAX );
// 1
2
3
4
// Źle !
set < int >:: iterator p = si . find (3);
* p = 7;
// To jest niestety legalne
// 1 2 7 4
cout << * si . find (4) << " " << si . count (4) << endl ;
// 0 2 !!!
5
5
}
2008–10–23
51 / 84
Kontener set — modyfikacja wartości kluczy
Skąd te problemy?7
Standard C++ wymaga aby obiekty przechowywane w kontenerze set nie miały
modyfikatora const
Taki element można w związku z tym zmodyfikować posługując się iteratorem!
Jak poprawnie modyfikować klucze?
1
Wyszukać element do zmiany
2
Sporządzić jego lokalną kopię
3
Zmodyfikować kopię (w obiektach można modyfikować np. jedno z pól — klucz, po
którym zbiór jest sortowany)
4
Usunąć element do zmiany
5
Wstawić nowy element
7
Więcej w S. Meyers, STL w praktyce. 50 sposobów efektywnego wykorzystania
2008–10–23
52 / 84
Przykład
# include < set >
const int MAX = 5;
{
int tab [ MAX ] = {1 , 2 , 3 , 4 , 5};
set < int > si ( tab , tab + MAX ) , si2 ( tab , tab + MAX );
// 1
2
3
4
// Źle !
set < int >:: iterator p = si . find (3);
* p = 7;
// To jest niestety legalne
// 1 2 7 4
cout << * si . find (4) << " " << si . count (4) << endl ;
// 0 2 !!!
5
5
// Dobrze
p = si2 . find (3);
int tmp = * p ;
tmp = 7;
// Dla obiektów modyfikujemy np . jedno z pól ( klucz )
si2 . erase ( p );
si2 . insert ( tmp );
ShowC ollection ( si2 );
// 1 2 7 4 5
cout << * si2 . find (4) << " " << si2 . count (4) << endl ;
// 4 1 !!!
}
2008–10–23
53 / 84
iterator lower_bound(const key_type& x)
const_iterator lower_bound(const key_type& x) const
Działanie: Wyszukuje najmniejszy element nie mniejszy niż x
Parametr:
x — wyszukiwana wartość
Zwracana wartość: Iterator do najmniejszego elementu nie mniejszego niż x bądź
wartość zwracana przez end()
2008–10–23
54 / 84
iterator upper_bound(const key_type& x)
const_iterator upper_bound(const key_type& x) const
Działanie: Wyszukuje największy element nie większy niż x
Parametr:
Zwracana wartość: Iterator do najmniejszego elementu większego niż x bądź wartość
zwracana przez end()
2008–10–23
55 / 84
pair<iterator, iterator> equal_range(const key_type& x)
pair<const_iterator, const_iterator> equal_range(const key_type& x) const
Działanie: Wyszukuje zakres elementów zawierających x
Parametr:
Zwracana wartość: Wyniki działania lower_bound i upper_bound w postaci pary
2008–10–23
56 / 84
Kontenera set — wyszukiwanie
Przykład
# include < set >
const int MAX = 5;
{
int tab [ MAX ] = {1 , 19 , 32 , 15 , 25};
set < int > si ( tab , tab + MAX );
pair < set < int >:: iterator , set < int >:: iterator > range ;
cout
cout
cout
cout
<<
<<
<<
<<
* si . lower_bound (15)
* si . lower_bound (16)
* si . upper_bound (15)
* si . upper_bound (25)
<<
<<
<<
<<
endl ;
endl ;
endl ;
endl ;
// 1
//
//
//
//
range = si . equal_range (15);
cout << * range . first << " " << * range . second << endl ;
15
19
25
32
15
19
19
32
// 15
19
}
2008–10–23
57 / 84
Kontener set
Jak to wszystko jest w środku zbudowane?
Złożoności operacji mocno sugerują, że dane przechowywane są w zrównoważonych
drzewach poszukiwań binarnych
Często są to drzewa czerwono-czarne
2008–10–23
58 / 84
Kontener multiset
Opis8
Kontener jest tym samym co kontener set z takim wyjątkiem, że elementy mogą się
powtarzać
Interfejs jest w zasadzie identyczny jak dla zbioru, z wyjątkiem jednej metody
wstawiania elementów
Nieco większego sensu nabierają takie metody jak count zwracające liczbę wystąpień
elementu w wielozbiorze
Złożoności niektórych operacji rosną
usuwanie klucza — O(log n + count)
zliczanie wystąpień klucza — O(log n + count)
8
Dostępna w pliku nagłówkowym set
2008–10–23
59 / 84
Kontener multiset — wstawianie elementu
iterator insert(const value_type& x)
Działanie: Wstawia element x do wielozbioru
Parametr:
x — element do wstawienia
Zwracana wartość: Iterator do wstawionego elementu (dla zbioru była tu para:
iterator, wartość logiczna)
2008–10–23
60 / 84
Kontener bitset9
Opis
Tablica zawierająca ustaloną liczbę wartości logicznych
Wygodna np. do zarządzania zbiorem znaczników
Rozmiar kontenera przekazywany jest jako parametr wzorca a nie jako parametr
konstruktora!
8
Dostępna w pliku nagłówkowym bitset
2008–10–23
61 / 84
Kontener bitset — konstruktory
bitset()
Działanie: Tworzy obiekt klasy bitset<N> zainicjalizowany wartościami 0 dla
wszystkich bitów
Parametry: brak
Złożoność: O(N)
bitset(unsigned long val)
Działanie: Tworzy obiekt klasy bitset<N> zainicjalizowany M najmłodszymi
bitami val, gdzie M = min(N, sizeof(unsigned long))
Parametr:
val — wartość używana do inicjalizacji
Złożoność: O(1)
2008–10–23
62 / 84
Kontener bitset — konstruktory
bitset(const basic_string<charT, traits, Allocator>& str,
typename basic_string<charT, traits, Allocator>::size_type pos=0,
typename basic_string<charT, traits, Allocator>::size_type n =
basic_string<charT, traits, Allocator>::npos)
Działanie: Tworzy obiekt klasy bitset<N> zainicjalizowany wartościami
przekazanymi jako obiekt klasy string (jakkolwiek „magicznie” to wygląda)
Parametry:
str — obiekt klasy string używany do inicjalizacji
pos — początkowa pozycja, od której pobierane są bity do inicjalizacji
n — maksymalna liczba bitów, które mają być użyte do inicjalizacji
Złożoność: O(M), gdzie M = min(N, str.size() - pos)
Zgłaszane wyjątki:
invalid_argument — któryś ze znaków inicjalizujących miał wartość różną od 0 i 1
out_of_range — pos > str.size()
2008–10–23
63 / 84
Kontener bitset — operatory
bitset<N>& operator&=(const bitset<N>& rhs)
Działanie: Iloczyn bitowy dwóch kontenerów bitset (zmieniana jest zawartość
bieżącego kontenera)
Parametr:
rhs — kontener, z którym wykonywany jest iloczyn bitowy kontenera bieżącego
Zwracana wartość: referencja do bieżącego obiektu
Złożoność: O(N)
Podobne operatory
bitset<N>& operator|=(const bitset<N>& rhs) — suma logiczna
bitset<N>& operator^=(const bitset<N>& rhs) — różnica symetryczna
2008–10–23
64 / 84
bitset<N>& operator<<=(size_t pos)
Działanie: Przesuwa w lewo bity bieżącego kontenera o pos pozycji
Parametr:
pos — liczba bitów do przesunięcia
Złożoność: O(N)
Uwaga: pos bitów z prawej strony otrzymuje wartość 0
Podobny operator
bitset<N>& operator>>=(size_t pos)
2008–10–23
65 / 84
bitset<N>& set()
Działanie: Ustawia wartość wszystkich bitów na 1
Parametry: brak
Złożoność: O(N)
bitset<N>& set(size_t pos, bool val=true)
Działanie: Ustawia wartość bitu na pozycji pos na val
Parametry:
pos — pozycja bitu
val — nowa wartość bitu
Złożoność: O(1)
2008–10–23
66 / 84
Kontener bitset — przykład
Przykład
# include < bitset >
{
bitset <10 > bs10 ;
cout << bs10 << endl ;
// 0000000000
bitset <14 > bs14 (0 xFFA9 );
// 11111110101001
bitset <20 > bs20 ( string ( " 101001011001 " ));
// 0 0 0 0 0 0 0 0 1 0 1 0 0 1 0 1 1 0 0 1
// bs10 &= bs14 ;
bs10 ^= bs10 ;
// 0000000000
// Błąd kompilacji !
bs14 < <= 2;
// 11111010100100
bs20 . set ();
// 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
bs10 . set (3);
// 0000001000
}
2008–10–23
67 / 84
Kontener bitset — metody
bitset<N>& reset()
Działanie: Ustawia wartość wszystkich bitów na 0
Parametry: brak
Złożoność: O(N)
bitset<N>& reset(size_t pos)
Działanie: Ustawia wartość bitu na pozycji pos na 0
Parametr:
Złożoność: O(1)
2008–10–23
68 / 84
bitset<N> operator~() const
Działanie: Zwraca obiekt będący kopią bieżącego obiektu, w którym wszystkie bity
są zanegowane
Parametry: brak
Zwracana wartość: Kopia bieżącego obiektu, w którym wszystkie bity są zanegowane
Złożoność: O(N)
2008–10–23
69 / 84
Kontener bitset — negowanie bitów
bitset<N>& flip()
Działanie: Neguje wartości wszystkich bitów w kontenerze
Parametry: brak
Złożoność: O(N)
bitset<N>& flip(size_t pos)
Działanie: Neguje wartość bitu na pozycji pos
Parametr:
pos — pozycja bitu do zanegowania
Złożoność: O(1)
2008–10–23
70 / 84
Kontener bitset — konwersja
unsigned long to_ulong() const
Działanie: Konwertuje zawartość kontenera na typ unsigned long
Parametry: brak
Zwracana wartość: Wartość typu unsigned long zawierająca na kolejnych pozycjach
wartości bitów z kontenera bitset
Złożoność: O(1)
Uwaga: Jeśli rozmiar kontenera jest większy niż sizeof(unsigned long) to
generowany jest wyjątek overflow_error
2008–10–23
71 / 84
Kontener bitset — konwersja
basic_string<charT, traits, Allocator> to_string() const
basic_string <charT, traits, allocator<charT> >to_string() const
basic_string <charT, char_traits<charT>, allocator <charT> > to_string()
const
basic_string <char, char_traits<char>, allocator <char> > to_string() const
Działanie: Tworzy obiekt klasy string zawierający na kolejnych znakach wartości 0
bądź 1 odpowiadające wartościom bitów
Parametry: brak
Zwracana wartość: Obiekt klasy string reprezentujący wartości bitów z kontenera
Złożoność: O(N)
Uwaga: Pierwszy bit obiektu klasy string odpowiada najstarszemu bitowi kontenera
2008–10–23
72 / 84
Kontener bitset — inne metody
size_t count() const
Działanie: Zwraca liczbę ustawionych bitów w kontenerze
Parametry: brak
Zwracana wartość: Liczba ustawionych bitów
Złożoność: O(N)
size_t size() const
Działanie: Zwraca rozmiar kontenera
Parametry: brak
Zwracana wartość: N
Złożoność: O(1)
2008–10–23
73 / 84
Kontener bitset — operatory porównań
bool operator==(const bitset<N>& rhs) const
Działanie: Porównuje dwa obiekty klasy bitset<N>
Parametr:
rhs — kontener do porównania
Zwracana wartość: true jeśli obiekty są identyczne
Złożoność: O(N)
bool operator!=(const bitset<N>& rhs) const
Działanie: Porównuje dwa obiekty klasy bitset<N>
Parametr:
rhs — kontener do porównania
Zwracana wartość: true jeśli obiekty nie są identyczne
Złożoność: O(N)
2008–10–23
74 / 84
Kontener bitset — testowanie bitów
bool test(size_t pos) const
Działanie: Sprawdza wartość bitu pos
Parametr:
pos — numer bitu do sprawdzenia
Zwracana wartość: true jeśli bit jest ustawiony
Złożoność: O(1)
Uwaga: Jeśli pos nie jest prawidłowym numerem pozycji to generuje wyjątek
out_of_range
2008–10–23
75 / 84
Kontener bitset — testowanie bitów
bool any() const
Działanie: Sprawdza czy jakikolwiek bit jest ustawiony
Parametry: brak
Zwracana wartość: true jeśli jakikolwiek bit kontenera jest ustawiony
Złożoność: O(N), choć może być nawet O(1) dla niektórych implementacji
bool none() const
Działanie: Sprawdza czy żaden bit nie jest ustawiony
Parametry: brak
Zwracana wartość: true jeśli żaden bit kontenera nie jest ustawiony
Złożoność: O(N), choć może być nawet O(1) dla niektórych implementacji
2008–10–23
76 / 84
Kkontener bitset — operatory przesunięć bitowych
bitset<N> operator<<(size_t pos) const
Działanie: Zwraca obiekt będący kopią obiektu bieżącego przesuniętą o pos bitów
w lewo
Parametr:
pos — przesunięcie
Zwracana wartość: Kopia obiektu bieżącego przesunięta w lewo o pos bitów
Złożoność: O(N)
bitset<N> operator>>(size_t pos) const
Działanie: Zwraca obiekt będący kopią obiektu bieżącego przesuniętą o pos bitów
w prawo
Parametr:
pos — przesunięcie
Zwracana wartość: Kopia obiektu bieżącego przesunięta w prawo o pos bitów
Złożoność: O(N)
2008–10–23
77 / 84
Kontener bitset — operatory indeksowania
bool operator[](size_t pos) const
Działanie: Zwraca wartość bitu na pozycji pos
Parametr:
Zwracana wartość: true jeśli bit jest ustawiony
Złożoność: O(1)
Uwaga: Jeśli pos jest niepoprawne to zachowanie niezdefiniowane
bitset<N>::reference operator[](size_t pos)
Działanie: Zwraca obiekt typu bitset<N>::reference taki, że:
(*this)[pos] == this->test(pos)
(*this)[pos ] = val jest równoważne this->set(pos, val)
Parametr:
Zwracana wartość: Obiekt typu bitset<N>::reference
Złożoność: O(1)
Uwaga: Jeśli pos jest niepoprawne to zachowanie niezdefiniowane
2008–10–23
78 / 84
Kontener bitset — dostęp do bitów przez operator[]
Metody
reference& operator=(bool x) — umożliwia przypisania b[i] = x
reference& operator=(const reference&) — umożliwia przypisania
b[i] = b[j]
bool operator~() const — umożliwia zanegowanie bitu: a = ~b[i]
operator bool() const — umożliwia automatyczną konwersję do typu bool:
x = b[i]
reference& flip() — umożliwia negowanie bitu: b[i].flip()
2008–10–23
79 / 84
Kontener bitset — operatory bitowe
bitset<N> operator&(const bitset<N>& lhs, const bitset<N>& rhs)
Działanie: Zwraca obiekt klasy bitset<N> będący iloczynem bitowym lhs i rhs
Parametry:
lhs, rhs — obiekty, na których wykonywany jest iloczyn bitowy
Zwracana wartość: Obiekt klasy bitset<N> zawierający iloczyn bitowy
Złożoność: O(N)
Podobne operatory
bitset<N> operator|(const bitset<N>& lhs, const bitset <N>& rhs) — zwraca
sumę logiczną
bitset<N> operator^(const bitset<N>& lhs, const bitset <N>& rhs) — zwraca
różnicę symetryczną
2008–10–23
80 / 84
Kontener bitset — operatory strumieniowe
template <class charT, class traits, size_t N>
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is, bitset<N>& x)
Działanie: Wczytuje ze strumienia wejściowego nie więcej niż N bitów do kontenera
Parametry:
is — strumień wejściowy
x — obiekt klasy bitset<N>
Zwracana wartość: referencja do obiektu strumienia wejściowego
Złożoność: O(N)
Uwaga: Wczytywanie bitów kończy się jeśli zajdzie dowolny z warunków:
wczytano N bitów
napotkano znak EOF w strumieniu
następny znak w strumieniu jest różny od 0 i 1
2008–10–23
81 / 84
Kontener bitset — operatory strumieniowe
template <class charT, class traits, size_t N>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x)
Działanie: Wypisuje bity z kontenera w postaci łańcucha znakowego do strumienia
wyjściowego
Parametry:
os — strumień wyjściowy
x — kontener bitset<N>
Zwracana wartość: referencja do obiektu strumienia wyjściowego
Złożoność: O(N)
2008–10–23
82 / 84
Kontener bitset — przykład
Przykład
# include < bitset >
{
bitset <16 > bs (0 xF1F1 );
cout << bs << endl ;
cout << ~ bs << endl ;
// 1111000111110001
// 0000 111000001110
bs [4]. flip ();
bs [5] = 0;
bs [4] = bs [0];
cout << bs . count () << endl ;
// 1111000111000001
// 1111000111010001
// 9
cout << ( bs ^ bitset <16 >( string ( " 10010010 " ))) << endl ; // 1111 000101000011
}
2008–10–23
83 / 84
Co będzie za tydzień?
Poznamy kolejne kontenery asocjacyjne (map, multimap)
Dowiemy się jeszcze więcej o iteratorach
Poznamy też kolejne algorytmy
2008–10–23
84 / 84

Kontenery, algorytmy - Politechnika Śląska

Transkrypt

Podobne dokumenty

SPECYFIKACJA KONTENERÓW TYPU „FLAT RACK” 40`FT

SIWZ - Zapytanie 1

Kontener KOMBI Mały

kontener i wóz asenizacyjny

KONTENER NA KÓŁKACH - typ 1 załącznik nr 10

st-psp-ref-260916

Kontener Chłodnia dzięki dużej powierzchni chłodniczej zapewnia

KATEGORIA do lat 15 - Urząd Miasta Jastrzębie