Programovanie 3.

Transkript

Programovanie 3.

Programovanie 3.
2012 – 2013
11. Prednáška
STL – II.
Ing. František Gyárfáš, PhD.
Katedra aplikovanej informatiky
[email protected]
http://www.ii.fmph.uniba.sk/~gyarfas/
Ako programovať reálny svet?
Ako to dátovo reprezentovať?
class PESNICKA {
string nazov;
string textPlusAkordy;
};
Výhody:
Jednoduchá a jasná reprezentácia.
Nevýhody:
Nutnosť analyzovať pri každom čítaní.
Predspracovanie:
Oddelenie akordov od textu
Vložíme do textu oddeľovače:
$-akord, #-fraza
Ami$Spatřil jsem kometu, oblohou letěla,#
chtěl jsem ji zaspívat, ona mi zmizela#
Dmi$zmizela jako laň #G7$u lesa v remízku#
C$v očích mi zbylo jen #E7$pár žlutých penízkú.#
Ami$Penízky ukryl jsem do hlíny pod dubem,#
až příště přiletí, my už tu nebudem,#
Dmi$my už tu nebudem, #G7$ach, pýcho marnivá#
spatřil jsem kometu, chtěl jsem jí zaspívat.#
Ami$O vodě, o trávě, #Dmi$o lese,#
G7$o smrti, se kterou smířit #C$nejde se,#
Ami$o lásce, o zradě, #Dmi$o světe#
E$a o všech lidech, co kdy #E7$žili na téhle#Ami$planetě.#
Ami$Na hvězdném nádraží cinkají vagóny,#
pan Kepler rozepsal nebeské zákony#
Dmi$hledal, až nalezl #G7$v hvězdářských triedrech#
C$tajemství, která teď #E7$neseme na bedrech.#
Ukladanie po riadkoch
class PESNICKA {
string nazov;
string riadky[100];
};
Zlepšenie:
Ideálne pre načítavanie. (getline)
Problémy:
Nebezpečná manipulácia s polom.
Náhrada poľa – čím?
class PESNICKA {
string nazov;
vector<string> riadky;
};
Zlepšenie:
Nehrozí pretečenie.
Problémy:
Nutnosť analyzovať pri každom čítaní.
Ukladanie po frázach
class PESNICKA {
string nazov;
vector<string> frazy;
};
Zlepšenie:
Zjednodušené čítanie.
Problémy:
Nutnosť oddeľovať akordy od textu pri čítaní.
Oddelenie akordov od textu
class PESNICKA {
string nazov;
vector<string> akordy;
vector<string> texty;
};
Zlepšenie:
Oddelenie akordov od textu sa vykoná iba raz.
Problémy:
Ak verš nemá akord, mám problém.
Spojenie akordov s textami
class FRAZA {
string text;
string akord;
};
class PESNICKA {
string nazov;
vector<FRAZA> frazy;
};
Zlepšenie:
Akordy s textami sú bezpečne spárované.
Problémy:
Chýba informácia o riadkoch.
Verše a frázy
class FRAZA {
string text;
string akord;
};
class VERS {
};
class PESNICKA {
string nazov;
vector<VERS> verse;
};
Zlepšenie:
Dátová štruktúra odráža štruktúru textu.
Problémy:
Neviem, aký zoznam akordov pieseň obsahuje.
Pridanie zoznamu akordov
Zlepšenie:
Samostatný zoznam akordov.
class FRAZA {
string text;
string akord;
};
class VERS {
};
class PESNICKA {
string nazov;
vector<VERS> verse;
vector<string> akordy;
};
Problémy:
Zoznam akordov môže obsahuje duplikáty.
Zoznam akordov nie je utriedený.
Potrebujem:
Zoznam, ktorý nepovoľuje duplikáty.
Zoznam, ktorý sa automaticky usporiadava.
Sekvenčné kontajnery a adaptéry
Zoznam, ktorý nepovoľuje duplikáty.
Zoznam, ktorý sa automaticky usporiadava.
vector – je lineárna sekvencia objektov.
deque – je to fronta s dvoma koncami.
list – je to obojstranný zreťazený zoznam.
Adaptér stack sa správa ako zásobník LIFO (last in, first out).
Adaptér queue sa správa ako fronta FIFO (first in, first out).
Adaptér priority_queue sa správa ako usporiadaný zásobník.
Môžem použiť priority_queue?
class FRAZA {
string text;
string akord;
};
class VERS {
};
class PESNICKA {
string nazov;
vector<VERS> verse;
priority_queue<string> akordy;
};
Zlepšenie:
Usporiadaný zoznam akordov.
Problémy:
Dostanem sa iba k vrchnému akordu.
Asociatívne kontajnery
Asociatívne kontajnery – používajú kľúče a umožňujú ich prostredníctvom
rýchly prístup k jednotlivým položkám.
•
set – kľúč je samotná hodnota. Obsahuje max. 1 prvok tej istej hodnoty.
•
multiset – kľúč je samotná hodnota. Môže obsahovať viacero
prvkov tej istej hodnoty.
•
map – obsahuje dvojice hodnôt: unikátny kľúč a hodnota. Obsahuje
max. 1 prvok s tým istým kľúčom .
•
multimap – obsahuje dvojice hodnôt. Umožňuje viac hodnôt s tým
istým kľúčom.
Položky v asociatívnych kontajneroch sú usporiadané, preto je vždy
definovaný spôsob usporiadania, ktorý si vyžaduje porovnávaciu funkciu
(predikát).
Zoznam akordov ako množina
class FRAZA {
string text;
string akord;
};
class VERS {
};
class PESNICKA {
string nazov;
vector<VERS> verse;
set<string> akordy;
};
Zlepšenie:
Množina set akordov nepovoľuje duplikáty.
Množina set sa automaticky usporiadava.
Problémy:
???
Ako vytvoriť spevník ?
Spevník by mal obsahovať zoznam pesničiek a množinu akordov, ktoré je potrebné
ovládať na zahranie všetkých pesničiek v spevníku.
class SPEVNIK {
vector<PESNICKA> zoznam;
set<string> akordy;
};
Problémy:
Náročné vyhľadávanie pesničiek.
Chýba ochrana pred duplikátmi pesničiek.
Čo si vybrať pre pesničky?
class SPEVNIK {
vector<PESNICKA> zoznam;
set<string> akordy;
};
set – kľúč je samotná hodnota. Obsahuje max. 1 prvok tej istej hodnoty.
multiset – kľúč je samotná hodnota. Môže obsahovať viacero prvkov tej
istej hodnoty.
map – obsahuje dvojice hodnôt: unikátny kľúč a hodnota. Obsahuje max. 1
prvok s tým istým kľúčom .
multimap – obsahuje dvojice hodnôt. Umožňuje viac hodnôt s tým istým
kľúčom.
Mapa pesničiek
class SPEVNIK {
map<string, PESNICKA> spevnik;
set<string> akordy;
};
Problémy:
Nie je možné mať dve rôzne piesne s rovnakým názvom.
class SPEVNIK {
multimap<string, PESNICKA> spevnik;
set<string> akordy;
};
Asociatívne kontajnery
Asociatívne kontajnery – používajú kľúče a umožňujú ich prostredníctvom
rýchly prístup k jednotlivým položkám.
Položky v asociatívnych kontajneroch sú usporiadané, preto je vždy
definovaný spôsob usporiadania, ktorý si vyžaduje porovnávaciu funkciu
(predikát).
Asociatívny kontajner set
Syntax:
template <class Kluc, class Predikat>
kľúč
class set ;
Samotná trieda
usporiadanie
Preddefinovaný predikát:
template <class Key, class Compare = less<Key> >
class set;
Konštruktory kontajnera set
set<type, predicate> name;
Vytvorí prázdnu množinu set.
set<type, predicate>
name(sourceSet);
Vytvorí kópiu množiny sourceSet.
set<type, predicate>
name(prvy,
posl);
Skopíruje elementy zdrojovej množiny od
iterátora prvy po iterátor posl.
Vkladanie položiek do množiny
Metóda insert vkladá novú hodnotu do množiny na miesto určené predikátom.
intSet.insert(10);
V prípade existencie položky s danou hodnotou insert novú položku ignoruje.
intSet.insert(10);
intSet.insert(10);
Návratová hodnota insert
Metóda insert vracia dvojicu pair< set<int>::iterator, bool >.
Druhá položka (second) vracia true, ak bol vložený nový prvok a false, ak už sa
daný prvok v množine nachádza.
Prvá položka (first) je iterátor na nový prvok, príp. iterátor na už existujúci
prvok s danou hodnotou.
#include <iostream>
#include <set>
using namespace std;
int main () {
set<int> myset;
set<int>::iterator it;
pair< set<int>::iterator, bool > ret;
ret = myset.insert(10);
string vlozenie = (ret.second == true) ? "Prve = " : "Druhe = ";
cout << vlozenie << *ret.first << endl;
ret = myset.insert(10);
it = ret.first;
vlozenie = (ret.second == true) ? "Prve = " : "Druhe = ";
cout << vlozenie << *it << endl;
}
Predikát
template<class T> class mensi{
public:
bool operator()(T x, T y) {
return x < y;
}
};
int main(){
set<int, mensi<int> > intSet;
intSet.insert(10);
intSet.insert(15);
intSet.insert(0);
intSet.insert(30);
intSet.insert(10);
intSet.insert(60);
set<int, mensi<int> >::iterator it;
template<class T> class vacsi{
public:
return x > y;
}
};
int main(){
set<int, vacsi<int> > intSet;
intSet.insert(10);
intSet.insert(15);
intSet.insert(0);
intSet.insert(30);
intSet.insert(10);
intSet.insert(60);
set<int, vacsi<int> >::iterator it;
for (it = intSet.begin()
; it!=intSet.end(); it++){
cout << *it << " ";
}
cout << *it << " ";
}
}
}
Hádanka: aký predikát pre LIFO
template<class T> class LIFO{
public:
return ???????????;
}
};
int main(){
set<int, LIFO<int> > intSet;
intSet.insert(10);
intSet.insert(15);
intSet.insert(0);
intSet.insert(30);
intSet.insert(10);
intSet.insert(60);
set<int, LIFO<int> >::iterator it;
cout << *it << " ";
}
}
Kontajner multiset
multiset –množina, ktorá môže obsahovať viac elementov s tou
istou hodnotou.
#include <iostream>
#include <set>
int main(){
multiset<char> multiSet;
multiSet.insert('A');
multiSet.insert('g');
multiSet.insert('0');
multiSet.insert('%');
multiSet.insert('w');
multiSet.insert('W');
multiset<char>::iterator iter;
cout << "Mnozina multiset: " << endl;
for (iter = multiSet.begin(); iter!=multiSet.end(); iter++){
cout << *iter << " ";
}
}
Mapy ako asociatívne polia
Normálne polia spájajú dve veličiny: index a objekt hodnoty.
Mapy sú asociatívne polia. Tiež spájajú dve veličiny: objekt kľúča a objekt
hodnoty. Mapy sú vždy usporiadané podľa predikátu usporiadania.
template <class Key, class Val, class Predikat = less<Key>
class
mapa;
kľúč
hodnota
usporiadanie
samotná trieda
Konštruktory kontajnera map
map<Kluc, Hod, predikat> name;
Prázdny kontajner map.
map<Kluc, Hod, predikat> name(source);
Kópia kontajnera source.
map<Kluc, Hod, predikat> name(prvy, posl);
Skopíruje elementy
zdrojového kontajnera od
iterátora prvy po iterátor
posl.
Iterátory do kontajnera map obsahujú dvojicu hodnôt (kľúč a hodnota) :
map<Kluc, Hod>::iterator iter;
Kluc k = (*iter).first;
Hod
h = iter->second;
//
iter->first
// (*iter).second
Vkladanie do mapy s insert
Do mapy vkladáme nový objekt pomocou metódy insert.
charMap.insert(pair<int, char>(6,'V'));
Metóda insert má jeden vstupný parameter:
pair<kluc,hodnota>()
alebo
map<kluc,hodnota>::value_type()
Návratová hodnota insert
Metóda insert vracia objekt, obsahujúci dvojicu hodnôt: iterátor
ukazujúci na vloženú položku a informáciu, či bol objekt vložený.
pair< map<kluc,hodnota>::iterator, bool >
pair<map<int,char>::iterator, bool> ret;
ret = charMap.insert(pair<int, char>(6,'V'));
ret = charMap.insert(map<int, char>::value_type(6,'V'));
Ak mapa už obsahuje položku s daným kľúčom, insert novú hodnotu
nevloží, vráti iterátor na už existujúci prvok s daným kľúčom a false.
map - operator[]
Asociatívny kontajner map má definovaný operator[].
Parameter tohto operátora je kľúč.
mnozina[3]
Ak element s daným kľúčom sa v kontajneri už nachádza, operátor vracia
referenciu na tento element.
Ak hodnota s daným kľúčom už existuje, táto hodnota sa prepíše.
mnozina[3] = 'A';
Ak hodnota s daným kľúčom ešte neexistuje, do kontajnera sa vloží nový
element s danými hodnotami.
mnozina[3] = 'B';
Kontajner multimap
multimap – je mapa, ktorá môže obsahovať viac elementov s rovnakým kľúčom.
#include <iostream>
#include <map>
const int MAX = 6;
int main() {
multimap<int, char> charMap;
charMap.insert(multimap<int, char>::value_type(1,'A'));
charMap.insert(multimap<int, char>::value_type(2,'X'));
charMap.insert(multimap<int, char>::value_type(1,'Y'));
charMap.insert(multimap<int, char>::value_type(2,'B'));
multimap<int, char>::iterator iter;
for (unsigned int i = 0; i < MAX; i++){
iter = charMap.find(i);
if (iter == charMap.end()){
cout << "Polozka " <first == i) {
cout << "Polozka s klucom " <second << endl;
iter++;
}
}
}
}
Algoritmy pre kontajnery
U algoritmov hovoríme transformuj namiesto vykonaj pre všetky prvky
v definovanom rozsahu.
Algoritmy zvyšujú objektovosť programovania.
Algoritmy zvyčajne očakávajú iterátory ukazujúce na prvý a posledný
prvok spracovávaného úseku kontajnera.
Šanca, že algoritmus je naprogramovaný správne a neobsahuje chyby, je
podstatne vyššia, ako u priameho použitia cyklov for, while a pod.
Pravidlo rozumného sebapodceňovania
Bezpečné programovanie
Uprednostňujte
volanie algoritmov
je krásny pred
sen. písaním vlastných cyklov.
Generické algoritmy
Nemodifikujúce algoritmy
Meniace algoritmy
Odstraňujúce algoritmy
Usporadúvajúce algoritmy
Numerické algoritmy
Všetky algoritmy sa nachádzajú v namespace std a ich hlavičky sa
nachádzajú v:
#include <algorithm>
Nemodifikujúce algoritmy
int count(first, last, val);
int count_if(first, last, pred);
Spočíta výskyt vyhovujúcich elementov
od iterátora first po last podľa
hodnoty alebo predikátu.
Ďalšie algoritmy vracajú iterátor prvého nájdeného elementu podľa zvoleného
kritéria:
iter = find_if(first,last,pred);
Vráti iterátor na prvý element s hodnotou
val alebo podľa predikátu pred medzi
iterátormi first a last.
iter = min(first, last);
iter = max(first, last);
Vráti iterátor na najmenší (min) alebo
najväčší (max) element.
iter = find(first, last, val);
Vykoná funkciu pre každý element:
for_each(first, last, func);
Zbehne funkciu func nad všetkými
elementami medzi iterátormi first a
last. Nemení hodnoty kontajnera.
Meniace algoritmy
fill(first, last, val);
Vloží hodnotou val od first po
last.
fill_n(first, n, val);
Vloží hodnotou val do n prvkov
počínajúc first.
generate(first, last, gen);
Vloží hodnotou od first po last
generovanú funkciou gen.
generate_n(first, n, gen);
Vloží hodnotou do n prvkov počínajúc
first generovanú funkciou gen.
copy(first, last, target);
Skopíruje hodnoty od iterátora first po
last do novej pozície od iterátora
target. Iterátor target môže byť v
tom istom kontajneri, alebo aj v inom.
Meniace algoritmy II.
replace(first,last,val1,val2);
Nahradí hodnotu val1 s val2
reverse(first, second);
Vymení hodnoty
random_shuffle(first, second);
Náhodne prehádže hodnoty
Odstraňujúce algoritmy
remove(first, last, val);
Odstráni elementy s hodnotou val, ale
nezmenší kontajner.
remove_if(first, last, pred);
Odstráni elementy vyhovujúce predikátu
pred, ale nezmenší kontajner.
remove_copy(first, last,
target, val);
Skopíruje obsah s odstránením kópií
elementu s val, ale nezmenší kontajner.
remove_copy_if(first, last,
target, pred);
Odstráni kópie elementu vyhovujúce
predikátu pred, ale nezmenší kontajner.
Všetky algoritmy remove_X vracajú iterátor na nový posledný prvok.
new_last= remove(first,last,val);
new_last je iterátor ukazujúci za nový
posledný prvok
Úplné odstránenie položiek
Je možné privolať metódu kontajnerov erase, ktorá úplne odstráni prvky
odstránené algoritmom remove a zmení veľkosť kontajnera.
vector<int>::iterator last_iter;
last_iter = remove(vect.begin(), vect.end(), 10);
vect.erase(last_iter, vect.end());
vect.erase(remove(vect.begin(), vect.end(), 10), vect.end());
Usporadúvajúce algoritmy
sort(first, last);
Usporiada podľa hodnôt.
sort(first,last,greater<int>())
Usporiada s explicitným predikátom.
nth_element(first, n_ty, last);
Všetky pred n_ty sú menšie ako n_ty a
ostatné väčšie alebo rovne.
partial_sort(first, n_ty,last);
Usporiada toľko elementov, koľko sa ich
zmestí po n_ty element.
merge(first1, last1, first2,
last2, result);
Spojí dva usporiadané kontajnery do
usporiadaného kontajneru result.
Väčšina usporadúvajúcich algoritmov má aj verziu s predikátom.
Numerické algoritmy
#include <numeric>
accumulate(first,last,result);
Pripočíta do hodnoty result hodnoty
prvkov od first po last.
accumulate(first,last,result,
f);
Pripočíta do hodnoty result hodnoty
funkcie f aplikovanej od first po last.
partial_sum(first,last,vystup);
Vkladá do kontajnera vystup postupné
sumy.
adjacent_difference(first,last,
vystup);
Vkladá do kontajnera vystup rozdiely
susedných hodnôt, pričom prvá hodnota sa
nemení.
Skúška
Podmienka pripustenia ku skúške:
•
Úspešné získanie min. 80 bodov z cvičení (do termínu skúšky). Po
vykonaní úspešnej skúšky už nie je dovolené odovzdávať cvičenia.
Úspešné spravenie skúšky:
•
Úspešné vyriešenie písomnej skúšky (min. 60 % úspešných testov)
•
Úspešné okamžité ústne obhájenie písomky
•
Odovzdanie a ohodnotenie semestrálneho projektu. Projekt je dovolené
odovzdať aj po úspešnej skúške (do 23.1.2010).
Hodnotenie na skúške
Skúška sa koná vo forme písomnej skúšky za počítačom. Obsahom skúšky je
vypracovanie riešenia zadanej úlohy. Forma zadania je podobná forme, akou
boli zadané všetky úlohy na cvičeniach. Rozdiel bude v tom, že súčasťou
zadanie nebude návod na riešenie úlohy.
Minimum na úspešné zvládnutie skúšky bude úspešné zvládnutie 60 %
všetkých testov z úlohy (tri skupiny testov). Pri dosiahnutí menej ako 60 %
úspešných testov je skúška neúspešná.
Termíny skúšok
Termíny skúšok budú počas skúšobného obdoba vždy v stredu popoludní od
13.00. Prihlasovanie sa na skúšku sa bude diať na stránke predmetu a počet
účastníkov skúšky bude cca. 25 študentov.
Má niekto záujem o vypísanie predtermínu na 19.12.2012 o 13.00?
Kontajner set - príklad
#include <iostream>
#include <set>
int main(){
set<int> intSet;
intSet.insert(10);
intSet.insert(15);
intSet.insert(0);
intSet.insert(30);
intSet.insert(10);
intSet.insert(60);
set<int>::iterator iter;
cout << "Prvky mnoziny: " << endl;
for (iter=intSet.begin(); iter!=intSet.end(); iter++){
cout << *iter << endl;
}
getchar();
}
Usporiadanie podľa vloženia
#include <iostream>
#include <set>
template<class T> class Porovnaj{
public:
return false;
}
};
int main(){
multiset<char, Porovnaj<char> > multiSet;
multiSet.insert('g');
multiSet.insert('&');
multiSet.insert('W');
multiSet.insert('&');
multiset<char, Porovnaj<char> >::iterator iter;
cout << "Prvky mnoziny multiset: " << endl;
for (iter = multiSet.begin(); iter!=multiSet.end(); iter++){
cout << *iter << endl;
}
getchar();
}
Príklad na insert
#include <iostream>
#include <map>
void vypis(pair<map<char,int>::iterator,bool> ret){
if (ret.second) {
cout << "Vlozil hodnotu " << ret.first->second;
cout << " s klucom " << ret.first->first << endl;
}
else {
cout << "Hodnota " << ret.first->second;
cout << " sa uz nachadza s klucom " << ret.first->first << endl;
}
}
int main () {
map<char,int> mapa;
pair<map<char,int>::iterator,bool> ret;
ret = mapa.insert(pair<char, int>('a', 10) );
vypis(ret);
ret = mapa.insert(pair<char, int>('b', 20) );
vypis(ret);
ret = mapa.insert(pair<char, int>('b', 40) );
vypis(ret);
ret = mapa.insert(pair<char,int>('a', 30) );
vypis(ret);
getchar();
}
Pozor na operator[]
#include <iostream>
#include <map>
int main() {
map<int, string> mapa;
mapa.insert(pair<int, string>(0, "prva"));
mapa.insert(pair<int, string>(2, "druha"));
mapa.insert(pair<int, string>(4, "tretia"));
cout << "Velkost mapy = " << mapa.size() << endl;
map<int, string>::iterator iter;
for (iter = mapa.begin(); iter != mapa.end(); iter++) {
cout << " [" << iter->first << "] = " << iter->second;
cout << endl;
}
cout << endl << "Velkost mapy = " << mapa.size() << endl;
unsigned int SIZE = mapa.size();
for (unsigned int i = 0; i < SIZE; i++){
cout << " [" <first << "] = " << iter->second;
cout << endl;
}
getchar();
}
Príklad používania mapy
#include <iostream>
#include <map>
int main() {
map<string, int> charMap;
charMap["prva"] = 1;
charMap["druha"] = 2;
charMap.insert(map<string, int>::value_type("prva", 11));
charMap["druha"] = 22;
charMap["druha"]++;
cout << "Obsah mapy: " << endl;
map<string, int>::iterator iter;
for (iter = charMap.begin(); iter != charMap.end(); iter++) {
cout << iter->first << " --> ";
cout << iter->second << endl;
}
getchar();
}
V akom pôjdu poradí?
Aké budú mať hodnoty?
Kontajner multimap
multimap – je mapa, ktorá môže obsahovať viac elementov s rovnakým kľúčom.
#include <iostream>
#include <map>
const int MAX = 6;
int main() {
multimap<int, char> charMap;
charMap.insert(multimap<int, char>::value_type(1,'A'));
charMap.insert(multimap<int, char>::value_type(1,'Y'));
multimap<int, char>::iterator iter;
for (unsigned int i = 0; i < MAX; i++){
iter = charMap.find(i);
if (iter == charMap.end()){
cout << "Polozka " <first == i) {
cout << "Polozka s klucom " <second << endl;
iter++;
}
}
}
getchar();
}
Príklad: count,find,for_each
#include <iostream>
#include <set>
template<class T> void vypis(T iter){
cout << iter << " ";
}
const int MAX = 5;
int main(){
multiset<int> kopa;
for(unsigned int i = 0; i < MAX; i++){
kopa.insert(i * 10);
kopa.insert(i * 20);
}
for_each(kopa.begin(), kopa.end(), vypis<int>);
cout << endl<< "Pocet = 0: " << count(kopa.begin(), kopa.end(), 0) << endl;
cout << "Pocet = 30: " << count(kopa.begin(), kopa.end(), 30) << endl;
cout << "Pocet < 30: "
<< count_if(kopa.begin(), kopa.end(), bind2nd(less<int>(),30)) << endl;
set<int>::iterator iter;
iter = find(kopa.begin(), kopa.end(), 30);
cout << "Dalsi element za 30:" << *(++iter) << endl;
iter = find_if(kopa.begin(), kopa.end(), bind2nd(greater<int>(),50));
cout << "Element > 50:" << *iter << endl;
cout << "Dalsi element za > 50:" << *(++iter) << endl;
getchar();
}
Príklad meniacich algoritmov
#include <iostream>
#include <set>
const int MAX = 5;
}
int main(){
multiset<int> kopa;
for(unsigned int i = 0; i < MAX; i++){
kopa.insert(0);
}
multiset<int> kopa2(kopa);
fill(kopa.begin(), kopa.end(), 1);
cout << endl;
fill_n(kopa.begin(), 3, 2);
cout << endl;
generate(kopa.begin(), kopa.end(), std::rand);
cout << endl;
copy(kopa.begin(), kopa.end(), kopa2.begin());
for_each(kopa2.begin(), kopa2.end(), vypis<int>);
getchar();
}
Príklad meniacich algoritmov
#include <iostream>
#include <vector>
const int MAX = 10;
}
int nextI() {
static int element = -5;
return element++;
}
int main() {
vector<int> vect(MAX, 0);
generate(vect.begin(), vect.end(), nextI);
cout << "Zoznam: ";
for_each(vect.begin(), vect.end(), vypis<int>);
reverse(vect.begin(), vect.end());
cout << endl << "Opacne: ";
cout << endl << "Nahoda: ";
random_shuffle(vect.begin(), vect.end());
getchar();
}
Príklad odstraňovania
#include <iostream>
#include <vector>
const int MAX = 8;
}
int main () {
int myints[] = {10,20,30,30,20,10,40,20};
vector<int> vystup(MAX);
remove(myints, myints + MAX, 30);
vector<int>::iterator it;
remove_copy(myints, myints + MAX, vystup.begin(), 20);
cout << "Vystup obsahuje: " << endl;
for (it = vystup.begin(); it != vystup.end(); ++it) {
cout << *it << " ";
}
getchar();
}
Príklad úplného odstránenia
#include <iostream>
#include <vector>
const int MAX = 5;
}
int main() {
vector<int> vect(MAX);
for(int i = 0; i < MAX; i++){
vect[i] = i;
}
cout << endl << endl;
vector<int>::iterator last_iter;
last_iter = remove(vect.begin(), vect.end(), 3);
for_each(vect.begin(), last_iter, vypis<int>);
vect.erase(last_iter, vect.end());
getchar();
}
Príklad pre usporiadania
#include <iostream>
#include <vector>
const int MAX = 10;
}
int main() {
vector<int> vect(MAX);
vect[i] = i;
}
cout << endl << "Nahoda: ";
cout << endl << "Po 5 mensie: ";
nth_element(vect.begin(), vect.begin() + 5, vect.end());
cout << endl << "Cast usporiadana: ";
partial_sort(vect.begin(), vect.begin() + 5, vect.end());
cout << endl << "Cele usporiadane: ";
sort(vect.begin(), vect.end());
getchar();
}
Príklad pre spájanie
#include <iostream>
#include <vector>
const int MAX = 10;
}
int main() {
vector<int> vect(MAX), vect2(MAX), vystup(MAX*2);
vect[i] = i * 2; vect2[i] = i * 2 + 1;
}
cout << "Prvy: ";
cout << endl << "Druhy: ";
for_each(vect2.begin(), vect2.end(), vypis<int>);
merge(vect.begin(), vect.end(), vect2.begin(), vect2.end(),vystup.begin());
cout << endl << "Spolu: ";
for_each(vystup.begin(), vystup.end(), vypis<int>);
cout << endl << "Mix: ";
merge(vect.begin(), vect.end(), vect2.begin(), vect2.end(),vystup.begin());
cout << endl << "Spolu: ";
getchar();
}
Príklad pre numerické algoritmy
#include <iostream>
#include <vector>
#include <numeric>
const int MAX = 10;
}
int main() {
vector<int> vect(MAX), vystup(MAX);
vect[i] = i;
}
cout << "Zoznam: ";
int suma = accumulate(vect.begin(), vect.end(), 0);
cout << endl << "Suma: " << suma;
partial_sum(vect.begin(), vect.end(), vystup.begin());
cout << endl << "Ciastocne sumy: ";
adjacent_difference(vect.begin(), vect.end(), vystup.begin());
cout << endl << "Rozdiely: ";
getchar();
}

Programovanie 3.

Transkript

Podobné dokumenty

INDUSTRIÁLNE KULTY

03 Exaktni metody a heuristika

Rozhranní člověk vs. stroj - jeden za všechny, všichni za

Studijní opora pro OOM

multiset vrf, dc inverter r410a

Pro pokročilé - Industry Online Support

Assembly a jazyková interoperabilita

Text bakalářské práce - Katedra geoinformatiky

1TX psani txt.docx

ZÁKLADY PROGRAMOVACÍHO JAZYKA TURBO PASCAL

BAKALÁŘSKÁ PRÁCE Tvorba geografického informačního

13 FormalniPřeklad

Správa LIDAR datových sad LIDAR data kompletně reprezentují

otevirani_zapis_soubory _3

13 FormalniPřeklad

Maxima, minima, suprema a infima