XIII. STL. Tároló Bejáró Algoritmus. XIII.1 A vector #include <vector> #include <vector> #include <algorithm> using namespace std;

Átírás

1 XIII. STL Tároló Bejáró Algoritmus #include <vector> #include <algorithm> using namespace std; vector<int> vect; // a vect adatainak megadása sort(vect.begin(),vect.end()); XIII.1 A vector #include <vector> 1

2 Konstruktorok (vector<tip>) vector<tip> vektor_0; // üres tip típusú vektor vector<tip> vektor_1 (db[,ertek]); // db elemű vektor ertek elemekkel vector<tip> vektor_2 (vektor.begin(), vektor.end()); // iterációs létrehozás //vektor-ból vector<tip> vektor_4 (vektor); // másoló konstruktor vektor-ból Bejárók (vector<tip>::iterator) begin() // kezdet end() // vég rbegin() // vissza kezdet rend() // vissza vég &v[0] // pointer a memóriára vector<tip>::iterator v; (*v) // maga a vektor elem, mintha pointer lenne Tulajdonságok operator[i], at(i) // az i. elem, at() ellenőriz is front() // az első elem referenciája back() // az utolsó elem referenciája Méretek size() // az elemek aktuális száma resize(n[,val]) // n-re méretez val [vagy default] elemmel feltöltve capacity() // a férőhelyek száma fit into the area // (automatikusan is nő) reserve(n) // a férőhelyek számának növelése n-re Módosítók push_back(val) // a val az utolsó elem mögé kerül pop_back() // törli az utolsó elemet és visszatér értékével iterator insert ( iterator position, const T& x ) // a pozícióba helyez nem hatékony Törlés bool empty ( ) const; // üres-e erase(iterator tol, iterator ig) // tol ig töröl 2

3 Keresések #include <algorithm> vector<tip>::iterator find(vector< tip>::iterator tol, vector< tip >::iterator ig, tip t); vector<int> vect(); // feltöltés vector<int>::iterator it; // iterator a vectorra it = find (vect.begin(), vect.end(), 2000); vector<tip>::iterator search(vector< tip>::iterator tol, vector< tip >::iterator ig, vector< tip>::iterator mitk, bool vector< tip >::iterator mitv); binary_search(vector< tip>::iterator tol, vector< tip >::iterator ig, tip ert) fvtip for_each(vector< tip>::iterator tol, vector< tip >::iterator ig, fvtip f) egyváltozós fv elem kijelölésere void myfunc (int i) { cout << " " << i; for_each (vect.begin(), vect.end(), myfunc); void sort(vector< tip>::iterator tol, vector< tip >::iterator ig [,fvtip f(a,b)]); f: összehasonlító (true, ha az első megelőzi a másodikat) ha nem természetes 3

4 #include <stdlib.h> #include <vector> #include <algorithm> #include <iostream> using namespace std; void myfunc (int i) { cout << " " << i; vector<int> vect(2); // 2 méretű vektor vect[0]=1; // a vect adatainak megadása 1 vect[1]=2000; for (int i=0; i<8; i++) // a vect adatainak megadása 2 vect.push_back(rand()); // a vect adatainak kiírása 1 vector<int>::iterator vit; for (vit=vect.begin(); vit!=vect.end(); vit++) cout<<*(vit)<<endl; cout<<endl; // a vect adatainak kiírása 2 for (int i=0; i<vect.size(); i++) cout<<vect[i]<<endl; sort(vect.begin(),vect.end()); cout<<endl; // a vect adatainak kiírása 3 for (int i=0; i<vect.size(); i++) cout<<vect[i]<<endl; // keresés vector<int>::iterator it; // iterator vectorra it = find (vect.begin(), vect.end(), 2000); cout<<"2000:"<<*(it)<<endl; // a vect adatainak kiírása 4 for_each (vect.begin(), vect.end(), myfunc); //

5 IV A deque #include <deque> Kétvégű sor. Nem folytonos adatterületen. Lassúbb mint a sor. Memóriamodell Konstruktorok (vector<tip>) deque<tip> dq_0; // üres tip típusú deque deque<tip> dq_1 (db[,ertek]); // db elemű deque ertek elemekkel deque<tip> dq_2 (deque.begin(), deque.end()); // iterációs létrehozás //deque-ból deque<tip> dq_4 (deque); // másoló konstruktor deque-ból Bejárók (vector<tip>::iterator) begin() // kezdet end() // vég rbegin() // vissza kezdet rend() // vissza vég &v[0] // pointer a memóriára deque<tip>::iterator v; (*v) // maga a deque elem, mintha pointer lenne Tulajdonságok operator[i], at(i) front() back() // az i. elem, at() ellenőriz is // az első elem referenciája // az utolsó elem referenciája 5

