[Algorithms] Sorting Algorithms (Insertion Sort, Bubble Sort, Merge Sort and Quicksort)

Recently I systematicall review some sorting algorithms, including insertion sort, bubble sort, merge sort and quick sort. I then implement them in C++. All the function takes in a  vector<int>& type and directly operates on the input. To use the following code, you need to add the following code to your headers.

#include <iostream>
#include <vector>
#include <ctime> // for randomization in quicksort

using namespace std;

 Insertion Sort:

// Insertion sort
void insertionSort(vector<int>& arr) {
    for (int j = 1; j < (signed)arr.size(); j++)
        for (int i = j - 1; i >= 0 && arr[i] > arr[i + 1]; i--)
            swap(arr[i], arr[i + 1]);
}

Bubble Sort:

// Bubble sort
void bubbleSort(vector<int>& arr) {
    for (int i = 0; i < (signed)arr.size() - 1; i++)
        for (int j = i + 1; j < (signed)arr.size(); j++)
            if (arr[i] > arr[j]) swap(arr[i], arr[j]);
}

Merge Sort:

// Merge sort
void merge(vector<int>& arr, int left, int mid, int right) {
    if (left >= right) return;
    vector<int> larr(arr.begin() + left, arr.begin() + mid + 1);
    vector<int> rarr(arr.begin() + mid + 1, arr.begin() + right + 1);
    int i = 0, j = 0, pos = left;
    while(i < (signed)larr.size() && j < (signed)rarr.size()) {
        if (larr[i] > rarr[j]) arr[pos++] = rarr[j++];
        else arr[pos++] = larr[i++];
    }
    while (i < (signed)larr.size()) arr[pos++] = larr[i++];
    while (j < (signed)rarr.size()) arr[pos++] = rarr[j++];
}

void mergeSortHelper(vector<int>& arr, int left, int right) {
    if (left >= right) return;
    int mid = (left + right) / 2;
    mergeSortHelper(arr, left, mid);
    mergeSortHelper(arr, mid + 1, right);
    merge(arr, left, mid, right);
}

void mergeSort(vector<int>& arr) {
    mergeSortHelper(arr, 0, arr.size() - 1);
}

Quicksort:

// Quicksort
int partition(vector<int>& arr, int left, int right) {
    // Introduce randomization
    srand((unsigned)time(0));
    int rndIdx = rand() % (right - left + 1) + left;
    swap(arr[rndIdx], arr[left]);
    int l = left + 1, r = right;
    while (l <= r) {
        if (arr[l] > arr[left] && arr[r] < arr[left])
            swap(arr[l], arr[r]);
        if (arr[l] <= arr[left]) l++;
        if (arr[r] >= arr[left]) r--;
    }
    swap(arr[left], arr[r]);
    return r;
}

void quickSortHelper(vector<int> &arr, int left, int right) {
    if (left >= right) return;
    int pivot = partition(arr, left, right);
    quickSortHelper(arr, left, pivot - 1);
    quickSortHelper(arr, pivot + 1, right);
}

void quickSort(vector<int>& arr) {
    quickSortHelper(arr, 0, arr.size() - 1);
}

Welcome for any question, comment and suggestion about the code!