Algo Search and Sort

Author: harshit2608

.gitignore

@@ -1,3 +1,4 @@
 .vscode/
 *.exe
-.cph/
+.cph/
+*.bin

ALGORITHMS/Arrays/Kadane Algorithm.cpp

@@ -0,0 +1,35 @@
+#include <bits/stdc++.h>
+
+using ll = long long int;
+
+ll kadane(std::vector<ll> &data)
+{
+    ll res = data[0], maxsum = data[0];
+    for (ll i = 1; i < data.size(); ++i)
+    {
+        maxsum = std::max(data[i], maxsum + data[i]);
+        res = std::max(res, maxsum);
+    }
+    return res;
+}
+
+int main()
+{
+    int t;
+    std::cin >> t;
+    while (t--)
+    {
+        ll size, element;
+        std::cin >> size;
+        std::vector<ll> data;
+        data.reserve(size);
+        for (ll i = 0; i < size; i++)
+        {
+            std::cin >> element;
+            data.emplace_back(element);
+        }
+        std::cout << kadane(data) << std::endl;
+        data.clear();
+    }
+    return 0;
+}

ALGORITHMS/Arrays/WindowSliding.cpp

@@ -0,0 +1,49 @@
+//TODO:
+//* Given an unsorted array of non-negative integers.Find if there is a subarray wiht given sum*/
+
+#include <bits/stdc++.h>
+
+using ll = long long int;
+
+bool windowSliding(std::vector<ll> &data, ll target)
+{
+    ll curr_sum = data[0], start = 0;
+    for (ll i = 1; i < data.size(); ++i)
+    {
+        while (curr_sum > target && start < i - 1)
+        {
+            curr_sum = curr_sum - data[start];
+            start++;
+        }
+        if (curr_sum == target)
+        {
+            return true;
+        }
+        else
+        {
+            curr_sum += data[i];
+        }
+    }
+    return curr_sum == target;
+}
+
+int main()
+{
+    int t;
+    std::cin >> t;
+    while (t--)
+    {
+        ll size, element, target;
+        std::cin >> size >> target;
+        std::vector<ll> data;
+        data.reserve(size);
+        for (ll i = 0; i < size; i++)
+        {
+            std::cin >> element;
+            data.emplace_back(element);
+        }
+        std::cout << windowSliding(data, target) << std::endl;
+        data.clear();
+    }
+    return 0;
+}

ALGORITHMS/Sorting/Dutch National Flag(DNF).bin

@@ -0,0 +1,37 @@
+#include <bits/stdc++.h>
+
+using ll = long long int;
+
+void heapSort(std::vector<ll> &data, ll low, ll high)
+{
+}
+
+void printArray(std::vector<ll> data)
+{
+    for (int i = 0; i < data.size(); ++i)
+    {
+        std::cout << data[i] << " ";
+    }
+    std::cout << "\n";
+}
+
+int main()
+{
+    int t;
+    std::cin >> t;
+    while (t--)
+    {
+        ll size, element;
+        std::cin >> size;
+        std::vector<ll> data;
+        data.reserve(size);
+        for (ll i = 0; i < size; i++)
+        {
+            std::cin >> element;
+            data.emplace_back(element);
+        }
+        heapSort(data, 0, data.size() - 1);
+        printArray(data);
+    }
+    return 0;
+}

ALGORITHMS/Sorting/HeapSort.cpp

