基本排序算法

#include <iostream>
#include <cassert>
#include <ctime>
#include <stack>
using namespace std;
//交换
template<typename T>
void _swap(T* a, T* b){
    T temp(*a);
    *a = *b;
    *b = temp;
}
//打印数组的元素
template<typename T>
void print_sort(T* arr, int n){
    assert(arr != nullptr);
    for (int i = 0; i < n; ++i){
        cout << arr[i] << ends;
    }
    cout << endl;
}
//插入排序
void insert_sort(int* arr, int n){
    assert(arr != nullptr);
    int i,j;
    int temp;
    for (i = 1; i < n; ++i){
        temp = arr[i];
        for (j = i - 1; j >= 0 && arr[j] > temp; --j){
            arr[j + 1] = arr[j];//后移
        }
        arr[j + 1] = temp;
    }
}
//希尔排序
void shell_sort(int* arr, int n){
    assert(arr != nullptr);
    int i,j;
    int interval = n;//每组排序的间隔
    int temp;
    do{
        interval = interval / 3 + 1;
        for (i = interval; i < n; ++i){
            temp = arr[i];
            for (j = i - interval; j >= 0 && arr[j] > temp; j -= interval){
                arr[j+interval] = arr[j];//后移
            }
            arr[j + interval] = temp;
        }
    } while (interval > 1);
}
//冒泡排序
void bubble_sort(int* arr, int n){
    assert(arr != nullptr);
    int i,j;
    int changed = 0;//是否发生交换的标记，
    for (i = n - 1; i > 0; --i){
        changed = 0;
        for (j = 0; j < i; ++j){
            if (arr[j] > arr[j + 1]){
                changed = 1;//发生交换 changed = 1
                _swap(&arr[j], &arr[j + 1]);
            }
        }
        if (changed == 0){ break; }//changed = 0 则表示没有发生交换，排序结束
    }
}
//一次分化
int parption(int* arr, int first, int last){
    while (first < last){
        while (first < last && arr[first] <= arr[last]){ --last; }
        if (first < last){
            _swap(&arr[first], &arr[last]);
            ++first; //gorget
        }

        while (first < last && arr[first] <= arr[last]){ ++first; }
        if (first < last){ 
            _swap(&arr[first], &arr[last]);
            --last;
        }
    }
    return first;
}
//快速排序
void quick_sort(int* arr, int first,int last){
    assert(arr != nullptr);
    int pivot;
    if (first < last){//不能为while
        pivot = parption(arr, first, last);
        quick_sort(arr, first, pivot - 1);
        quick_sort(arr, pivot + 1, last);
    }
}
//非递归快速排序
void quick_sort_non_recursive(int* arr, int first, int last){
    assert(arr != nullptr);
    int pivot;
    stack<int> s;
    if (first < last){

        pivot = parption(arr, first, last);
        if (first < pivot - 1){ s.push(first); s.push(pivot - 1); }
        if (pivot + 1 < last){ s.push(pivot + 1); s.push(last); }

        while (!s.empty()){
            last = s.top(); s.pop();
            first = s.top(); s.pop();
            pivot = parption(arr, first, last);
            if (first < pivot - 1){ s.push(first); s.push(pivot - 1); }
            if (pivot + 1 < last){ s.push(pivot + 1); s.push(last); }
        }
    }
}
//选择排序
void select_sort(int* arr, int n){
    assert(arr != nullptr);
    int i,j;
    int smallest;//最小元素的下标
    for (i = 0; i < n - 1; ++i){
        smallest = i;
        for (j = i + 1; j < n; ++j){
            if (arr[smallest] > arr[j]){smallest = j;}
        }
        if (smallest != i){_swap(&arr[smallest], &arr[i]);}
    }
}
//非递归归并排序
void merge_sort_non_recursive(int*arr, int n){
    assert(arr != nullptr);
    int interval;
    int left_first, left_last, right_first, right_last;
    int index;
    int* temp = (int*)malloc(sizeof(int)*n);
    if (!temp){cout << "memory error"<<endl; }

    for (interval = 1; interval < n; interval *= 2){
        for (left_first = 0; left_first < n - interval; left_first = right_last){
            left_last = left_first + interval;
            right_first = left_last;
            right_last = right_first + interval;

            if (right_last > n){right_last = n;}
            index = 0;
            while (left_first < left_last && right_first < right_last){
                if (arr[left_first] < arr[right_first]){
                    temp[index++] = arr[left_first++];
                }
                else{ temp[index++] = arr[right_first++];}
            }
            while (left_first < left_last){
                arr[--right_first] = arr[--left_last];
            }
            while (index > 0){
                arr[--right_first] = temp[--index];
            }
        }
    }
    free(temp);
}
//堆排序
void adjust_heap(int*arr, int p, int n){
    assert(arr != nullptr);
    int i;
    int temp = arr[p];
    for (i = 2 * p + 1; i <= n; i = 2 * i + 1){
        if (i < n && arr[i] < arr[i + 1]){ ++i; }
        if (temp >= arr[i]){ break; }
        arr[p] = arr[i];
        p = i;
    }
    arr[p] = temp;
}
void heap_sort(int* arr, int n){
    assert(arr != nullptr);
    int i;
    if (n <= 2){i = 0;}
    else{ i = (n - 2) / 2; }
    for (; i >= 0; --i){
        adjust_heap(arr, i, n - 1);
    }
    for (i = n - 1; i >= 0;--i){
        _swap(&arr[0], &arr[i]);
        adjust_heap(arr, 0, i - 1);
    }
}

int a[20];//初始化数组元素
void random_array(int* arr, int n){
    assert(arr != nullptr);
    for (int i = 0; i < n; ++i){
        arr[i] = rand() % 1000 - 500;
    }
}
int main(){ 
    srand(time(NULL));

    random_array(a, 20);
    //insert_sort(a, 10);
    //shell_sort(a, 10);
    //bubble_sort(a, 10);
    //quick_sort(a, 0, 9);
    //quick_sort_non_recursive(a, 0, 9);
    //select_sort(a, 10);
    //merge_sort_non_recursive(a, 10);
    heap_sort(a, 20);
    print_sort(a, 20);

    return 0; 
}