├── README.md
├── algorithm.cpp
├── array.cpp
├── deque.cpp
├── list.cpp
├── map.cpp
├── priority_queue.cpp
├── queue.cpp
├── set.cpp
├── stacks.cpp
├── unordered_map.cpp
├── unordered_set.cpp
└── vector.cpp


/README.md:
--------------------------------------------------------------------------------
 1 | # Important CPP(C++) STL functions for competitive programming and other questions
 2 | 
 3 | ### Most of the STL functions are in the [Algorithm](https://github.com/geeky01adarsh/CPP_STL/blob/main/algorithm.cpp) file as it could be applied almost every STL containers.
 4 | 
 5 | ### Find complete hand-written notes with time complexities from [here](https://drive.google.com/file/d/1aDsx8ZYymjhLZm5JwtSmTsaojvucdXzr/view?usp=sharing).
 6 | 
 7 | <h3> C++ STL <h3>
 8 | <ul>
 9 |   <a href="https://github.com/geeky01adarsh/CPP_STL/blob/main/algorithm.cpp"><li><em>Algorithm</em></li></a>
10 |     <ol>
11 |       <li>Binary Search</li>
12 |       <li>Upper/Lower Bound</li>
13 |       <li>min/max</li>
14 |       <li>Reverse/Rotate</li>
15 |       <li>Sort/Swap etc.</li>
16 |     </ol> 
17 |   <li><em>Containers</em></li>
18 |     <ol>
19 |       <li>Sequence Container</li>
20 |         <ul type="star">
21 |            <a href="https://github.com/geeky01adarsh/CPP_STL/blob/main/array.cpp"><li>Array</li></a>
22 |           <a href="https://github.com/geeky01adarsh/CPP_STL/blob/main/vector.cpp"><li>Vector</li></a>
23 |           <a href="https://github.com/geeky01adarsh/CPP_STL/blob/main/deque.cpp"><li>Deque</li></a>
24 |           <a href="https://github.com/geeky01adarsh/CPP_STL/blob/main/list.cpp"><li>List</li></a>
25 |           <li>Forward List</li>
26 |         </ul>
27 |       <li>Container Adaptors</li>
28 |         <ul type="star">
29 |            <a href="https://github.com/geeky01adarsh/CPP_STL/blob/main/stacks.cpp"><li>Stack</li></a>
30 |           <a href="https://github.com/geeky01adarsh/CPP_STL/blob/main/queue.cpp"><li>Queue</li></a>
31 |           <a href="https://github.com/geeky01adarsh/CPP_STL/blob/main/priority_queue.cpp"><li>Priority_Queue</li></a>
32 |         </ul>
33 |       <li>Associative Containers</li>
34 |         <ul>
35 |           <a href="https://github.com/geeky01adarsh/CPP_STL/blob/main/set.cpp"><li>Set</li></a>
36 |           <a href="https://github.com/geeky01adarsh/CPP_STL/blob/main/map.cpp"><li>Map</li></a>
37 |           <li>MultiSet</li>
38 |           <li>MultiMap</li>
39 |         </ul>
40 |       <li>Unordered Associative</li>
41 |         <ul>
42 |           <a href="https://github.com/geeky01adarsh/CPP_STL/blob/main/unordered_set.cpp"><li>Unordered Set</li></a>
43 |           <a href="https://github.com/geeky01adarsh/CPP_STL/blob/main/unordered_map.cpp"><li>Unordered Map</li></a>
44 |           <li>Unordered MultiSet</li>
45 |           <li>Unordered MultiMap</li>
46 |         </ul>
47 |     <ol>
48 |       
49 | </ul>
50 |       
51 | ### Time Complexity and Space complexites for these containers -- [Hand written notes(pdf)](https://drive.google.com/file/d/1aBsuM59ileYqExvXOmK7IAcvjUT7DPre/view?usp=sharing) -- [Digital Copy(pdf)](https://drive.google.com/file/d/1DkKDrURUyOl9OO2N0hHHfZkPxso7Fh9Q/view?usp=sharing)
52 |        
53 | #### Thank You for visiting this repo. Please provide support by staring it.
54 | ##### Feel free to contact me 
55 | [![image](https://user-images.githubusercontent.com/74068552/128004471-32cc18b7-4ce6-4faa-9536-410607433b08.png)
56 | ](adarsh91094@gmail.com)   [![image](https://user-images.githubusercontent.com/74068552/128004564-e85e171a-0869-4c1f-9451-eb49254e8ea9.png)
57 | ](https://www.linkedin.com/in/adarsh-navneet-sinha-34a36419a/)     [![image](https://user-images.githubusercontent.com/74068552/128004703-5babc26d-679a-43a0-8d6b-9e4146d8f65a.png)
58 | ](https://twitter.com/geeky01adarsh)
59 | 


--------------------------------------------------------------------------------
/algorithm.cpp:
--------------------------------------------------------------------------------
 1 | // These algoritms may be applied to most of the stl containers
 2 | // we will implement them in vector here
 3 | #include <iostream>
 4 | #include <algorithm>
 5 | #include <vector>
 6 | 
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 |     vector<int> v;
12 |     v.push_back(2);
13 |     // v.push_back(5);
14 |     v.push_back(4);
15 |     v.push_back(1);
16 |     v.push_back(6);
17 |     v.push_back(3);
18 |     v.push_back(7);
19 | 
20 |     // binary search - to search if an element is present
21 |     cout << "Check if 6 is present in vector- ";
22 |     cout << binary_search(v.begin(), v.end(), 6) << endl;
23 | 
24 |     // lower bound:- The element just greater than given element
25 |     cout << "The lower bound for 5 is ";
26 |     cout << lower_bound(v.begin(), v.end(), 5) - v.begin() << endl;
27 | 
28 |     // upper bound:- The element just smaller than the given element
29 |     cout << "The upper bound for 5 is ";
30 |     cout << upper_bound(v.begin(), v.end(), 6) - v.begin() << endl;
31 | 
32 |     // maximum of two number
33 |     int a = 8, b = 10;
34 |     cout << "Maximum of " << a << " and " << b << " is " << max(a, b) << endl;
35 | 
36 |     // minimum of two no.
37 |     cout << "Minimum of " << a << " and " << b << " is " << min(a, b) << endl;
38 | 
39 |     // swap function to replace the value among themselves
40 |     cout << "Earlier a=" << a << " and b=" << b << endl;
41 |     swap(a, b);
42 |     cout << "Now a=" << a << " and b=" << b << endl;
43 | 
44 |     // reverse the container
45 |     cout << "Before reversing vector : ";
46 |     for (auto i : v)
47 |         cout << i << " ";
48 |     cout << endl;
49 |     // calling the reverse function
50 |     reverse(v.begin(), v.end());
51 |     cout << "After reversing vector : ";
52 |     for (auto i : v)
53 |         cout << i << " ";
54 |     cout << endl;
55 | 
56 |     // rotate - it will rotate by provided position
57 |     cout << "Before rotating vector : ";
58 |     for (auto i : v)
59 |         cout << i << " ";
60 |     cout << endl;
61 |     // calling the rotate function
62 |     rotate(v.begin(), v.begin() + 1, v.end());
63 |     cout << "After rotating vector by 1 : ";
64 |     for (auto i : v)
65 |         cout << i << " ";
66 |     cout << endl;
67 | 
68 |     // sorting the container
69 |     // it is based on intro sort(quick sort + heap sort + insertion sort)
70 |     cout << "Before sorting vector : ";
71 |     for (auto i : v)
72 |         cout << i << " ";
73 |     cout << endl;
74 |     // calling the rotate function
75 |     sort(v.begin(), v.end());
76 |     cout << "After sorting vector  : ";
77 |     for (auto i : v)
78 |         cout << i << " ";
79 |     cout << endl;
80 | 
81 |     return 0;
82 | }
83 | 


--------------------------------------------------------------------------------
/array.cpp:
--------------------------------------------------------------------------------
 1 | // array using stl function can do much more task and have a good library support
 2 | 
 3 | #include <iostream>
 4 | #include <array>
 5 | 
 6 | using namespace std;
 7 | 
 8 | int main()
 9 | {
10 | 
11 |     // declaration
12 |     array<int, 4> a;
13 |     // assigning values
14 |     for (int i = 0; i < 4; i++)
15 |     {
16 |         cin >> a[i];
17 |     }
18 |     // declaration and assigning value
19 |     array<int, 4> arr = {1, 2, 3, 4};
20 | 
21 |     // printing the array
22 |     for (int i = 0; i < 4; i++)
23 |     {
24 |         cout << a[i] << " ";
25 |     }
26 |     cout << endl;
27 |     for (int i = 0; i < 4; i++)
28 |     {
29 |         cout << arr[i] << " ";
30 |     }
31 |     cout << endl;
32 | 
33 |     // finding the size of the array
34 |     cout << a.size() << " " << arr.size() << endl;
35 | 
36 |     // accessing any element at given potion
37 |     cout << a[3] << " " << a.at(3) << endl;
38 | 
39 |     // checking if the array is empty
40 |     cout << "Is array a empty ? " << a.empty() << endl;
41 | 
42 |     // excessing first and last element
43 |     cout << arr.front() << " " << arr.back() << endl;
44 | 
45 |     return 0;
46 | }


--------------------------------------------------------------------------------
/deque.cpp:
--------------------------------------------------------------------------------
 1 | // deque is also know as doubly ended queue
 2 | 
 3 | #include <iostream>
 4 | #include <deque>
 5 | 
 6 | using namespace std;
 7 | 
 8 | int main()
 9 | {
10 |     // declaration
11 |     deque<int> dq;
12 | 
13 |     // assigning value
14 |     // we can enter value in doubly ended queue both from front and back
15 |     dq.push_back(1);
16 |     dq.push_back(2);
17 |     dq.push_back(3);
18 |     dq.push_back(4);
19 |     dq.push_back(5);
20 |     dq.push_front(0);
21 | 
22 |     // printing the deque
23 |     for (auto i : dq)
24 |         cout << i << " ";
25 |     cout << endl<<endl;
26 | 
27 |     // excessing the ith element from a deque
28 |     cout << dq[1] << " " << dq.at(1) << endl<<endl;
29 | 
30 |     // removing elements from deque
31 |     // we can remove the elements both from front and back
32 |     dq.pop_back();
33 |     dq.pop_front();
34 |     // checking our functions
35 |     for (auto i : dq)
36 |         cout << i << " ";
37 |     cout << endl<<endl;
38 | 
39 |     // front and back elements
40 |     cout<<"Front and back elements are ";
41 |     cout << dq.front() << " and " << dq.back() << endl<<endl;
42 | 
43 |     // to check if our deques is empty or not;
44 |     cout << "Is the deque empty? " << dq.empty() << endl<<endl;
45 | 
46 |     // first and last+1 iterators
47 |     cout <<"First and last element using pointers"<<endl<<*dq.begin() << " " << *(dq.end() - 1) << endl<<endl;
48 | 
49 |     // size of the deque
50 |     cout<<"The size of deque is "<<dq.size()<<endl<<endl; 
51 | 
52 |     // deleting all elements of deque or selection of elements
53 |     dq.erase(dq.begin()+2,dq.end());
54 |     cout<<"After deleting all elements except the first 2"<<endl;
55 |     cout<<"The size of deque is "<<dq.size()<<endl; 
56 |     cout << "Is the deque empty? " << dq.empty() << endl<<endl;
57 |     dq.erase(dq.begin(),dq.end());
58 |     cout<<"\nAfter deleting all elements"<<endl;
59 |     cout<<"The size of deque is "<<dq.size()<<endl; 
60 |     cout << "Is the deque empty? " << dq.empty() << endl;
61 | 
62 |     return 0;
63 | }


--------------------------------------------------------------------------------
/list.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <list>
 3 | 
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     // declaration
 9 |     list<int> ls;
10 | 
11 |     // assigning values
12 |     ls.push_back(1);
13 |     ls.push_back(3);
14 |     ls.push_back(2);
15 |     ls.push_back(4);
16 |     ls.push_front(0);
17 |     // printing a list
18 |     for (auto i : ls)
19 |         cout << i << " ";
20 |     cout << endl;
21 | 
22 |     // declaration with given dingle value
23 |     list<int> l(5, 10);
24 |     cout << "this list will print like this ";
25 |     for (auto i : l)
26 |         cout << i << " ";
27 |     cout << endl;
28 | 
29 |     // deleting the first element
30 |     ls.erase(ls.begin());
31 |     cout << "After deleting first element  : ";
32 |     for (auto i : ls)
33 |         cout << i << " ";
34 |     cout << endl;
35 | 
36 |     // deleting the first or the last element
37 |     ls.pop_back();
38 |     ls.pop_front();
39 |     cout << "After deleting front and back element  : ";
40 |     for (auto i : ls)
41 |         cout << i << " ";
42 |     cout << endl;
43 | 
44 |     // size of the list
45 |     cout << "The size of the list is " << ls.size() << endl;
46 | 
47 |     // iterators
48 |     cout << "front and back iterators are " << *ls.begin() << " ls.end()" << endl;
49 | 
50 |     return 0;
51 | }


--------------------------------------------------------------------------------
/map.cpp:
--------------------------------------------------------------------------------
 1 | // stores in key-value pair
 2 | // all kyes are unique
 3 | // stored in sorted order
 4 | 
 5 | #include <iostream>
 6 | #include <map>
 7 | 
 8 | using namespace std;
 9 | 
10 | int main(){
11 |     // declaration
12 |     map<int,string> mp;
13 | 
14 |     // assigning values
15 |     // m[key]=value
16 |     mp[1]="Adarsh";
17 |     mp[2]="Navneet";
18 |     mp[30]="Sinha";
19 | 
20 |     // inserting elements using insert function
21 |     mp.insert({5,"geeky01adarsh"});
22 | 
23 |     // printing the map
24 |     for(auto i:mp){
25 |         cout<<"key = "<<i.first<<" and its value = "<<i.second<<endl;
26 |     }
27 |     cout<<endl;
28 | 
29 |     // to check if an element is present or not(time-- O(log n))
30 |     cout<<"Is 13 present in map? "<<mp.count(13)<<endl;
31 | 
32 |     // to return iterator where any element is present(time-- O(log n))
33 |     mp.find(1);
34 |     
35 |     // deleting any key-value pair
36 |     // takes key name as argument
37 |     mp.erase(2);
38 |     // checking the map
39 |     for(auto i:mp){
40 |         cout<<"key = "<<i.first<<" and its value = "<<i.second<<endl;
41 |     }
42 |     cout<<endl;
43 | 
44 | 
45 |     return 0;
46 | }


--------------------------------------------------------------------------------
/priority_queue.cpp:
--------------------------------------------------------------------------------
 1 | // it works on max heap and min heap
 2 | // i.e. it stores values in sorted order either increasing or decreasing
 3 | 
 4 | #include <iostream>
 5 | #include <queue>
 6 | 
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 |     // decreasing order implementation
12 |     priority_queue<int> maxi;
13 | 
14 |     // increasing order implementaion
15 |     priority_queue<int, vector<int>, greater<int>> mini;
16 | 
17 |     // putting the same values in both the queues
18 |     // pushing values to maxi(max heap)
19 |     maxi.push(5);
20 |     maxi.push(7);
21 |     maxi.push(1);
22 |     maxi.push(2);
23 |     maxi.push(9);
24 |     // pushing value to mini
25 |     mini.push(5);
26 |     mini.push(7);
27 |     mini.push(1);
28 |     mini.push(2);
29 |     mini.push(9);
30 | 
31 |     // empty function
32 |     cout << "Is maxi empty? " << maxi.empty() << endl;
33 | 
34 |     // size fuction
35 |     cout << "The size of maxi is " << maxi.size() << endl;
36 |     cout << "The size of mini is " << mini.size() << endl;
37 | 
38 |     // printing the maxi(max heap)
39 |     cout << "Printing the maxi ";
40 |     int n = maxi.size();
41 |     for (int i = 0; i < n; i++)
42 |     {
43 |         cout << maxi.top() << " ";
44 |         maxi.pop();
45 |     }
46 |     cout << endl;
47 |     cout << "Is maxi empty now? " << mini.empty() << endl;
48 | 
49 |     // printing the mini(min heap)
50 |     cout << "Printing the mini ";
51 |     n = mini.size();
52 |     for (int i = 0; i < n; i++)
53 |     {
54 |         cout << mini.top() << " ";
55 |         mini.pop();
56 |     }
57 | 
58 |     return 0;
59 | }