6 Méretek size() resize(n[,val]) capacity() // az elemek aktuális száma // n-re méretez val [vagy default] elemmel feltöltve // a férőhelyek száma fit into the area // (automatikusan is nő) // a férőhelyek számának növelése n-re reserve(n) Módosítók push_back(val) // a val az utolsó elem mögé kerül pop_back() // törli az utolsó elemet és visszatér értékével iterator insert ( iterator position, const T& x ) // a pozícióba helyez nem hatékony Törlés bool empty ( ) const; erase(iterator tol, iterator ig) void clear() // üres-e // tol ig töröl // mindent töröl Nincs capacity() és reserve(n) Van push_front(val) // a val az első elem elé kerül pop_front() // törli az első elemet és visszatér értékéve splice() lst1.splice(i1,lst2) // lst2 összes elem törlődik és lst1-be // insertálódik i1-től 6

7 void kiir_it(vector<double> v, vector<double>::iterator it) { for (it = v.begin(); it!=v.end(); it++) { cout << *it; void kiir_it(deque<double> dq, deque<double>::iterator it) { for (it = dq.begin(); it!= dq.end(); it++) { cout << *it; deque<double> dq(4,10); deque<double>::iterator dqi; cout << "dq" << endl; kiir_i(dq); cout << endl; for (int i = 1; i < 5; i++) { dq.push_front(-i); dq.push_back(i); cout << "dq" << endl; kiir_it(dq,dqi); cout << endl; dqi=dq.begin(); for (int i = 0; i < 6; i++) dqi++; dq.insert(dqi,567); cout << "dq" << endl; kiir_it(dq, dqi); cout << endl; 7

8 IV A list #include <list> Nincs direkt elérés (at() és []) Kétirányban láncolt lista. Gyors beszúrás törlés. Nem rontja el az iterátorokat. Konstruktorok (vector<tip>) list<tip> l_0; // üres tip típusú deque list<tip> l_1 (db[,ertek]); // db elemű deque ertek elemekkel list<tip> l_2 (l1.begin(), l1.end()); //iterációs létreh li-ből list<tip> l_4 (l3); // másoló konstruktor deque-ból Bejárók (vector<tip>::iterator) begin() // kezdet end() // vég rbegin() // vissza kezdet rend() // vissza vég 8

9 void kiir_it(list<double> dq, list<double>::iterator it) { for (it = dq.begin(); it!= dq.end(); it++) { cout << *it; list<double> l1; list<double> l2(3, 1.0); list<double>::iterator lii; for (int i = 1; i < 5; i++) { l2.push_front(-i); l2.push_back(i); lii = l2.begin(); for (int i = 0; i < 6; i++) lii++; l2.insert(lii, 8998); cout << "li" << endl; kiir_it(l2, lii); cout << endl; 9

10 IV.1.2 Asszociatív tárolók Az asszociatív tárolók (map, set) absztrakt adattípusok, melyek - map Esetén (kulcs,érték) adatpárok (a pair sablon szerint), set esetén csak kulcsok - kulcs szerint rendezett tömbjét tárolják. Minden lehetséges kulcsérték legalább egyszer előfordul. template <class T1, class T2> struct pair { T1 first; T2 second; pair() : first(t1()), second(t2()) { ; IV map #include <map> Konstruktorok (map<tip1,tip2>) map<tip1,tip2> map_0; // üres (tip1,tip2) típusú map map<tip1,tip2> map_1(map_0.begin(),map_0.end()); // iterációs létrehozás map<tip1,tip2> map_2(map_1); // másoló konstruktor // Lehet definiálni az összehasonlítást kulcsra és értékre is Bejárók (map<tip1,tip2>::iterator) begin() // kezdet end() // vég rbegin() // vissza kezdet rend() // vissza vég map<tip1,tip2> ::iterator m; (*m) // maga az elem, mintha pointer lenne (*m).first a kulcs m->second - az érték Tulajdonságok operator[] // az adott kulcsú elem 10

11 Méretek size() // az elemek aktuális száma max_size() // az elemek maximális száma Módosítók insert(iterator,pair<tip1,tip2>(kulcs,ertek)); Törlés bool empty ( ) const; erase(iterator tol, iterator ig) clear() // üres-e // tol ig töröl // mindent töröl Keresések #include <algorithm> map<tip1,tip2>::iterator find(const tip1& x); size_type count ( const key_type& x ) const; iterator lower_bound ( const key_type& x ); // az első x kulcsú elem it. iterator upper_bound ( const key_type& x ); // az első nagyobb elem it. Példák map<char,int> map_0; // az alap konstruktor map<char,int>::iterator m0_it; // iterátor map_0['a']=10; map_0['b']=30; map_0['c']=50; map_0['d']=70; m0_it=map_0.begin(); cout<<m0_it->first<<endl; // az első elem kulcsa - a cout<<(*m0_it).second<<endl; // az első elem értéke - 10 map<char,int> map_1 (map_0.begin(),map_0.end()); // iteratív feltöltés map<char,int> map_2 (map_1); // másoló konstruktor // feltöltés for (m0_it=map_0.begin(); m0_it!=map_0.end(); m0_it++) // a map elemek kiírása 11 cout<<(*m0_it).first<<" : "<<(*m0_it).second<<endl; // a : 10 // b : 30

12 cout<<"size:"<<map_0.size()<<endl; // a méret 4 cout<<"maxsize:"<<map_0.max_size()<<endl; // a maximális méret m0_it=map_0.begin(); map_0.insert(m0_it,pair<char,int>('a',300)); // beszúrás for (m0_it=map_0.begin(); m0_it!=map_0.end(); m0_it++) // sorba cout<<(*m0_it).first<<" : "<<(*m0_it).second<<endl; // A : 300 // a : 10 // b : 30 cout<<map_0.count('a')<< " db. "<<'a'<<" kulccsal"<<endl; // 1 cout<<"a legkisebb "<<'a'<<" kulcsú elem: <<(*map_0.lower_bound('a')).second<<endl; // 10 cout<<"az "<<'a'<<" kulcsu elem felso hat:" <<(*map_0.upper_bound('a')).second<<endl; // 30

13 IV set Asszociatív tároló amely egyetlen elem sort tartalmaz, ami a kulcs egyben. A bejárók pointerek #include <set> Konstruktorok (set<tip>) set<tip> set_0; tip tomb[]= {t0, t1, t2; set<tip> set_1 (tomb,tomb+3); set<tip> set_2(set_1.begin(),set_1.end()); set<tip> set_3(map_1); // (Lehet definiálni az összehasonlítást) Bejárók (set<tip>::iterator) // üres (tip1) típusú set // iteratív pointerekkel // iterációs létrehozás // másoló konstruktor begin() // kezdet end() // vég rbegin() // vissza kezdet rend() // vissza vég set<tip>::iterator m; (*m) // maga az elem, mintha pointer lenne (*m) az elem Méretek size() // az elemek aktuális száma max_size() // az elemek maximális száma Módosítók insert(iterator,const tip & x); // beszúr

14 Törlés bool empty ( ) const; // üres-e erase(iterator tol, iterator ig) // tol ig töröl clear() // mindent töröl Keresések #include <algorithm> NINCS operator[] set<tip>::iterator find(const tip& x); // az adott kulcsú elem size_type count ( const key_type& x ) const; iterator lower_bound ( const key_type& x ); // első x elem iterátora iterator upper_bound ( const key_type& x ); // első már nem x elem it. 14

15 Példák set<int> set_0; // üres (tip1) típusú set int tomb[]= {10, 20, 30; set<int> set_1 (tomb,tomb+3); // iteratív pointerekkel set<int> set_2(set_1.begin(),set_1.end()); // iterációs létrehozás set<int> set_3(set_1); // másoló konstruktor set<int>::iterator it_s; for ( it_s=set_1.begin() ; it_s!= set_1.end(); it_s++ ) // set elemek kiírása cout << " " << *it_s; // cout<<endl; cout<<"size:"<<set_1.size()<<endl; // meret 3 cout<<"maxsize:"<<set_1.max_size()<<endl; // max meret set<int>::iterator s_it; s_it=set_1.begin(); set_1.insert(s_it,300); // beilleszt az 1. helyre for (s_it=set_1.begin(); s_it!=set_1.end(); s_it++) // sorba cout<<(*s_it)<<endl; // !!!!! cout<<set_1.count(10)<< " db. "<<10<<"-es"<<endl; // 1 db. 10-es cout<<"a legkisebb "<<10<<" kulcsu elem:"<<(*set_1.lower_bound(10))<<endl; //10 cout<<"az "<<10<<" kulcsu elem felso hat:"<<(*set_1.upper_bound(10))<<endl; //20 15

16 IV.1.3 Adapter tárolók A stack LIFO típusú, a queue FIFO típusú tárolók más típusú tárolót használnak egyszerűsített kezelő felülettel. IV stack A stack (bármilyen standard aminek van back(), push_back() és pop_back() művelete vector deque list). #include <stack> Konstruktorok (stack<tip, tarolo<tip>>) stack<tip,vector<tip> > stack_0; // üres stack vector-t használ vector<tip> vek (2,200); // vektor 2 elemmel stack<tip,vector<tip> > stack_1 (vek); // stack vektorral inicializálva Kezelés bool empty ( ) const // üres-e void push(const tip & x) // a stack-be tölt void pop() // leveszi a felső elemet tip & top() // visszaadja a felső elemet size_type size() const // a méret; Példák stack<int,vector<int> > stack_0; // üres stack vector-t használ vector<int> vek (2,200); // vektor 2 elemmel stack<int,vector<int> > stack_1 (vek); // stack vektorral inicializálva for (int i=1; i<5; i++) stack_1.push(i);// tölti az elemeket for (int i=1; i<3; i++){ cout<<stack_1.top()<<endl; // kiírja és stack_1.pop(); // leveszi a felsőt cout<<stack_1.size()<<endl; // a meret 4 (2+4-2)

17 IV queue A queue (bármilyen standard aminek van front(), back(), push_back() és push_front() művelete deque) #include <queue> Konstruktorok (queue<tip, tarolo<tip>>) queue<tip,list<tip> > que_0; list<tip> lst (2,200); queue<tip,list<tip> > que_1 (lst); Kezelés bool empty ( ) const; void push(const tip & x) void pop() tip & front() tip & back() size_type size() const Példák list<int> lst (2,200); queue<int,list<int> > que_1 (lst); queue<int,deque<int>> que_0; for (int i=1; i<10; i++) que_0.push(i); for (int i=1; i<4; i++){ cout<<que_0.front()<<endl; // que_0.pop(); cout<<que_0.size()<<endl; // 6 (9-3) // üres queue list-t használ // list 2 elemmel // stack vektorral inicializálva // üres-e // a queue véégére tölt // leveszi a legrégebbi elemet // visszaadja a legújabb elemet // visszaadja a legrégebbi elemet // a méret; // lista 2 elemmel // que list-tel inicializálva // üres queue deque-t használ // tölti az elemeket 17

18 #include "stdafx.h" #include <iostream> #include <conio.h> #include <stdlib.h> #include <vector> #include <stack> #include <algorithm> using namespace std; struct au{ double t; double vx; double vy;; bool mys(au au1, au au2) { return (au1.vx>au2.vx); int _tmain(int argc, _TCHAR* argv[]) { vector<int> v; for (int i=1; i<10; i++) v.push_back(rand()); sort(v.begin(), v.end()); for (int i=0; i<v.size(); i++) cout<<v[i]<<endl; /**************************************************/ 18

19 vector<au> x(1); x[0].t=0; x[0].vx=0; x[0].vy=0; vector<au>::iterator it; for (int i=0; i<10; i++) { au s; s.t=i; s.vx=rand(); s.vy=rand(); x.push_back(s); for (it=x.begin(); it!=x.end(); it++) cout<<(*it).t<<" "<<+(*it).vx<<" " <<(*it).vy<<endl; sort(x.begin(), x.end(), mys); for (it=x.begin(); it!=x.end(); it++) cout<<(*it).t<<" "<<+(*it).vx<<" "<<(*it).vy<<endl; 19

20 /***************************************************/ stack<int,vector<int>> st; for (int i=0; i<10; i++) st.push(i); while (!st.empty()){ cout<<st.top()<<endl; st.pop(); /****************************************************************/ queue<int,deque<int>> q; for (int i=0; i<10; i++) q.push(i); while (!q.empty()){ cout<<q.front()<<endl; q.pop(); getch(); return 0; 20