@@ -0,0 +1,81 @@
+#include <bits/stdc++.h>
+
+using ll = long long int;
+
+void merge(std::vector<ll> &data, ll low, ll mid, ll high)
+{
+    ll leftSize = mid - low + 1, rightSize = high - mid;
+    std::vector<ll> left(leftSize);
+    std::vector<ll> right(rightSize);
+
+    for (ll i = 0; i < leftSize; i++)
+    {
+        left[i] = data[i + low];
+    }
+    for (ll j = 0; j < rightSize; j++)
+    {
+        right[j] = data[mid + j + 1];
+    }
+
+    ll i = 0, j = 0, k = low;
+    while (i < leftSize && j < rightSize)
+    {
+        if (left[i] <= right[j])
+        {
+            data[k++] = left[i++];
+        }
+        else
+        {
+            data[k++] = right[j++];
+        }
+    }
+    while (i < leftSize)
+    {
+        data[k++] = left[i++];
+    }
+    while (j < rightSize)
+    {
+        data[k++] = right[j++];
+    }
+}
+
+void mergeSort(std::vector<ll> &data, ll low, ll high)
+{
+    if (high > low)
+    {
+        ll mid = low + (high - low) / 2; //used to avoid overflow
+        mergeSort(data, low, mid);
+        mergeSort(data, mid + 1, high);
+        merge(data, low, mid, high);
+    }
+}
+
+void printArray(std::vector<ll> arr)
+{
+    for (int i = 0; i < arr.size(); ++i)
+    {
+        std::cout << arr[i] << " ";
+    }
+    std::cout << "\n";
+}
+
+int main()
+{
+    int t;
+    std::cin >> t;
+    while (t--)
+    {
+        ll size, element;
+        std::cin >> size;
+        std::vector<ll> data;
+        data.reserve(size);
+        for (ll i = 0; i < size; i++)
+        {
+            std::cin >> element;
+            data.emplace_back(element);
+        }
+        mergeSort(data, 0, data.size() - 1);
+        printArray(data);
+    }
+    return 0;
+}

ALGORITHMS/Sorting/MergeSort.cpp

@@ -0,0 +1,65 @@
+#include <bits/stdc++.h>
+
+using ll = long long int;
+
+ll partition(std::vector<ll> &data, ll low, ll high)
+{
+    ll pivot = data[low];
+    ll i = low - 1, j = high + 1;
+    while (true)
+    {
+        do
+        {
+            i++;
+        } while (data[i] < pivot);
+        do
+        {
+            j--;
+        } while (data[j] > pivot);
+        if (i >= j)
+        {
+            return j;
+        }
+        std::swap(data[i], data[j]);
+    }
+}
+
+void quickSort(std::vector<ll> &data, ll low, ll high)
+{
+    if (high > low)
+    {
+        ll p = partition(data, low, high);
+        quickSort(data, low, p);
+        quickSort(data, p + 1, high);
+    }
+}
+
+void printArray(std::vector<ll> data)
+{
+    for (int i = 0; i < data.size(); ++i)
+    {
+        std::cout << data[i] << " ";
+    }
+    std::cout << "\n";
+}
+
+int main()
+{
+    int t;
+    std::cin >> t;
+    while (t--)
+    {
+        ll size, element;
+        std::cin >> size;
+        std::vector<ll> data;
+        data.reserve(size);
+        for (ll i = 0; i < size; i++)
+        {
+            std::cin >> element;
+            data.emplace_back(element);
+        }
+        quickSort(data, 0, data.size() - 1);
+        printArray(data);
+    }
+    return 0;
+}

ALGORITHMS/Sorting/QuickSort(Hoare).cpp

@@ -0,0 +1,59 @@
+#include <bits/stdc++.h>
+
+using ll = long long int;
+
+ll partition(std::vector<ll> &data, ll low, ll high)
+{
+    ll pivot = data[high];
+    ll i = low - 1;
+    for (ll j = low; j <= high - 1; ++j)
+    {
+        if (data[j] < pivot)
+        {
+            i++;
+            std::swap(data[j], data[i]);
+        }
+    }
+    std::swap(data[i + 1], data[high]);
+    return (i + 1);
+}
+
+void quickSort(std::vector<ll> &data, ll low, ll high)
+{
+    if (high > low)
+    {
+        ll p = partition(data, low, high);
+        quickSort(data, low, p - 1);
+        quickSort(data, p + 1, high);
+    }
+}
+
+void printArray(std::vector<ll> data)
+{
+    for (int i = 0; i < data.size(); ++i)
+    {
+        std::cout << data[i] << " ";
+    }
+    std::cout << "\n";
+}
+
+int main()
+{
+    int t;
+    std::cin >> t;
+    while (t--)
+    {
+        ll size, element;
+        std::cin >> size;
+        std::vector<ll> data;
+        data.reserve(size);
+        for (ll i = 0; i < size; i++)
+        {
+            std::cin >> element;
+            data.emplace_back(element);
+        }
+        quickSort(data, 0, data.size() - 1);
+        printArray(data);
+    }
+    return 0;
+}