--------------------------------------------------------------------------------
/queue.cpp:
--------------------------------------------------------------------------------
 1 | // It works on the FIFO methodology
 2 | 
 3 | #include <iostream>
 4 | #include <queue>
 5 | 
 6 | using namespace std;
 7 | 
 8 | int main(){
 9 |     // declaration
10 |     queue<int> q;
11 | 
12 |     // assigning values 
13 |     q.push(1);
14 |     q.push(2);
15 |     q.push(3);
16 |     q.push(4);
17 |     q.push(5);
18 | 
19 |     // size of queue
20 |     cout<<"The size of queue is "<<q.size()<<endl;
21 | 
22 |     // empty or not
23 |     cout<<"Is the queue empty? "<<q.empty()<<endl;
24 | 
25 |     // printing the first element
26 |     cout<<"The first element is "<<q.front()<<endl;
27 | 
28 |     // deleting the first element
29 |     q.pop();
30 |     cout<<"Now after deleting prev first, the first element is "<<q. front()<<endl;
31 | 
32 |     // printing the entire queue
33 |     cout<<"Printing the entire queue : ";
34 |     int n = q.size();
35 |     for(int i=0; i<n; i++){
36 |         cout<<q.front()<<" ";
37 |         q.pop();
38 |     }
39 |     cout<<endl;
40 | 
41 | 
42 |     return 0;
43 | }


