[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 = ; j < (signed)arr.size(); j++)
         for (int i = j - ; i >=  && arr[i] > arr[i + ]; i--)
             swap(arr[i], arr[i + ]);
 }

Bubble Sort:

 // Bubble sort
 void bubbleSort(vector<int>& arr) {
     for (int i = ; i < (signed)arr.size() - ; i++)
         for (int j = i + ; 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 + );
     vector<int> rarr(arr.begin() + mid + , arr.begin() + right + );
     int i = , j = , 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) / ;
     mergeSortHelper(arr, left, mid);
     mergeSortHelper(arr, mid + , right);
     merge(arr, left, mid, right);
 }

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

Quicksort:

 // Quicksort
 int partition(vector<int>& arr, int left, int right) {
     // Introduce randomization
     srand((unsigned)time());
     int rndIdx = rand() % (right - left + ) + left;
     swap(arr[rndIdx], arr[left]);
     int l = left + , 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 - );
     quickSortHelper(arr, pivot + , right);
 }

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

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