INTRODUCTION TO

C++ STL

STL CLASSES Container Classes

Storage Class stack, queue, vector, map ...

Iterator Classes

Algorithm Classes

frequently used algorithms sort, find, binary search, next_permutation ...

STL CONTAINERS

VECTOR random access ([] operator) like an array

add / remove an element in constant time at the last of vector

add / remove an element in linear time in the

middle of vector

automatic memory management

needn’t specify quantity of elements

VECTOR OPERATIONS#include <vector>

int main()

{

vector<int> v;

v.push_back(10);

cout<<v[0]<<endl;

v.push_back(20);

cout<<v[0]<<” “<<v[1]<<endl;

cout << v.size() << “ “ << v.capacity() << endl;

v.pop_back();

print(v);

cout << v.size() << “ “ << v.capacity() << endl;

}

/* Output:1010 202 2101 2*/

STRING CLASS OPERATIONS

string s = "hello";

string s1 = s.substr(0, 3), // "hel"

s+=“ Ayan”

s2 = s.substr(1, 6), // "ello A“

s4 = s.substr(1); // "ello Ayan"

LIST Sequence

Elements in sequence containers are ordered in a strict linear sequence.

Individual elements are accessed by their position in this sequence.

Doubly-linked list

LIST OPERATIONS#include <list>

int main() {

list <int> la, lb;

la.push_back(0), la.push_back(1), la.push_back(3);

lb.push_back(4), lb.push_front(2);

la.sort(); lb.sort();

la.merge(lb); /*merge function merges 2 sorted lists*/

print(la);

} /* Output:0 1 2 3 4*/

SET Associative

Elements in associative containers are referenced by their key and not by their absolute position in the container.

Ordered

The elements in the container follow a strict order at all times. All inserted elements are given a position in this order.

Unique keys

No two elements in the container can have equivalent keys.

Implemented as balanced binary search trees. Insertion Searching complexity O(logn)

SET OPERATIONS

#include <set>

struct ltstr

{

bool operator() (const char* s1, const char* s2) const

{

return (strcmp(s1, s2) < 0);

}

}

int main()

{

const char* str[6] = {“Ayan”, “Sagar”, “Nitin” ,“Sasy”, “Sadhu”};

set<const char*, ltstr> s(str, str + 6);

print(s);

}

/* Output:Ayan Nitin Sadhu Sagar Sasy */

MULTISET Same as set

But elements need not be unique.

STACK OPERATIONS

#include <stack>

int main()

{

stack<int> s;

s.push(8);

s.push(5);

s.push(6);

cout << s.top() << endl;

s.pop();

cout << s.top() << endl;

}/* Output:65*/

QUEUE OPERATIONS#include <queue>

int main()

{

queue<int> q;

q.push(8);

q.push(5);

q.push(6);

cout << q.top() << endl;

q.pop();

cout << q.top() << endl;

}

/* Output:85*/

PRIORITY QUEUE Max Heap

Maximum Element at top of queue

PRIORITY_QUEUE OPERATIONS#include <queue>

int main()

{

priority_queue< int > pq;

int ary[6] = {1, 4, 2, 8, 5, 7};

for (int i = 0; i < 6; pq.push(ary[i++]));

while (!pq.empty()) {

cout << pq.top() << “ “;

pq.pop();

}

}

/* Output:8 7 5 4 2 1*/

MAP Associative

Elements in associative containers are referenced by their key and not by their absolute position in the container.

Ordered

The elements in the container follow a strict order at all times. All inserted elements are given a position in this order.

Map

Each element associates a key to a mapped value: Keys are meant to identify the elements whose main content is the mapped value.

Unique keys

No two elements in the container can have equivalent keys. Implemented as balanced binary search trees. Insertion Searching complexity O(logn)

MAP OPERATIONS#include <map>

int main() {

map<string, int> grade;

grade[“Mark”] = 95;

grade[“Edward”] = 87;

grade[“Louise”] = 66;

grade[“Allen”] = 76;

for(map<string,int> iterator it=grade.begin();it!=grade.end();it++)

cout<<*it.first<<“ “<<*it.second<<endl;

cout << grade[“Allen”] << endl;

}

/* Output:Allen, 76Edward, 87Louise, 66Mark, 9576*/

DEQUE Double Ended Queue

Functionality similar to vectors,

