AK: Add a basic QuickSort template implementation.

It was depressing not being able to capture anything when passing a lambda
to qsort_r() so let's just have our own QuickSort. I was gonna have to do
this eventually anyway. :^)

AK/QuickSort.h

@@ -0,0 +1,47 @@
+#pragma once
+
+namespace AK {
+
+template<typename IteratorType, typename LessThan>
+IteratorType partition(IteratorType first, IteratorType last, LessThan less_than)
+{
+    auto pivot = last;
+    auto smallest = first - 1;
+    auto it = first;
+    for (; it < last; ++it) {
+        if (less_than(*it, *pivot)) {
+            ++smallest;
+            swap(*it, *smallest);
+        }
+    }
+    swap(*(smallest + 1), *last);
+    return smallest + 1;
+}
+
+template<typename IteratorType, typename LessThan>
+void quick_sort_impl(IteratorType begin, IteratorType first, IteratorType last, LessThan less_than)
+{
+    if (first < last) {
+        auto pivot = partition(first, last, less_than);
+        quick_sort_impl(begin, first, pivot - 1, less_than);
+        quick_sort_impl(begin, pivot + 1, last, less_than);
+    }
+}
+
+template<typename T>
+bool is_less_than(const T& a, const T& b)
+{
+    return a < b;
+}
+
+template<typename IteratorType, typename LessThan>
+void quick_sort(IteratorType begin, IteratorType end, LessThan less_than = is_less_than)
+{
+    if (begin == end)
+        return;
+    quick_sort_impl(begin, begin, end - 1, less_than);
+}
+
+}
+
+using AK::quick_sort;

AK/Vector.h

@@ -274,7 +274,11 @@ public:
     class Iterator {
     public:
         bool operator!=(const Iterator& other) { return m_index != other.m_index; }
+        bool operator==(const Iterator& other) { return m_index == other.m_index; }
+        bool operator<(const Iterator& other) { return m_index < other.m_index; }
         Iterator& operator++() { ++m_index; return *this; }
+        Iterator operator-(int value) { return { m_vector, m_index - value }; }
+        Iterator operator+(int value) { return { m_vector, m_index + value }; }
         T& operator*() { return m_vector[m_index]; }
     private:
         friend class Vector;
@@ -289,7 +293,11 @@ public:
     class ConstIterator {
     public:
         bool operator!=(const ConstIterator& other) { return m_index != other.m_index; }
+        bool operator==(const ConstIterator& other) { return m_index == other.m_index; }
+        bool operator<(const ConstIterator& other) { return m_index < other.m_index; }
         ConstIterator& operator++() { ++m_index; return *this; }
+        ConstIterator operator-(int value) { return { m_vector, m_index - value }; }
+        ConstIterator operator+(int value) { return { m_vector, m_index + value }; }
         const T& operator*() const { return m_vector[m_index]; }
     private:
         friend class Vector;