Basic ADTs in STL

1. Basic ADTs in STL What are ADTs, STL Intro, vector, list, queue, stack Learning & Development Team http://academy.telerik.com Telerik Software Academy

2. Table of Contents • Basic Abstract Data Types • List • Linked List • Stack • Queue • ADTs in STL • STL Intro • Iterators • Vector, list, stack, queue

3. Basic Data Structures Abstract Data Types

4. 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 Abstract Data Types

5. 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 search/insert Basic Data Structures

6. Lists

7. Data structure (container) that containsa 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) Using resizable array The List ADT

8. Implemented by an array Direct access by index (fast) Insertion and deletion and resizing are slow operations Static List 0 1 2 3 4 5 6 7 L

9. 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 endor beginning Linked List null head

10. Stacks

11. 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 implementation) The Stack ADT

12. Queues

13. 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) The Queue ADT

14. Standard Template Library Introduction, Basic ADT Implementations

15. 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

16. 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 • Used to "traverse" containers

17. 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 to act over elements (elements passed as parameters)

18. STL Introduction Live Demo

19. STL Iterators Mechanism for traversing container elements

20. STL Iterators • "Smart" pointers to objects • Specific for each container type • Each container defines how it’s iterators work • If we have an iterator to one element • Increase/decrease it to get the other elements • Types: • Input, Output • Forward iterator, Bidirectional iterator • Random access iterator

21. STL Containers Fast data structures to store elements

22. 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: • sequence, adaptors, associative

23. Basic STL Containers Vector, List, Deque, Queue, Stack

24. 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

25. STL Vector • Declaring and initializing a vector • Vector size and is obtained by calling size() #include<vector> //required header … vector<int> numbers; numbers.push_back(42); //numbers is now {42} numbers.push_back(13); //numbers is now {42, 13} intconsoleNumber; cin>>consoleNumber; numbers.push_back(consoleNumber) vector<int> numbers; numbers.push_back(42); numbers.push_back(13); cout<<numbers.size(); //prints 2

26. STL Vector • Accessing vector elements • Done the same way as with arrays, i.e. [] • Traversing a vector is the same as traversing an array (e.g. with a for loop) • Element access does not depend on vector size 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

27. STL vector Live Demo

28. 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

29. STL (Linked) List • Declaring and initializing a list • List size and is obtained by calling size() • List elements can be removed from front and back fast list<int> numbers; numbers.push_back(2); numbers.push_front(1); numbers.push_back(3); numbers.pop_front(); numbers.pop_back();

30. STL (Linked) List • Accessing list elements • front and back methods provide first and last element access • Only way to get access to all elements – traversal by iterator cout<<numbers.front(); cout<<numbers.back(); list<int>::iterator numbersIterator; for(numbersIterator = numbers.begin(); numbersIterator != numbers.end(); numbersIterator++) { cout<<*numbersIterator<<endl; }

31. STL list Live Demo

32. 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

33. STL Queue • Declaring and initializing a queue • Queue size is obtained by calling size() • Queues allow removing elements only from the front of the sequence queue<int> q; q.push(1); q.push(2); q.push(3); q.pop();

34. STL Queue • Accessing queue elements • front and back methods provide first and last element access • Other types of access to queue elements are meaningless • The idea of the queue is to restrict access and be FIFO cout<<q.front(); cout<<q.back();

35. STL queue Live Demo

36. 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

37. STL Stack • Declaring and initializing a stack • Stack size is obtained by calling size() • Stacks allow removing elements only from the back (top) of the sequence stack<int> s; s.push(1); s.push(2); s.push(3); s.pop();

38. STL Stack • Accessing stack elements • top method provides first element access • Other types of access to stack elements are meaningless • The idea of the stack is to restrict access and be LIFO cout<<s.top();

39. STL stack Live Demo

40. Basic ADTs in STL http://algoacademy.telerik.com

41. Exercises • …