--------------------------------------------------------------------------------
/set.cpp:
--------------------------------------------------------------------------------
 1 | // In set, only unique elements are stored
 2 | // Implemented using BST
 3 | // Modification of elements is allowed
 4 | // Stores element in sorted order
 5 | 
 6 | #include <iostream>
 7 | #include <set>
 8 | 
 9 | using namespace std;
10 | 
11 | int main()
12 | {
13 |     // declaration
14 |     set<int> s;
15 | 
16 |     // inserting elements takes O(log n) time
17 |     s.insert(1);
18 |     s.insert(7);
19 |     s.insert(8);
20 |     s.insert(2);
21 |     s.insert(5);
22 | 
23 |     // printing the set
24 |     set<int, greater<int>>::iterator itr;
25 |     for (itr = s.begin(); itr != s.end(); itr++)
26 |     {
27 |         cout << *itr << " ";
28 |     }
29 |     cout << endl;
30 | 
31 |     // finding any elements require O(log n)
32 |     // "find" function returns the iterator in O(log n)
33 |     cout << "Print 5 if present ";
34 |     cout << *s.find(5) << endl;
35 |     // "count" function returns bool value in O(log n) time
36 |     cout << "Is 9 present in the set? " << s.count(9) << endl;
37 | 
38 |     // deleting all elements in the set
39 |     cout << "Is the set empty? " << s.empty() << endl;
40 |     s.clear();
41 |     cout << "Is the set empty now? " << s.empty() << endl;
42 | 
43 |     return 0;
44 | }