but with efficient insertion and deletion of elements also at the beginning of the sequence, and not only at its end

Sequence

Elements in sequence containers are ordered in a strict linear sequence. Individual elements are accessed by their position in this sequence.

DEQUE OPERATIONS#include <deque>

int main() {

deque<int> dq;

dq.push_back(3);

dq.push_front(1);

dq.insert(de.begin() + 1, 2);

dq[2] = 0;

}

/* Output:1 2 0*

STL ITERATORS Every STL container holds a nested iterator class

ITERATOR OPERATIONS#include <vector>

#include <iterator>

#include <algorithm>

int main()

{

vector<int> v;

int ary[6] = {1, 4, 2, 8, 5, 7};

for (int i = 0; i < 6; v.push_back(ary[i++]));

for (vector<int>::iterator it = v.begin(); it != v.end(); it++)

cout << (*it) << “ “;

cout << endl;

}

/* Output:1 4 2 8 5 7*/

COMMON STL ALGORITHMS

FINDint main ()

{

int myints[] = { 10, 20, 30 ,40 };

int * p; // pointer to array element:

p = find (myints,myints+4,30);

++p;

cout << "The element following 30 is " << *p << '\n';

vector<int> myvector (myints,myints+4);

vector<int>::iterator it; // iterator to vector element

it = find (myvector.begin(), myvector.end(), 30);

++it;

cout << "The element following 30 is " << *it << '\n';

return 0;

}The element following 30 is 40 The element following 30 is 40

NEXT_PERMUTATION// next_permutation example

#include <algorithm> // std::next_permutation, std::sort

int main ()

{

int myints[] = {1,2,3};

sort(myints,myints+3);

cout<<"The 3! possible permutations with 3 elements:\n";

do {

print(myints);

} while(next_permutation(myints,myints+3));

return 0;

}

The 3! possible permutations with 3 elements: 1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1

SORT()#include<algorithm>

int main()

{

int ar[5]={3,2,4,1,5};

vector<int> v;

for(int i=0;i<5;i++) v.push_back(ar[i]);

sort(ar,ar+5);

sort(v.begin(),v.end(),greater<int>);

print(ar);

print(v);

}

/*Output1 2 3 4 55 4 3 2 1*/

BINARY SEARCH// lower_bound/upper_bound example

#include <iostream> // std::cout

#include <algorithm> // std::lower_bound, std::upper_bound, std::sort

#include <vector> // std::vector

int main ()

{

int myints[] = {10,20,30,30,20,10,10,20};

std::vector<int> v(myints,myints+8); // 10 20 30 30 20 10 10 20

std::sort (v.begin(), v.end()); // 10 10 10 20 20 20 30 30

std::vector<int>::iterator low,up;

low=std::lower_bound (v.begin(), v.end(), 20);

up= std::upper_bound (v.begin(), v.end(), 20);

std::cout << "lower_bound at position " << (low- v.begin()) << '\n';

std::cout << "upper_bound at position " << (up - v.begin()) << '\n';

return 0;

}

/*Outputlower_bound at position 3upper_bound at position 6*/

A SMALL EXAMPLEvector<pair<int,int> > v(5);

for(int i=0;i<5;i++) v[i]=make_pair(5-i,i);

sort(v.begin(),v.end());

for(vector<pair<int,int> >::iterator it=v.begin();it!=v.end();it++)

cout<<*it.first<<“ “<<*it.second<<endl;

for(int i=0;i<5;i++)

cout<<v[i].first<<“ “v[i].second<<endl;

Output1 42 33 24 15 0

LONGEST INCREASING SUBSEQUENCEset<int> st;

set<int>::iterator it;

st.clear();

for(int i=0; i<n; i++) {

it=st.find(array[i]);

if(*it==array[i]);

else

{

st.insert(array[i]);

it=st.find(array[i]);

it++;

if(it!=st.end()) st.erase(it);

}

for(set<int>::iterator it2=st.begin();it2!=st.end();it2++)

printf("%d ",*it2);

printf("\n");

}

cout<<st.size()<<endl;

LONGEST INCREASING SUBSEQUENCE OPERATIONS

/*Input51 4 2 4 3*//*Output1 1 4 1 2 1 2 4 1 2 3 3*/

/*Input51 2 1*//*Output1 1 2 1 2 2*/