STL for newbies

MC LC
I.
II.

ITERATOR (BIN LP): ......................................................................................................... 3

CONTAINERS (TH VIN LU TR) .................................................................................. 4
1. Iterator: .................................................................................................................................. 4
2. Vector (Mng ng):.............................................................................................................. 5
3. Deque (Hng i hai u): ..................................................................................................... 8
4. List (Danh sch lin kt): ....................................................................................................... 9
5. Stack (Ngn xp): .................................................................................................................. 9
6. Queue (Hng i): ............................................................................................................... 10
7. Priority Queue (Hng i u tin): ....................................................................................... 11
8. Set (Tp hp): ...................................................................................................................... 12
9. Mutiset (Tp hp): ............................................................................................................... 15
10.
Map (nh x):.................................................................................................................. 16
11.
Multi Map (nh x): ........................................................................................................ 17
III.
STL ALGORITHMS (TH VIN THUT TON): ........................................................... 18
1. Min, max ............................................................................................................................. 18
1.1. min............................................................................................................................... 18
1.2. max .............................................................................................................................. 18
1.3. next_permutation.......................................................................................................... 18
1.4. prev_permution ............................................................................................................ 18
2. Sp xp: ............................................................................................................................... 19
3. Tm kim nh phn (cc hm i vi on sp xp): ........................................................ 19
3.1. binary_search: .............................................................................................................. 19
3.2. lower_bound: ............................................................................................................... 20
3.3. upper_bound ................................................................................................................ 20
IV.
TH VIN STRING C++: .................................................................................................. 21

STL for newbies iu Xun Mnh D10CN6 PTIT

Li ni u
-

C++ c nh gi l ngn ng mnh v tnh mm do, gn gi vi ngn ng my.

Ngoi ra, vi kh nng lp trnh theo mu ( template ), C++ khin ngn ng lp
trnh tr thnh khi qut, khng c th v chi tit nh nhiu ngn ng khc. Sc mnh
ca C++ n t STL, vit tt ca Standard Template Library - mt th vin template
cho C++ vi nhng cu trc d liu cng nh gii thut c xy dng tng qut m
vn tn dng c hiu nng v tc ca C. Vi khi nim template, nhng ngi
lp trnh ra khi nim lp trnh khi lc (generic programming), C++ c
cung cp km vi b th vin chun STL.
B th vin ny thc hin ton b cc cng vic vo ra d liu (iostream), qun l
mng (vector), thc hin hu ht cc tnh nng ca cc cu trc d liu c bn (stack,
queue, map, set...). Ngoi ra, STL cn bao gm cc thut ton c bn: tm min, max,
tnh tng, sp xp (vi nhiu thut ton khc nhau), thay th cc phn t, tm kim
(tm kim thng v tm kim nh phn), trn. Ton b cc tnh nng nu trn u
c cung cp di dng template nn vic lp trnh lun th hin tnh khi qut ha
cao. Nh vy, STL lm cho ngn ng C++ tr nn trong sng hn nhiu.
Trch Tng quan v th vin chun STL
STL kh l rng nn ti liu ny mnh ch vit nh hng v cch s dng STL c
bn cc bn ng dng trong vic gii cc bi ton tin hc i hi n cu trc d
liu v gii thut.
Mnh ch yu s dng cc v d, cng nh ngun ti liu t trang web
www.cplusplus.com , cc bn c th tham kho chi tit na.
c th hiu c nhng g mnh trnh by trong ny, cc bn cn c nhng kin
thc v cc cu trc d liu, cng nh mt s thut ton nh sp xp, tm kim...
Vic s dng thnh tho STL s l rt quan trng nu cc bn c nh tham gia cc
k thi nh Olympic Tin Hc, hay ACM. STL s ni di kh nng lp trnh ca cc
bn (trch li thy L Minh Hong).
Mi kin ng gp xin gi v a ch: manhdjeu@gmail.com

STL for newbies iu Xun Mnh D10CN6 PTIT

Th vin mu chun STL trong C++ chia lm 4 thnh phn l:

Containers Library : cha cc cu trc d liu mu (template)
Sequence containers
Vector
Deque
List
Containers adpators
Stack
Queue
Priority_queue
Associative containers
Set
Multiset
Map
Multimap
Bitset
Algorithms Library: mt s thut ton thao tc trn d liu
Iterator Library: ging nh con tr, dng truy cp n cc phn t d liu
ca container.
Numeric library:

s dng STL, bn cn khai bo t kha using namespace std; sau cc khai bo