--------------------------------------------------------------------------------
/stacks.cpp:
--------------------------------------------------------------------------------
 1 | // works on lifo methodology
 2 | 
 3 | #include <iostream>
 4 | #include <stack>
 5 | 
 6 | using namespace std;
 7 | 
 8 | int main(){
 9 |     // declaration
10 |     stack<string> st;
11 | 
12 |     // assigning value
13 |     st.push("Adarsh");
14 |     st.push("Navneet");
15 |     st.push("Sinha");
16 | 
17 |     // printing our stack
18 |     cout<<"top element is "<<st.top()<<endl;
19 | 
20 |     // size of stack
21 |     cout<<"size of stack is "<<st.size()<<endl;
22 | 
23 |     // stack is empty or not
24 |     cout<<"Is the stack empty?"<<st.empty()<<endl;
25 | 
26 |     // removing the top element
27 |     st.pop();
28 |     cout<<"Now the top is "<<st.top()<<endl;
29 | 
30 |     // printing the complete stack
31 |     // inserting new elements
32 |     st.push("Computer");
33 |     st.push("Science");
34 |     st.push("Engineering");
35 |     int n = st.size();
36 |     cout<<"The complete stack is ";
37 |     for(int i=0; i<n; i++){
38 |         cout<<st.top()<<" ";
39 |         st.pop();
40 |     }
41 |     cout<<endl;
42 | 
43 |     return 0;
44 | }


