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() /* Output:
{ 10
10 20
vector<int> v; 22
10
v.push_back(10); 12
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;
}
STRING CLASS OPERATIONS
string s = "hello";
string s1 = s.substr(0, 3), // "hel"
s+=“ Ayan”
string s2 = s.substr(1, 6), // "ello A“
string 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:
01234
*/
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);
/* Output:
} Ayan Nitin
Sadhu Sagar
}
Sasy
*/
int main()
{
const char* str[6] = {“Ayan”, “Sagar”, “Nitin” ,“Sasy”, “Sadhu”};
set<const char*, ltstr> s(str, str + 6);
print(s);
}
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:
} 6
5
*/
QUEUE OPERATIONS
#include <queue>
int main()
{
/* Output:
queue<int> q; 8
5
q.push(8);
*/
q.push(5);
q.push(6);
cout << q.top() << endl;
q.pop();
cout << q.top() << endl;
}
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>
#include<iostream>
Output:
using namespace std; Mark, 95
int main() Louise, 66
95
{
map<string,int> grade;
grade["Mark"] = 95;
grade["Louise"] = 66;
for(map<string,int> :: iterator it=grade.begin(); it!
=grade.end(); it++){
cout << '\t' << it->first
<< '\t' << it->second << '\n';
}
cout << grade["Mark"] << endl;
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() { /* Output:
120
deque<int> dq; *

dq.push_back(3);
dq.push_front(1);
dq.insert(de.begin() + 1, 2);
dq[2] = 0;
}
STL ITERATORS

Every STL container holds a nested iterator class
ITERATOR OPERATIONS
#include <vector>
#include <iterator>
/* Output:
#include <algorithm> 1 4 2 8 5 7
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;

}
COMMON STL ALGORITHMS
 FIND
int 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:
123
} 132
213
231
312
321
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); Output
} 12345
54321
*/
 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);
/*Output
std::cout << "lower_bound at position " << (low- v.begin()) << '\n'; lower_bound at
std::cout << "upper_bound at position " << (up - v.begin()) << '\n';
position 3
upper_bound at
position 6
return 0; */
}
A SMALL EXAMPLE
vector<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;

Output
14
23
32
41
50
LONGEST INCREASING SUBSEQUENCE
set<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

/*Input /*Input
5 5
1 2 1 1 4 2 4 3
*/ */
/*Output /*Output
1 1
1 2 1 4
1 2 1 2
2 1 2 4
*/ 1 2 3
3
*/