th vin (cc #include, hay #define,...)
V d:

#include <iostream>
#include <stack> //khai bo s dng container stack
#define n 100
using namespace std; //khai bo s dng STL
main() {
....
}

I.
-

Vic s dng cc hm trong STL tng t nh vic s dng cc hm nh trong class.

Cc bn c qua mt vi v d l c th thy c quy lut.

ITERATOR (BIN LP):

Trong C++, mt bin lp l mt i tng bt k, tr ti mt s phn t trong 1 phm
vi ca cc phn t (nh mng hoc container), c kh nng lp cc phn t trong
phm vi bng cch s dng mt tp cc ton t (operators) (nh so snh, tng (++),
...)
Dng r rng nht ca iterator l mt con tr: Mt con tr c th tr ti cc phn t
trong mng, v c th lp thng qua s dng ton t tng (++). Tuy nhin, cng c
STL for newbies iu Xun Mnh D10CN6 PTIT

II.
-

cc dng khc ca iterator. V d: mi loi container (chng hn nh vector) c mt

loi iterator c thit k lp cc phn t ca n mt cch hiu qu.
Iterator c cc ton t nh:
So snh: == , != gia 2 iterator.
Gn: = gia 2 iterator.
Cng tr: +,- vi hng s v ++,.
Ly gi tr: *.

CONTAINERS (TH VIN LU TR)

Mt container l mt i tng c th lu tr mt tp cc i tng khc (cc phn t
ca n). N c thc hin nh cc lp mu ( class templates).
Container qun l khng gian lu tr cho cc phn t ca n v cung cp cc hm
thnh vin (member function) truy cp ti chng, hoc trc tip hoc thng qua
cc bin lp (iterator ging nh con tr).
Container xy dng cc cu trc thung s dng trong lp trnh nh: mng ng dynamic arrays (vector), hng i queues (queue), hng i u tin heaps (priority
queue), danh sch kin kt linked list (list), cy trees (set), mng nh x associative arrays (map),...
Nhiu container cha mt s hm thnh vin ging nhau. Quyt nh s dng loi
container no cho nhu cu c th ni chung khng ch ph thuc vo cc hm c
cung cp m cn phi da vo hiu qu ca cc hm thnh vin ca n ( phc tp
(t gi mnh s vit tt l PT) ca cc hm). iu ny c bit ng vi container
dy (sequence containers), m trong c s khc nhau v phc tp i vi cc
thao tc chn/xa phn t hay truy cp vo phn t.

1. Iterator:
Tt c cc container 2 loi: Sequence container v Associative container u h tr cc
iterator nh sau (v d vi vector, nhng loi khc c chc nng cng vy).
/*khai bo iterator it*/
vector <int> :: iterator it;
/* tr n v tr phn t u tin ca vector */
it=vector.begin();
/*tr n v tr kt thc (khng phi phn t cui cng nh) ca vector) */
it=vector.end();
/* khai bo iterator ngc rit */
vector <int> :: reverse_iterator rit; rit = vector.rbegin();
/* tr n v tr kt thc ca vector theo chiu ngc (khng phi phn t
u tin nh*/
rit = vector.rend();

Tt c cc hm iterator ny u c phc tp O(1).

STL for newbies iu Xun Mnh D10CN6 PTIT

2. Vector (Mng ng):

Khai bo vector:
#include <vector>
...
/* Vector 1 chiu */
/* to vector rng kiu d liu int */
vector <int> first;
//to vector vi 4 phn t l 100
vector <int> second (4,100);
// ly t u n cui vector second
vector <int> third (second.begin(),second.end())
//copy t vector third
vector <int> four (third)
/*Vector 2 chiu*/
/* To vector 2 chiu rng */
vector < vector <int> > v;
/* khai bo vector 510 */
vector < vector <int> > v (5, 10) ;
/* khai bo 5 vector 1 chiu rng
vector < vector <int> > v (5) ;

*/

//khai bo vector 5*10 vi cc phn t khi to gi tr l 1

vector < vector <int> > v (5, vector <int> (10,1) ) ;

Cc bn ch 2 du ngoc khng c vit lin nhau.

V d nh sau l sai:
/*Khai bo vector 2 chiu SAI*/
vector <vector <int>> v;

Cc hm thnh vin:
Capacity:
-

size : tr v s lng phn t ca vector. PT O(1).

empty : tr v true(1) nu vector rng, ngc li l false(0). PT
O(1).

Truy cp ti phn t:
-

operator [] : tr v gi tr phn t th []. PT O(1).

at : tng t nh trn. PT O(1).
STL for newbies iu Xun Mnh D10CN6 PTIT

front: tr v gi tr phn t u tin. PT O(1).

back: tr v gi tr phn t cui cng. PT O(1).

Chnh sa:
-

push_back : thm vo cui vector. PT O(1).

pop_back : loi b phn t cui vector. PT O(1).
insert (iterator,x): chn x vo trc v tr iterator ( x c th
l phn t hay iterator ca 1 on phn t). PT O(n).
erase : xa phn t v tr iterator. PT O(n).
swap : i 2 vector cho nhau (v d: first.swap(second);). PT O(1).
clear: xa vector. PT O(n).

Nhn xt:
- S dng vector s tt khi:
o Truy cp n phn t ring l thng qua v tr ca n O(1)
o Chn hay xa v tr cui cng O(1).
- Vector lm vic ging nh mt mng ng.
V d 1: V d ny ch yu lm quen s dng cc hm ch khng c bi c th.
#include <iostream>
#include <vector>
using namespace std;
vector <int> v; //Khai bo vector
vector <int>::iterator it; //Khai bo iterator
vector <int>::reverse_iterator rit; //Khai bo iterator ngc
int i;
main() {
for (i=1;i<=5;i++) v.push_back(i); // v={1,2,3,4,5}
cout << v.front() << endl;
// In ra 1
cout << v.back() << endl;
// In ra 5
cout << v.size() << endl;

// In ra 5

v.push_back(9);
cout << v.size() << endl;

// v={1,2,3,4,5,9}
// In ra 6

v.clear();
cout << v.empty() << endl;

// v={}
// In ra 1 (vector rng)

for (i=1;i<=5;i++) v.push_back(i); // v={1,2,3,4,5}

v.pop_back();
// v={1,2,3,4}
cout << v.size() << endl;
// In ra 4
v.erase(v.begin()+1);
v.erase(v.begin(),v.begin()+2);
v.insert(v.begin(),100);
v.insert(v.end(),5);

//
//
//
//

Xa pt th 1 v={1,3,4}
v={4}
v={100,4}
v={100,4,5}

/*Duyt theo ch s phn t*/

for (i=0;i<v.size();i++) cout << v[i] << " "; // 100 4 5
cout << endl;
STL for newbies iu Xun Mnh D10CN6 PTIT

/*Ch : Khng nn vit

for (i=0;i<=v.size()-1;i++) ...
V nu vector v rng th s dn n sai khi duyt !!!
*/
/*Duyt theo iterator*/
for (it=v.begin();it!=v.end();it++)
cout << *it << " " ;
//In ra gi tr ma iterator ang tr ti "100 4 5"
cout << endl;
/*Duyt iterator ngc*/
for (rit=v.rbegin();rit!=v.rend();rit++)
cout << *rit << " "; // 5 4 100
cout << endl;
system("pause");
}

V d 2: Cho th v hng G c n nh (cc nh nh s t 1 n n) v m cnh v khng

c khuyn (ng i t 1 nh ti chnh nh ).
Ci t th bng danh sch k v in ra cc cnh k i vi mi cnh ca th.
D liu vo:
- Dng u cha n v m cch nhau bi du cch
- M dng sau, mi dng cha u v v cho bit c ng i t u ti v. Khng c cp nh
u,v no ch cng 1 ng i.
D liu ra:
- M dng: Dng th i cha cc nh k cnh i theo th t tng dn v cch nhau bi
du cch.
Gii hn: 1 <= n,m <= 10000
V d:
INPUT
6 7
1 2
1 3
1 5
2 3
2 6
3 5
6 1

OUTPUT
2 3 5 6
1 3 6
1 2 5
1 3
1 2

Chng trnh mu:

#include <iostream>
#include <vector>
using namespace std;
vector < vector <int> > a (10001);
STL for newbies iu Xun Mnh D10CN6 PTIT

//Khai bo vector 2 chiu vi 10001 vector 1 chiu rng

int m,n,i,j,u,v;
main() {
/*Input data*/
cin >> n >> m;
for (i=1;i<=m;i++) {
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
}
/*Sort cnh k*/
for (i=1;i<=m;i++)
sort(a[i].begin(),a[i].end());
/*Print Result*/
for (i=1;i<=m;i++) {
for (j=0;j<a[i].size();j++) cout << a[i][j] << " ";
cout << endl;
}
system("pause");
}

3. Deque (Hng i hai u):

- Deque (thung c pht m ging nh deck) l t vit tt ca double-ended
queue (hng i hai u).
- Deque c cc u im nh:
o Cc phn t c th truy cp thng cua ch s v tr ca n. O(1)
o Chn hoc xa phn t cui hoc u ca dy. O(1)
Khai bo: #include <deque>
Capacity:
-

size : tr v s lng phn t ca deque. PT O(1).

empty : tr v true(1) nu deque rng, ngc li l false(0). PT
O(1).

Truy cp phn t:
-

operator [] : tr v gi tr phn t th []. PT O(1).

at : tng t nh trn. PT O(1).
front: tr v gi tr phn t u tin. PT O(1).
back: tr v gi tr phn t cui cng. PT O(1).

Chnh sa:
-

push_back : thm phn t vo cui deque. PT O(1).

push_front : thm phn t vo u deque. PT O(1).
pop_back : loi b phn t cui deque. PT O(1).
pop_front : loi b phn t u deque. PT O(1).
insert (iterator,x): chn x vo trc v tr iterator ( x c th
l phn t hay iterator ca 1 on phn t). PT O(n).
- erase : xa phn t v tr iterator. PT O(n).
- swap : i 2 deque cho nhau (v d: first.swap(second);). PT O(n).
clear: xa vector. PT O(1).

STL for newbies iu Xun Mnh D10CN6 PTIT

4. List (Danh sch lin kt):

- List c thc hin nh danh sch ni kp (doubly-linked list). Mi phn t trong
danh sch ni kp c lin kt n mt phn t trc v mt phn t sau n.
- Do , list c cc u im nh sau:
o Chn v loi b phn t bt c v tr no trong container. O(1).
- im yu ca list l kh nng truy cp ti phn t thng qua v tr. O(n).
- Khai bo: #include <list>
Cc hm thnh vin:
Capacity:
-

size : tr v s lng phn t ca list. PT O(1).

empty : tr v true(1) nu list rng, ngc li l false(0). PT
O(1).

Truy cp phn t:
-

front: tr v gi tr phn t u tin. PT O(1).

back: tr v gi tr phn t cui cng. PT O(1).

Chnh sa:
-

push_back : thm phn t vo cui list. PT O(1).

push_front : thm phn t vo u list. PT O(1).
pop_back : loi b phn t cui list. PT O(1).
pop_front : loi b phn t u list. PT O(1).
insert (iterator,x): chn x vo trc v tr iterator ( x c th
l phn t hay iterator ca 1 on phn t). PT l s phn t thm
vo.
erase : xa phn t v tr iterator. PT l s phn t b xa i.
swap : i 2 list cho nhau (v d: first.swap(second);). PT O(1).
clear: xa list. PT O(n).

Operations:
-

splice : di chuyn phn t t list ny sang list khc. PT O(n).

remove (const) : loi b tt c phn t trong list bng const. PT
O(n).
remove_if (function) : loi b tt cc phn t trong list nu hm
function return true . PT O(n).
unique : loi b cc phn t b trng lp hoc tha mn hm no .
PT O(n). Lu : Cc phn t trong list phi c sp xp.
sort : sp xp cc phn t ca list. O(NlogN)
reverse : o ngc li cc phn t ca list. O(n).

5. Stack (Ngn xp):

- Stack l mt loi container adaptor, c thit k hot ng theo kiu LIFO (Last in first - out) (vo sau ra trc), tc l mt kiu danh sch m vic b sung v loi b
mt phn t c thc hin cui danh sch. V tr cui cng ca stack gi l nh
(top) ca ngn xp.
Khai bo: #include <stack>
Cc hm thnh vin:
STL for newbies iu Xun Mnh D10CN6 PTIT

size : tr v kch
empty : true stack
push : y phn t
pop : loi b phn
top : truy cp ti

thc hin ti ca stack. PT O(1).

nu rng, v ngc li. PT O(1).
vo stack. PT O(1).
t nh ca stack. PT O(1).
phn t nh stack. PT O(1).

Chng trnh demo:

#include <iostream>
#include <stack>
using namespace std;
stack <int> s;
int i;
main() {
for (i=1;i<=5;i++) s.push(i);
s.push(100);
cout << s.top() << endl;
s.pop();
cout << s.empty() << endl;
cout << s.size() << endl;
system("pause");
}

//
//
//
//
//
//

s={1,2,3,4,5}
s={1,2,3,4,5,100}
In ra 100
s={1,2,3,4,5}
In ra 0
In ra 5

6. Queue (Hng i):

- Queue l mt loi container adaptor, c thit k hot ng theo kiu FIFO (First
- in first - out) (vo trc ra trc), tc l mt kiu danh sch m vic b sung c
thc hin cui danh sch v loi b u danh sch.
- Trong queue, c hai v tr quan trng l v tr u danh sch (front), ni phn t c
ly ra, v v tr cui danh sch (back), ni phn t cui cng c thm vo.
Khai bo: #include <queue>
Cc hm thnh vin:
-

size : tr v kch thc hin ti ca queue. PT O(1).

empty : true nu queue rng, v ngc li. PT O(1).
push : y vo cui queue. PT O(1).
pop: loi b phn t ( u). PT O(1).
front : tr v phn t u. PT O(1).
back: tr v phn t cui. PT O(1).

Chng trnh demo:

#include <iostream>
#include <queue>
using namespace std;
queue <int> q;
int i;
main() {
for (i=1;i<=5;i++) q.push(i);
q.push(100);
cout << q.front() << endl;
q.pop();
cout << q.back() << endl;

//
//
//
//
//

q={1,2,3,4,5}
q={1,2,3,4,5,100}
In ra 1
q={2,3,4,5,100}
In ra 100

STL for newbies iu Xun Mnh D10CN6 PTIT

10

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

cout << q.size() << endl;
system("pause");

// In ra 0
// In ra 5

7. Priority Queue (Hng i u tin):

- Priority queue l mt loi container adaptor, c thit k c bit phn t u
lun lun ln nht (theo mt quy c v u tin no ) so vi cc phn t khc.
- N ging nh mt heap, m y l heap max, tc l phn t c u tin ln nht
c th c ly ra v cc phn t khc c chn vo bt k.
- Php ton so snh mc nh khi s dng priority queue l php ton less (Xem thm
th vin functional)
- s dng priority queue mt cch hiu qu, cc bn nn hc cch vit hm so snh
s dng cho linh hot cho tng bi ton.
- Khai bo: #include <queue>
/*Dng 1 (s dng php ton mc nh l less)*/
priority_queue <int> pq;
/* Dng 2 (s dng php ton khc) */
priority_queue <int,vector<int>,greater<int> > q; //php ton greater

Php ton khc cng c th do ngi dng t nh ngha. V d:

Cch khai bo dng 1 tng ng vi:
/* Dng s dng class so snh t nh ngha */
struct cmp{
bool operator() (int a,int b) {return a<b;}
};

main() {

priority_queue <int,vector<int>,cmp > q;

}

Cc hm thnh vin:
-

size : tr v kch thc hin ti ca priority queue. PT O(1)

empty : true nu priority queue rng, v ngc li. PT O(1).
push : y vo priority queue. PT O(logN).
pop: loi b phn t nh priority queue. PT O(logN).
top : tr v phn t nh priority queue. PT O(1).

Chng trnh Demo 1:

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
main() {
STL for newbies iu Xun Mnh D10CN6 PTIT

11

priority_queue <int> p;
p.push(1);
p.push(5);
cout << p.top() << endl;
p.pop();
cout << p.top() << endl;
p.push(9);
cout << p.top() << endl;
system("pause");

//
//
//
//
//
//
//
//

p={}
p={1}
p={1,5}
In ra 5
p={1}
In ra 1
p={1,9}
In ra 9

Chng trnh Demo 2:

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
main() {
priority_queue < int , vector <int> , greater <int> > p;
p.push(1);
// p={1}
p.push(5);
// p={1,5}
cout << p.top() << endl; // In ra 1
p.pop();
// p={5}
cout << p.top() << endl; // In ra 5
p.push(9);
// p={5,9}
cout << p.top() << endl; // In ra 5
system("pause");
}

// p={}

Chng trnh Demo 3:

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
struct cmp{
bool operator() (int a,int b) {return a<b;}
};
main() {
priority_queue < int , vector <int> , cmp > p;
p.push(1);
// p={1}
p.push(5);
// p={1,5}
cout << p.top() << endl; // In ra 1
p.pop();
// p={5}
cout << p.top() << endl; // In ra 5
p.push(9);
// p={5,9}
cout << p.top() << endl; // In ra 5
system("pause");
}

// p={}

8. Set (Tp hp):

- Set l mt loi associative containers lu tr cc phn t khng b trng lp
(unique elements), v cc phn t ny chnh l cc kha (keys).
STL for newbies iu Xun Mnh D10CN6 PTIT

12

- Khi duyt set theo iterator t begin n end, cc phn t ca set s tng dn theo php
ton so snh.
- Mc nh ca set l s dng php ton less, bn cng c th vit li hm so snh theo
mnh.
- Set c thc hin ging nh cy tm kim nh phn (Binary search tree).
Khai bo:
#include <set>
set <int> s;
set <int, greater<int> > s;

Hoc vit class so snh theo mnh:

struct cmp{
bool operator() (int a,int b) {return a<b;}
};
set <int,cmp > myset ;

Capacity:
-

size : tr v kch thc hin ti ca set. PT O(1)

empty : true nu set rng, v ngc li. PT O(1).

Modifiers:
-

insert : Chn phn t vo set. PT O(logN).

erase : c 2 kiu xa: xa theo iterator, hoc l xa theo kha. PT
O(logN).
clear : xa tt c set. PT O(n).
swap : i 2 set cho nhau. PT O(n).

Operations:
-

find : tr v itarator tr n phn t cn tm kim. Nu khng tm

thy itarator tr v end ca set. PT O(logN).
lower_bound : tr v iterator n v tr phn t b nht m khng b
hn (ln hn hoc bng) kha (d nhin l theo php so snh), nu
khng tm thy tr v v tr end ca set. PT O(logN).
upper_bound: tr v iterator n v tr phn t b nht m ln hn
kha, nu khng tm thy tr v v tr end ca set.. PT O(logN).
count : tr v s ln xut hin ca kha trong container. Nhng trong
set, cc phn t ch xut hin mt ln, nn hm ny c ngha l s
return 1 nu kha c trong container, v 0 nu khng c. PT O(logN).

Chng trnh Demo 1:

#include <iostream>
#include <set>
using namespace std;
main() {
set <int> s;
set <int> ::iterator it;
s.insert(9);
s.insert(5);
cout << *s.begin() << endl;
s.insert(1);
cout << *s.begin() << endl;

// s={9}
// s={5,9}
//In ra 5
// s={1,5,9}
// In ra 1

STL for newbies iu Xun Mnh D10CN6 PTIT

13

it=s.find(5);
if (it==s.end()) cout << "Khong co trong container" << endl;
else cout << "Co trong container" << endl;
s.erase(it);
s.erase(1);

// s={1,9}
// s={9}

s.insert(3);
s.insert(4);

// s={3,9}
// s={3,4,9}

it=s.lower_bound(4);
if (it==s.end()) cout << "Khong co phan tu nao trong set khong be hon 4" << endl;
else cout << "Phan tu be nhat khong be hon 4 la " << *it << endl; // In ra 4
it=s.lower_bound(10);
if (it==s.end()) cout << "Khong co phan tu nao trong set khong be hon 10" << endl;
else cout << "Phan tu be nhat khong be hon 10 la " << *it << endl; // Khong co ptu nao
it=s.upper_bound(4);
if (it==s.end()) cout << "Khong co phan tu nao trong set lon hon 4" << endl;
else cout << "Phan tu be nhat lon hon 4 la " << *it << endl;
// In ra 9
/* Duyet set */
for (it=s.begin();it!=s.end();it++) {
cout << *it << " ";
}
// In ra 3 4 9
cout << endl;
system("pause");
}

Lu : Nu bn mun s dng hm lower_bound hay upper_bound tm phn t ln nht

b hn hoc bng hoc b hn bn c th thay i cch so snh ca set tm kim. Mi
bn xem chng trnh sau r hn:
#include <iostream>
#include <set>
#include <vector>
using namespace std;
main() {
set <int, greater <int> > s;
set <int, greater <int> > :: iterator it; // Php ton so snh l greater
s.insert(1);
s.insert(2);
s.insert(4);
s.insert(9);

//
//
//
//

s={1}
s={2,1}
s={4,2,1}
s={9,4,2,1}

/* Tim phn t ln nht b hn hoc bng 5 */

it=s.lower_bound(5);
cout << *it << endl;
// In ra 4
/* Tim phn t ln nht b hn 4 */
it=s.upper_bound(4);
cout << *it << endl;
// In ra 2
system("pause");
}
STL for newbies iu Xun Mnh D10CN6 PTIT

14

9. Mutiset (Tp hp):

- Multiset ging nh Set nhng c th cha cc kha c gi tr ging nhau.
- Khai bo : ging nh set.
- Cc hm thnh vin:
Capacity:
-

size : tr v kch thc hin ti ca multiset. PT O(1)

empty : true nu multiset rng, v ngc li. PT O(1).

Chnh sa:
-

insert : Chn phn t vo set. PT O(logN).

erase :
o xa theo iterator PT O(logN)
o xa theo kha: xa tt c cc phn t bng kha trong multiset
PT: O(logN) + s phn t b xa.
clear : xa tt c set. PT O(n).
swap : i 2 set cho nhau. PT O(n).

Operations:
-

find : tr v itarator tr n phn t cn tm kim. Nu khng tm

thy itarator tr v end ca set. PT O(logN). D trong multiset c
nhiu phn t bng kha th n cng ch iterator n mt phn t.
lower_bound : tr v iterator n v tr phn t b nht m khng b
hn (ln hn hoc bng) kha (d nhin l theo php so snh), nu
khng tm thy tr v v tr end ca set. PT O(logN).
upper_bound: tr v iterator n v tr phn t b nht m ln hn
kha, nu khng tm thy tr v v tr end ca set.. PT O(logN).
count : tr v s ln xut hin ca kha trong multiset. PT O(logN)
+ s phn t tm c.

Chng trnh Demo:

#include <iostream>
#include <set>
using namespace std;
main() {
multiset <int> s;
multiset <int> :: iterator it;
int i;
for (i=1;i<=5;i++) s.insert(i*10);
s.insert(30);
cout << s.count(30) << endl;
cout << s.count(20) << endl;
s.erase(30);

//
//
//
//
//

s={10,20,30,40,50}
s={10,20,30,30,40,50}
In ra 2
In ra 1
s={10,20,40,50}

/* Duyet set */
for (it=s.begin();it!=s.end();it++) {
cout << *it << " ";
}
// In ra 10 20 40 50
cout << endl;
system("pause");
}
STL for newbies iu Xun Mnh D10CN6 PTIT

15

10. Map (nh x):

- Map l mt loi associative container. Mi phn t ca map l s kt hp ca kha
(key value) v nh x ca n (mapped value). Cng ging nh set, trong map khng
cha cc kha mang gi tr ging nhau.
- Trong map, cc kha c s dng xc nh gi tr cc phn t. Kiu ca kha v
nh x c th khc nhau.
- V cng ging nh set, cc phn t trong map c sp xp theo mt trnh t no
theo cch so snh.
- Map c ci t bng red-black tree (cy en) mt loi cy tm kim nh phn
t cn bng. Mi phn t ca map li c ci t theo kiu pair (xem thm th
vin utility).
Khai bo:
#include <map>
...
map <kiu_d_liu_1,kiu_d_liu_2>
// kiu d liu 1 l kha, kiu d liu 2 l gi tr ca kha.

S dng class so snh:

Dng 1:
struct cmp{
bool operator() (char a,char b) {return a<b;}
};
.....
map <char,int,cmp> m;

- Truy cp n gi tr ca cc phn t trong map khi s dng iterator:

V d ta ang c mt iterator l it khai bo cho map th:
(*it).first;
// Ly gi tr ca kha, kiu_d_liu_1
(*it).second; // Ly gi tr ca gi tr ca kha, kiu_d_liu_2
(*it)
// Ly gi tr ca phn t m iterator ang tr n, kiu pair
it->first;
it->second;

// ging nh (*it).first
// ging nh (*it).second

Capacity:
-

size : tr v kch thc hin ti ca map. PT O(1)

empty : true nu map rng, v ngc li. PT O(1).

Truy cp ti phn t:
-

operator [kha]: Nu kha c trong map, th hm ny s tr v gi

tr m kha nh x n. Ngc li, nu kha cha c trong map, th
khi gi [] n s thm vo map kha . PT O(logN)

Chnh sa
-

insert : Chn phn t vo map. Ch : phn t chn vo phi kiu

pair. PT O(logN).
erase :
o xa theo iterator PT O(logN)
o xa theo kha: xa kha trong map. PT: O(logN).
clear : xa tt c set. PT O(n).
STL for newbies iu Xun Mnh D10CN6 PTIT

16

swap : i 2 set cho nhau. PT O(n).

Operations:
-

find : tr v itarator tr n phn t cn tm kim. Nu khng tm

thy iterator tr v end ca map. PT O(logN).
lower_bound : tr v iterator n v tr phn t b nht m khng b
hn (ln hn hoc bng) kha (d nhin l theo php so snh), nu
khng tm thy tr v v tr end ca map. PT O(logN).
upper_bound: tr v iterator n v tr phn t b nht m ln hn
kha, nu khng tm thy tr v v tr end ca map. PT O(logN).
count : tr v s ln xut hin ca kha trong multiset. PT O(logN)

Chng trnh demo:

#include <iostream>
#include <map>
#include <vector>
using namespace std;
main() {
map <char,int> m;
map <char,int> :: iterator it;
m['a']=1;
m.insert(make_pair('b',2));
m.insert(pair<char,int>('c',3) );

// m={{'a',1}}
// m={{'a',1};{'b',2}}
// m={{'a',1};{'b',2};{'c',3}}

cout << m['b'] << endl;

m['b']++;

// In ra 2
// m={{'a',1};{'b',3};{'c',3}}

it=m.find('c');

// it point to key 'c'

cout << it->first << endl;

cout << it->second << endl;

// In ra 'c'
// In ra 3

m['e']=100;
it=m.lower_bound('d');
cout << it->first << endl;
cout << it->second << endl;

//m={{'a',1};{'b',3};{'c',3};{'e',100}}
// it point to 'e'
// In ra 'e'
// In ra 100

system("pause");
}

11. Multi Map (nh x):

Ging nh map nhng c th cha cc phn t c kha ging nhau, do n khc map ch
khng c opearator[].

STL for newbies iu Xun Mnh D10CN6 PTIT

17

III.

STL ALGORITHMS (TH VIN THUT TON):

Khai bo s dng: #include <algorithm>

- Cc hm trong STL Algorithm kh nhiu nn mnh ch gii thiu s qua v mt s
hm hay s dng trong cc bi ton.
- C mt lu nh cho cc bn l khi s dng cc hm m thc hin trong mt on
phn t lin tip no th cc hm trong c++ thung c tc dng trn na on [..).
V d nh: bn mun hm f c tc dng trong on t 1n th cc bn phi gi hm
trong on t 1 n+1.

1. Min, max:
1.1. min: tr v gi tr b hn theo php so snh (mc nh l php ton less):
V d: min(a,b) s return a;
min(3,1) s return 1;
1.2. max th ngc li vi hm min:
V d: max(a,b) s return b
max(3,1) s return 1.
1.3. next_permutation: hon v tip theo. Hm ny s return 1 nu c hon v
tip theo, 0 nu khng c hon v tip theo.
V d:
// next_permutation
#include <iostream>
#include <algorithm>
using namespace std;
int main () {
int myints[] = {1,2,3};
cout << "The 3! possible permutations with 3 elements:\n";
do {
cout << myints[0] << " " << myints[1] << " " << myints[2] << endl;
} while ( next_permutation (myints,myints+3) );
return 0;
}

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

1.4.

prev_permution: ngc li vi next_permutation

STL for newbies iu Xun Mnh D10CN6 PTIT

18

2. Sp xp:
- sort: sp xp on phn t theo mt trnh t no . Mc nh ca sort l s dng
operator <.
- Bn c th s dng hm so snh, hay class so snh t nh ngha sp xp cho linh
hot.
- Chng trnh mu:
// sort algorithm example
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
bool myfunction (int i,int j) { return (i<j); }
struct myclass {
bool operator() (int i,int j) { return (i>j);}
} myobject;
int main () {
int myints[] = {32,71,12,45,26,80,53,33};
// using default comparison (operator <):
sort (myints, myints+4);

//(12 32 45 71)26 80 53 33

// using function as comp

sort (myints+4, myints+8, myfunction);

// 12 32 45 71(26 33 53 80)

for (int i=0;i<8;i++) cout << myints[i] << " ";

cout << endl;
// using object as comp
sort (myints, myints+8, myobject);

//(80 71 53 45 33 32 26 12)

for (int i=0;i<8;i++) cout << myints[i] << " ";

cout << endl;
system("pause");
return 0;
}

3. Tm kim nh phn (cc hm i vi on sp xp):

3.1.

binary_search:

- tm kim xem kha c trong on cn tm khng. Lu : on tm kim phi c sp

xp theo mt trt t nht inh. Nu tm c s return true, ngc li return false.
- Dng 1: binary_search(v tr bt u, v tr kt thc, kha);
- Dng 2: binary_search(v tr bt u, v tr kt thc, kha, php so snh);

STL for newbies iu Xun Mnh D10CN6 PTIT

19

// binary_search example
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
bool myfunction (int i,int j) { return (i<j); }
int main () {
int myints[] = {1,2,3,4,5,4,3,2,1};
vector<int> v(myints,myints+9);

// 1 2 3 4 5 4 3 2 1

// S dng ton t so snh mc nh

sort (v.begin(), v.end());
cout << "looking for a 3... ";
if (binary_search (v.begin(), v.end(), 3))
cout << "found!\n"; else cout << "not found.\n";
// s dng hm so snh t nh ngha:
sort (v.begin(), v.end(), myfunction);
cout << "looking for a 6... ";
if (binary_search (v.begin(), v.end(), 6, myfunction))
cout << "found!\n"; else cout << "not found.\n";
return 0;
}

3.2.

lower_bound:

- Hm lower_bound v upper_bound tng t nh trong container set hay map.

- Tr v iterator n phn t u tin trong na on [first,last] m khng b hn kha
tm kim.
- Dng 1: lower_bound( u , cui , kha );
- Dng 2: lower_bound( u , cui , kha , php ton so snh ca on)
3.3.

upper_bound

- Tr v iterator n phn t u tin trong na on [first,last] m ln hn kha tm

kim.
- Dng 1: upper_bound ( u , cui , kha );
- Dng 2: upper_bound ( u , cui , kha, php ton so snh ca on)
- Chng trnh demo:
// lower_bound/upper_bound example
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main () {
int myints[] = {10,20,30,30,20,10,10,20};
vector<int> v(myints,myints+8);
// 10 20 30 30 20 10 10 20
vector<int>::iterator low,up;

STL for newbies iu Xun Mnh D10CN6 PTIT

20

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

// 10 10 10 20 20 20 30 30

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

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

^
^

cout << "lower_bound at position " << int(low- v.begin()) << endl;
cout << "upper_bound at position " << int(up - v.begin()) << endl;
return 0;
}

Output:
lower_bound at position 3
upper_bound at position 6

IV.

TH VIN STRING C++:

- String l mt kiu c bit ca container, thit k c hot ng vi cc chui k

t.
- Khai bo: #include <string>
- Iterator: Tng t nh trong container, string cng h tr cc iterator nh begin, end,
rbegin, rend vi ngha nh trc.
- Nhp, xut string:
o S dng ton t >> : tng t nh trong C. Nhp n khi gp du cch.
o S dng getline: ging nh gets trong C. Nhp c mt dng k t (cha c du
cch nu c) cho string.
o Xut string: s dng ton t << nh bnh thung.
Cc hm thnh vin:
- Trong string bn c th s dng cc ton t = gn gi tr cho string, hay ton t
+ ni hai string vi nhau, hay ton t ==,!= so snh. Chc nng ny kh
ging vi xu trong ngn ng pascal.
- Capacity:
o size: tr v di ca string
o length: tr v di ca string
o clear : xa string
o empty: return true nu string rng, false nu ngc li
- Truy cp n phn t:
o operator [ch_s]: ly k t v tr ch_s ca string
- Chnh sa:
o push_back: chn k t vo sau string
o insert (n,x): chn x vo string trc v tr th n. x c th l string, char,...
o erase (pos,n): xa khi string n k t bt u t v tr th pos.
o erase (iterator): xa khi string phn t v tr iterator.
o replace (pos, size, s1) : thay th string t v tr pos, s phn t thay th l
size v thay bng xu s1.
STL for newbies iu Xun Mnh D10CN6 PTIT

21

o swap (string_cn_i): i gi tr 2 xu cho nhau.

- String operations:
o c_str : chuyn xu t dng string trong C++ sang string trong C.
o substr (pos,length): return string c trch ra t v tr th pos, v trch ra
length k t.

STL for newbies iu Xun Mnh D10CN6 PTIT

22