Basic ADTs in STL

What are ADTs,

STL Intro, vector, list, queue, stack

Telerik Software
Academy
Learning &
http://academy.telerik.com
Development Team
 Table of Contents
1. Basic Abstract Data Types
1.List
2.Linked List
3.Stack
4.Queue
2. ADTs in STL
1.STL Intro
2.Iterators
3.Vector, list, stack, queue 2
Abstract Data
Types
Basic Data Structures
 Abstract Data Types
An Abstract Data Type (ADT) is a
data type together with the
operations, whose properties are
specified independently of any
particular implementation
ADT are set of definitions of
operations
Can have several different
implementations
Different implementations can have
different efficiency
 Basic Data Structures
Linear structures
Lists: fixed size and variable size
Stacks: LIFO (Last In First Out)
structure
Queues: FIFO (First In First Out)
structure
Trees
Binary, ordered, balanced, etc.
Dictionaries (maps)
Contain pairs (key, value)
Hash tables: use hash functions to
Lists
 The List ADT
Data structure (container) that
contains
a sequence of elements
Can have variable size
Elements are arranged linearly, in
sequence
Can be implemented in several
ways
Statically (using array fixed size)
Dynamically (linked
implementation)
 Static List
Implemented by an array
Direct access by index (fast)
Insertion and deletion and resizing
are slow operations

0 1 2 3 4 5 6 7
L 1 1 1
2 7 3 6 9
8 2 1
 Linked List
Dynamic (pointer-based)
implementation
Direct access to first/last element
No access by index
go through all previous elements
(slow)
Insertion and deletion are fast
Resizing add new element at the
end or beginning
2 7 4 5 null

head nex nex nex nex

t t t t
Stacks
 The Stack ADT
LIFO (Last In First Out) structure
Elements inserted (push) at top
Elements removed (pop) from
top
Useful in many situations

E.g. the execution stack of the

program
Can be implemented in several
ways
Statically (using array)
Dynamically (linked
Queues
 The Queue ADT
FIFO (First In First Out) structure
Elements inserted at the tail
(Enqueue)
Elements removed from the head
(Dequeue)
Useful in many situations

Print queues, message queues, etc.

Can be implemented in several
ways
Statically (using array)
Dynamically (using pointers)
Standard Template
Library
Introduction, Basic ADT
Implementations
 STL Introduction
Standard Template Library
C++ Library
Implements a lot of computer
science fundamentals
Container classes, Algorithms
Iterators
Mostly template-based
Algorithms decoupled from
containers through iterators

15
 STL Introduction
Containers
Data structures, hold collections of
elements
Different benefits and downsides
Implement fundamental Abstract
Data Types
Sequence, Associative, String,
Adaptors
Iterators
Provide access to container
elements
16
 STL Introduction
Algorithms
Fundamental algorithms over
collections or single
Hook up with iterators to access
container elements
Function objects
Wrap functions/methods into
objects
Implement () operator called like
functions
Called by algorithms and containers
17
STL Introduction
Live Demo
 STL Iterators
Mechanism for traversing container
elements
 STL Iterators
"Smart" pointers to objects
Specific for each container type

Each container defines how its

iterators work
If we have an iterator to one
element
Increase/decrease it to get the
other elements
Types:
Input, Output
Forward iterator, Bidirectional 20
 STL Containers
Fast data structures to store elements
 STL Containers
Store collections of other objects
Has methods to access elements

Types

By traversability:
Forward elements ordered, Forward
Iterators
Reversible have Bidirectional
iterators
Random access have Random
access iterators
By storage:
22
Basic STL Containers
Vector, List, Deque, Queue, Stack
 STL Vector
Vector (#include <vector>)
Defined: template <class T> vector
Sequence, Random Access
Stores a sequence of elements in
contiguous memory
Manages memory effectively
Fast at retrieving elements by index
and adding elements at the end
Slow insertion/deletion in middle or
beginning

24
 STL Vector
Declaring and initializing a vector
#include<vector> //required header

vector<int> numbers;
numbers.push_back(42); //numbers is now {42}
numbers.push_back(13); //numbers is now {42, 13}
int consoleNumber; cin>>consoleNumber;
numbers.push_back(consoleNumber)
Vector size and is obtained by
calling size()
vector<int> numbers;
numbers.push_back(42);
numbers.push_back(13);
cout<<numbers.size(); //prints 2
 STL Vector
Accessing vector elements
Done the same way as with arrays,
i.e. []
vector<int> numbers;
numbers.push_back(42);
numbers.push_back(13);
cout<<numbers[1]; //prints 13
cout<<endl;
numbers[1] = numbers[0];
cout<<numbers[1]; //prints 42

Traversing a vector is the same as

traversing an array (e.g. with a for
loop)
Element access does not depend on
STL vector
Live Demo
 STL (Linked) List
List (#include <list>)
Defined: template <class T> list
Sequence, Reversible
Stores a sequence of elements in a
doubly-linked list
Fast at deletion/insertion anywhere
No random access to elements
Have to traverse list to get to an
item

28
 STL (Linked) List
Declaring and initializing a list
list<int> numbers;

numbers.push_back(2);
numbers.push_front(1);
numbers.push_back(3);

List size and is obtained by calling

size()
List elements can be removed from
front and back fast
numbers.pop_front();
numbers.pop_back();
 STL (Linked) List
Accessing list elements
front and back methods provide
first and last element access
cout<<numbers.front();
cout<<numbers.back();
Only way to get access to all
elements traversal by iterator
list<int>::iterator numbersIterator;
for(numbersIterator = numbers.begin();
numbersIterator != numbers.end();
numbersIterator++)
{
cout<<*numbersIterator<<endl;
}
STL list
Live Demo
 STL Queue
Queue (#include<queue>)
Defined: template <class T> queue
Sequence Adaptor
First in, First out structure (FIFO)
Stores a sequence of elements
Provides access only to first
element
Can remove only at front
Can add only at back

32
 STL Queue
Declaring and initializing a queue
queue<int> q;

q.push(1);
q.push(2);
q.push(3);

Queue size is obtained by calling

size()
Queues allow removing elements
only from the front of the sequence
q.pop();
 STL Queue
Accessing queue elements
front and back methods provide
first and last element access
cout<<q.front();
cout<<q.back();
Other types of access to queue
elements are meaningless
The idea of the queue is to restrict
access and be FIFO
STL queue
Live Demo
 STL Stack
Stack (#include <stack>)
Defined: template <class T> stack
Sequence adaptor
Last in, First out structure (LIFO)
Stores a sequence of elements
Provides access only to last element
Can remove or add elements only at
back/top

36
 STL Stack
Declaring and initializing a stack
stack<int> s;

s.push(1);
s.push(2);
s.push(3);

Stack size is obtained by calling

size()
Stacks allow removing elements
only from the back (top) of the
s.pop();
sequence
 STL Stack
Accessing stack elements
top method provides first element
access
cout<<s.top();

Other types of access to stack

elements are meaningless
The idea of the stack is to restrict
access and be LIFO
STL stack
Live Demo
 Basic ADTs in STL
?
?
?
?

?
?

?
? ?

Questions?
?

?
?
?

?
?
? ?
?
?

, BG Coder - - online judge

,

http://algoacademy.tele
ASP.NET - , , C#, .NET, ASP.NET
ASP.NET MVC HTML, SQL, C#, .NET, ASP.NET MVC
SEO - ,
, iPhone, Android, W P7, PhoneGap
, HTML, CSS, JavaScript, Photoshop -
free C# book, C#, Java, C# -
" "
" cloud " C# , ,
 Exercises
1.

41