--------------------------------------------------------------------------------
/unordered_map.cpp:
--------------------------------------------------------------------------------
 1 | // stores in key-value pair
 2 | // all kyes are not unique
 3 | // not stored in sorted order
 4 | 
 5 | #include <iostream>
 6 | #include <unordered_map>
 7 | 
 8 | using namespace std;
 9 | 
10 | int main(){
11 |     // declaration
12 |     unordered_map<int,string> um;
13 | 
14 |     // assigning values
15 |     // m[key]=value
16 |     um[1]="Adarsh";
17 |     um[2]="Navneet";
18 |     um[30]="Sinha";
19 | 
20 |     // inserting elements using insert function
21 |     um.insert({5,"geeky01adarsh"});
22 | 
23 |     // printing the map
24 |     for(auto i:um){
25 |         cout<<"key = "<<i.first<<" and its value = "<<i.second<<endl;
26 |     }
27 |     cout<<endl;
28 | 
29 |     // to check if an element is present or not(time-- O(1))
30 |     cout<<"Is 13 present in map? "<<um.count(13)<<endl;
31 | 
32 |     // to return iterator where any element is present(time-- O(1))
33 |     um.find(1);
34 |     
35 |     // deleting any key-value pair
36 |     // takes key name as argument
37 |     um.erase(2);
38 |     // checking the map
39 |     for(auto i:um){
40 |         cout<<"key = "<<i.first<<" and its value = "<<i.second<<endl;
41 |     }
42 |     cout<<endl;
43 | 
44 | 
45 |     return 0;
46 | }


