## is_sorted in O(log n) time

Checking if array is sorted is simple, compare consecutive elements to check if next element is greater than the previous element. This takes O(n) time. The possible implementation of std::is_sorted is given as follows:

```template <class ForwardIterator>
bool is_sorted (ForwardIterator first, ForwardIterator last)
{
if (first==last) return true;
ForwardIterator next = first;
while (++next!=last) {
if (*next<*first) // or, if (comp(*next,*first)) for version (2)
return false;
++first;
}
return true;
}```

Here I came with an algorithm which is like quick sort and uses O(log n) time. Here is the implementation.

```#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

template <typename T>
bool check_sorted(T start, T finish, bool sorted = true){
if(start == finish) return true;

if(std::next(start) == finish) return *start <= *finish;

T middle = start;

sorted &= check_sorted(start, middle);
sorted &= check_sorted(middle, finish-1);
return sorted;
}

int main(){
std::vector<int> v(20);
std::iota(v.begin(), v.end(), 1);
bool sorted = check_sorted(v.begin(), v.end());
std::cout << "v is sorted? : " << sorted << '\n';

std::vector<int> v2 {20, 1, 3, 5, 2, 1, 4, 19, 18, 10};
sorted = check_sorted(v2.begin(), v2.end());
std::cout << "v2 is sorted?: " << sorted << '\n';

std::vector<int> v3 {1,1,1,1,1,1,1,1,1,1,1,1,1,1};
sorted = check_sorted(v3.begin(), v3.end());
std::cout << "v3 is sorted?: " << sorted << '\n';

std::vector<int> v4 {10,1,1,1,1,1,1,1,1,1,1,1,1,1};
sorted = check_sorted(v4.begin(), v4.end());
std::cout << "v4 is sorted?: " << sorted << '\n';
}```

## Remove dups in sorted vector

To remove duplicates of an array, use a hash map and array elements as keys, then extract keys. This requires extra space for storing the hash and time. Following algorithm does not need any extra space and time.

The algorithm is uses 3 iterators and moves the duplicate elements at the start of vector and erases the rest of vector. Pseudo code given as follows:

1. take iterator ​`​start` that points to beginning of vector.
2. take another iterator `i` that points to next element to start.
3. move  i to next index until elements are duplicate.
5. at the end erase elements from start+1 to end from vector.
```#include <iostream>  // std::cout
#include <vector>
#include <cstdlib>  // std::srand
#include <ctime>    // std::time

int main(){
std::vector<int> v(100);
std::srand(std::time(nullptr)); // use current time as seed for random generator

// generate 1000 random numbers between 0 to 99
for(int i = 0; i < 1000; i++){
int random_variable = std::rand()%100;
v.push_back(random_variable);
std::cout << random_variable << ' ';
}

// sort
std::sort(v.begin(), v.end());

std::vector<int>::iterator start = v.begin();
std::vector<int>::iterator end = v.end();
auto i = start+1; // std::vector<int>::iterator i = start+1;
while(i != end-1){
if(*start == *i){
i++;
}else{
start++;
*start = *i;
}
}

v.erase(start+1, end);
for(const auto & i:v) std::cout << i << ' ';
}```

## Quick Sort using iterators

Lately I have been experimenting various algorithms using std iterators and tried to implement quick sort algorithm using just iterators instead of passing on the vector by reference. Following is the implementation of the algorithm.

```#include <vector>
#include <iostream>
#include <algorithm>

auto partition(std::vector<int>::iterator start, std::vector<int>::iterator end_it){
auto partition_idx = start;
for(auto i = start; i != end_it; i++){
if(*i <= *end_it){
std::iter_swap(i, partition_idx);
partition_idx++;
}
}
std::iter_swap(partition_idx, end_it);
return partition_idx;
}

void quick_sort(std::vector<int>::iterator start, std::vector<int>::iterator end_it){
int size = std::distance(start, end_it);
if (size <= 1) return;
auto partition_idx = partition(start, end_it);
quick_sort(start, partition_idx-1);
quick_sort(partition_idx, end_it);
}

int main(){
std::vector<int> v{72, 23, 65, 53, 36, 90, 76, 50, 1, 20, 64, 18, 26, 39, 34, 91, 86, 21, 81, 7, 58, 27, 9, 61, 77, 2, 88, 70, 79, 3, 100, 44, 94, 51, 83, 48, 68, 13, 96, 30, 98, 24, 95, 67, 55, 8, 56, 19, 52, 85, 6, 69, 43, 16, 93, 74, 60, 41, 37, 84, 66, 99, 78, 57, 33, 14, 62, 35, 31, 46, 59, 38, 12, 92, 73, 25, 32, 22, 28, 63, 54, 97, 29, 47, 15, 40, 87, 80, 17, 71, 11, 4, 75, 89, 49, 10, 5, 45, 42, 82};
quick_sort(v.begin(), v.end()-1); // one element before end
for(const auto & i:v){
std::cout << i << ' ';
}
return 0;
}```