sort algorithms

//todo

#include<iostream>

void swap(int *a, int *b){int temp = *a; *a = *b; *b = temp;}
void print_array(int *arr, int len) { for (int i = ; i < len; i++) std::cout << arr[i] << " , "; }

// swap sort (bubble sort), bubble the largest item to top of list, impractical
void bubble_sort(int arr[], int len)
{
    bool need_sort = true;
    while (need_sort)
    {
        need_sort = false;
        for (int i = ; i < len - ; i++)
        {
            if (arr[i] < arr[i + i]){swap(arr+i, arr+i + );need_sort = true;}
        }
    }
}

// selection sort, select the largest one, and put it in the top, just need O(n) insert operation!!!
void select_sort(int arr[], int len)
{
    for (int i = ; i < len - ; i++)
    {
        int index = i;
        for (int j = i + ; j < len; j++)
        {
            if (arr[j] > arr[index]) index = j;
        }
        swap(arr+i, arr+index);
    }
}

// the only advantage of both bubble sort and selection sort is easy to implement, should not use it

// insert sort, choose item in list one and insert into another in right order
// efficient for small lists and mostly-sorted list
void insert_sort(int arr[], int len)
{
    for (int i = ; i < len-; i++)
    {
        int temp = arr[i + ];
        int j = i;
        for (; j >=  && (arr[j] < temp); j--)
        {
            arr[j+] =arr[j];
        }
        if (j < i) arr[j+] = temp;
    }
}

// as the result list is sorted, insert one new item is same to : put the new item in the top,
// bubble (swap) it to the right position (just need one-time bubbling through the list)
void insert_sort2(int arr[], int len)
{
    for (int i = ; i < len; i++)
    {
        for (int j = i - ; j >=  && (arr[j] < arr[j + ]); j--)
        {
            swap(arr + j, arr + j + );
        }
    }
}

// shell sort, combine insert sort and group (because insert sort is efficient when the list is mostly-sorted,
// one of the fastest algorithms for small number of elements( < 1000 ), and it needs little momery
// unlike efficient sorting algorithms, Shellsort does not require use of the call stack, making it useful in embedded systems where memory is at a premium
void shell_sort(int arr[], int len)
{
    for (int gap = len / ; gap >; gap /= )
    {
        for (int i = ; i < gap; i++)
        {
            for (int k = i + gap; k < len; k += gap)
            {
                for (int j = k - gap; j >=  && (arr[j] < arr[j + gap]); j -= gap) swap(arr + j, arr + j + gap);
            }
        }
    }
}

// merge sort, recursion and double memory of data
void merge_sorted_array(int a[], int lena, int b[], int lenb, int c[])
{
    int i(), j(), m();
    while (i < lena && j << lenb)
    {
        if (a[i] < b[j]) c[m++] = a[i++];
        else c[m++] = b[j++];
    }
    while (i < lena) c[m++] = a[i++];
    while (j < lenb) c[m++] = b[j++];
}

void merge_array(int a[], int first,int mid, int last, int temp[])
{
    int i(first), j(mid), m();
    while (i < mid && j <=last)
    {
        if (a[i] < a[j]) temp[m++] = a[i++];
        else temp[m++] = a[j++];
    }
    while (i < mid) temp[m++] = a[i++];
    while (j <=last)    temp[m++] = a[j++];

    for (i = first, m = ; i <= last;) a[i++] = temp[m++];
}

void merge_sort(int a[], int first_index, int last_index, int temp[])
{
    if (last_index>first_index)
    {
        int mid = (first_index + last_index) / ;
        merge_sort(a, first_index, mid, temp);
        merge_sort(a, mid + , last_index, temp);
        merge_array(a, first_index, mid+, last_index, temp);
    }
}

// quick sort, choose a pivot, put all elements smaller before it!
// Typically, quicksort is significantly faster in practice than other Θ(nlogn) algorithms
// in-place, need less swap than merge-sort
void quick_sort(int a[], int first, int last)
{
    if (!(first < last)) return;
    int i = first, j = last, temp = a[i];
    while (i < j)
    {
        while (i < j && temp < a[j]) j--;
        if (i < j) a[i++] = a[j];
        while (i < j && a[i] < temp) i++;
        if (i < j) a[j--] = a[i];
    }
    a[i] = temp;
    quick_sort(a, first, i - );
    quick_sort(a, i + , last);
}

int main()
{
    int array01[] = { , , , , , , , ,  };
    int temparr[] = {  };
    quick_sort(array01, ,);
    print_array(array01, );
}