--------------------------------------------------------------------------------
/unordered_set.cpp:
--------------------------------------------------------------------------------
 1 | // Implemented using BST
 2 | // Modification of elements is allowed
 3 | 
 4 | #include <iostream>
 5 | #include <unordered_set>
 6 | 
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 |     // declaration
12 |     unordered_set<int> ust;
13 | 
14 |     // inserting elements takes O(1) time
15 |     ust.insert(1);
16 |     ust.insert(7);
17 |     ust.insert(8);
18 |     ust.insert(2);
19 |     ust.insert(5);
20 | 
21 |     // printing the set
22 |     unordered_set<int> :: iterator itr;
23 |     for (itr = ust.begin(); itr != ust.end(); itr++)
24 |     {
25 |         cout << *itr << " ";
26 |     }
27 |     cout << endl;
28 | 
29 |     // finding any elements require O(1)
30 |     // "find" function returns the iterator in O(1)
31 |     cout << "Print 5 if present ";
32 |     cout << *ust.find(5) << endl;
33 |     // "count" function returns bool value in O(1) time
34 |     cout << "Is 9 present in the set? " << ust.count(9) << endl;
35 | 
36 |     // deleting all elements in the set
37 |     cout << "Is the set empty? " << ust.empty() << endl;
38 |     ust.clear();
39 |     cout << "Is the set empty now? " << ust.empty() << endl;
40 | 
41 |     return 0;
42 | }


--------------------------------------------------------------------------------
/vector.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | using namespace std;
 4 | 
 5 | int main()
 6 | {
 7 |     // declaration
 8 |     vector<int> v;
 9 | 
10 |     // assigning values
11 |     for (int i = 0; i < 5; i++)
12 |     {
13 |         int temp;
14 |         cin >> temp;
15 |         // adding the input to our vector
16 |         v.push_back(temp);
17 |     }
18 | 
19 |     // printing the vector
20 |     for (auto i : v)
21 |         cout << i << " ";
22 |     cout << endl;
23 | 
24 |     // with same given values
25 |     vector<int> a(5, 1);
26 |     // checking our vector
27 |     for (auto i : a)
28 |         cout << i << " ";
29 |     cout << endl;
30 | 
31 |     // coping one vector in different one
32 |     vector<int> last(a);
33 |     // checking our vector
34 |     for (auto i : last)
35 |         cout << i << " ";
36 |     cout << endl;
37 | 
38 |     // size of the vector
39 |     cout << v.size() << endl;
40 | 
41 |     // capacity of the vector
42 |     // how much place in vector is currently empty(not filled)
43 |     cout << v.capacity() << endl;
44 | 
45 |     // excessing certain element at any index
46 |     cout << v[1] << " " << v.at(1) << endl;
47 | 
48 |     // rempving the last element from the vector
49 |     v.pop_back();
50 |     // checking our fuction
51 |     for (auto i : v)
52 |         cout << i << " ";
53 |     cout << endl;
54 | 
55 |     // front and back elements
56 |     cout << v.front() << " " << v.back() << endl;
57 | 
58 |     // iterators(pointers for first and last+1 element)
59 |     cout << *v.begin() << " " << *(v.end() - 1) << endl;
60 | 
61 |     // deleting all elements of vector
62 |     v.clear();
63 |     // size changes to 0 but the capacity remains the same
64 |     cout << "SIZE : " << v.size() << endl
65 |          << "CAPACITY : " << v.capacity() << endl;
66 | 
67 |     // to check if our vector is empty or not
68 |     cout << "Is the vector-a empty? " << a.empty() << endl;
69 |     cout << "Is the vector-v empty? " << v.empty() << endl;
70 | 
71 |     return 0;
72 | }


--------------------------------------------------------------------------------