TDA Vector.

Pentru folosirea containerului vector se dă antetul:

#include <vector>
TDA vector generalizează conceptul de tablou cu o dimensiune. Abstractizarea permite mărirea sau micşorarea
colecţiei în cursul execuţiei.
Accesul la orice element se face în timp constant. Operatorul de indexare nu asigură verificarea indicelui (dacă se
încadrează în domeniu).
Inserarea şi ştergerea la sfârşit se face în O(1), iar în celelalte poziţii în O(n).
Fiind un container parametrizat, la instanţiere se declară:
vector<int> x(10,1); //vector de 10 intregi initializati cu 1
vector<double> y(20);//vector de 20 reali neinitializati
1. Operaţii asupra TDA vector.
1.constructori
vector<T> v; //c-tor implicit
vector<T>v(int); //c-tor cu dimens. initializata
vector<T>v(int, T); //c-tor cu dimensiune si
//valoare initiala
vector<T>v(vec); //c-tor de copiere
2.acces la elemente
v[i] //elementul din pozitia i
v.front() //primul element
v.back() //ultimul element
3.inserări
v.push_back(T); //adaugare element la sfarsit
v.insert(iterator, T);//inserare element dupa iterator
v.swap(vector<T>); //interschimb cu alt vector
4.ştergeri
v.pop_back(); //sterge ultimul element
v.erase(iterator); //sterge elementul indicat de iterator
v.erase(iterator, iterator); //sterge elementele din interval
Folosirea funcţiilor insert() şi erase() invalidează toţi iteratorii.
5. dimensionări
v.capacity(); //memoria rezervata pt.vector
v.size(); //memoria ocupata de vector
v.resize(int, T);//schimbarea dimensiunii
v.reserve(); //realocare memorie pt.vector
v.empty(); //test vector vid
6. iteratori
vector<T>::iterator it; //declara un iterator
v.begin(); //iterator de pornire(la primul elem)
v.end(); //iterator de oprire(după ultimul)

2. Algoritmi generici.
//pune in intervalul[p,u) valoarea val
template <class FwdIt, class T>
void fill(FwdIt p,FwdIt u, const T& val)
//copiaza elementele din intervalul [p,u) la destinatia d,
//intoarce pozitia de dupa ultima
template<class InIt, class OutIt>
OutIt copy(InIt p, InIt u, OutIt d);
//determina prima pozitie i din intervalul[p,u)astfel ca *i<*j sa fie fals
template<class FwdIt>
FwdIt max_element(FwdIt p, FwdIt u);

1
//determina prima pozitie i din intervalul[p,u)astfel ca pr(*i,*j) sa fie fals
template<class FwdIt, class Pred>
FwdIt max_element(FwdIt p, FwdIt u, Pred pr);
//pentru fiecare pozitie p din [p,u) se intoarce f(*p)
template<class InIt, class Fun>
Fun for_each(InIt p, InIt u, Fun f);
//cele doua secvente [p1,u1) si [p2,u2) ordonate cu relatia de ordine < sunt
//interclasate si depuse la d a.i. secventa sa ramana ordonata
//intoarce pozitia de dupa ultimul element dest
template<class InIt1, class InIt2, class OutIt>
OutIt merge(InIt1 p1, InIt1 u1, InIt2 fp2, InIt2 u2, OutIt d);
//cele doua secvente [p1,u1) si [p2,u2) ordonate cu relatia de ordine Pr sunt
//interclasate si depuse la d a.i. secventa sa ramana ordonata
//cu aceeasi relatie de ordine. Intoarce pozitia de dupa ultimul element destinatie
template<class InIt1, class InIt2, class OutIt, class Pred>
OutIt merge(InIt1 p1, InIt1 u1, InIt2 p2, InIt2 u2, OutIt d, Pred pr);
//secventele sortate [p,m) si [m,u) sunt amestecate ai secventa [p,u) sa fie sortata
template<class BidIt>
void inplace_merge(BidIt p, BidIt m, BidIt u);
//secventele [p,m) si [m,u) ordonate cu relatia de ordine pr sunt amestecate a.i.
// secventa [p,u) sa fie ordonata cu acelasi criteriu
template<class BidIt, class Pred>
void inplace_merge(BidIt p, BidIt m, BidIt u, Pred pr);
3.Implementarea clasei vector.
template <class T> class vector{
protected:
int ne; //numar de elemente
int dim; //spatiu alocat pentru vector
T* data; //zona de date
public:
typedef T* iterator;
vector(int n=0){ data=0; resize(n);};
vector(int n, const T& vi);
vector(const vector& v);
~vector(){delete[]data;};
T& operator[](int k){return data[k];};
int size()const{return ne;};
int capacity()const{return dim;};
int empty()const{return ne==0;};
void resize(int) { reserve(d); dim = d; };
void reserve(int);
T front(){return *data;};
T back() {return data[ne-1];};
void insert(iterator,T);
void swap(vector&);
iterator begin(){return data;};
iterator end() {return data+ne;};
void push_back(const T&);
void pop_back(){ne--;};
}
template <class T> vector<T>::vector(int n){
data=0;
resize(n);
}
template <class T> vector<T>::vector(int n, const T& vi){
data=0;
resize(n);
fill(begin(),end(),vi);
2
}
template <class T> vector<T>::vector(const vector& v){
data=0;
resize(v.size());
copy(v.begin(),v.end(),begin());
}
template <class T> void vector<T>::reserve(int c){
if(data==0){
ne=0;
dim=0;
};
if(c <= dim) return;
T* datan = new T[c];
assert(datan);
copy(data, data+ne, datan);
dim = c;
delete [] data;
data = datan;
}
template <class T> void vector<T>::push_back(T val){
if(ne >= dim)
reserve(dim+INC);
data[ne++] = val;
}
template <class T> void vector<T>::erase(iterator crt){
iterator dupa = crt;
while(++dupa!=end()){
*crt++ = *dupa;
};
template <class T> void vector<T>::erase(iterator start, iterator stop) {
while(start!=stop)
erase(start);
};
4. Implementarea algoritmilor generici.
//algoritmi generici
template <class ItrT, class T>
void fill(FwdIt p, FwdIt u,const T& val){
while(p!=u)
*p++ = val;
};

template <class InIt, class OutIt>

void copy(InIt p, InIt u, OutIt dest){
while(p!=u)
*dest++ = *p++;
};

//algoritmi generici pt.vectori sortati

template <class BidIt>
void inplace_merge(BidIt p, BidIt m, BidIt u){
int d = u - p;
vector<T> temp(d);
merge(p,m,m,u,temp.begin());
copy(temp.begin(),temp.end(),p);
};

template <class InIt1, class InIt2, class OutIt>

void merge(InIt1 p1, InIt1 u1, InIt2 p2, InIt2 u2, OutIt dest){
while(p1!=u1 && p2!=u2)
if(*p1 < *p2)
*dest++ = *p1++;
else
3
 *dest++ = *p2++;
while(p1!=u1)
*dest++ = *p1++;
while(p2!=u2)
*dest++ = *p2++;
};

5.Probleme propuse.
1. Scrieţi un program C++, care utilizează STL (biblioteca de şabloane standard) pentru a extrage dintr-un fişier text toate
cuvintele distincte şi a le introduce într-un container vector, împreună cu numărul de apariţii ale cuvâtului şi numerele liniilor
din fişierul text în care apare cuvântul. Se va trece apoi conţinutul containerului într-un fişier binar numit "index".
Pentru lucrul cu fişiere se vor utiliza facilităţile oferite de C++.

2.