常用排序算法实现

按平均时间将排序分为四类：

（1）平方阶(O(n2))排序
    　一般称为简单排序，例如直接插入、直接选择和冒泡排序；

（2）线性对数阶(O(nlgn))排序
    　如快速、堆和归并排序；

（3）O(n1+￡)阶排序
    　￡是介于0和1之间的常数，即0<￡<1，如希尔排序；

（4）线性阶(O(n))排序
    　如桶、箱和基数排序。

各种排序方法比较

     简单排序中直接插入最好，快速排序最快，当文件为正序时，直接插入和冒泡均最佳。


影响排序效果的因素

    　因为不同的排序方法适应不同的应用环境和要求，所以选择合适的排序方法应综合考虑下列因素：
　　①待排序的记录数目n；
　　②记录的大小(规模)；
　　③关键字的结构及其初始状态；
　　④对稳定性的要求；
　　⑤语言工具的条件；
　　⑥存储结构；
　　⑦时间和辅助空间复杂度等。

#include <stdio.h>
#include<iostream>
using namespace std;

//交换
void swap(int& a, int& b)
{
    int temp = a;
    a = b;
    b = temp;
}

//不用中间数的交换  ^按位异或 不相同才为真
void swap_(int& a, int& b)
{
    if (a != b)
    {
        a ^= b;
        b ^= a;
        a ^= b;
    }
}

//选择排序
void select_sort(int *array, int left, int right)
{
    if (NULL == array || left >= right) return;
    
    for (int i=left; i<right; ++i)
    {
        for (int j=i+1; j<right; ++j)
        {
            if (array[i] > array[j])
            {
                swap(array[i], array[j]);
            }
        }
    }
}

//冒泡排序
void bubble_sort(int *array, int left, int right)
{
    if (NULL == array || left >= right) return;


    bool flag = false;
    for (int i=left; i<right; ++i)
    {
        for (int j=left+1; j<right-i; ++j)
        {
            if (array[j-1] > array[j])
            {
                swap(array[j-1], array[j]);
                flag = true;
            }
        }
        if (!flag) return;
    }
}

//插入排序
void insert_sort(int *array, int left, int right)
{
    if (NULL == array || left+1 >= right) return;

    for (int i= left + 1; i<right; i++)
    {
        if (array[i - 1] > array[i])
        {
            int temp = array[i];
            int j = i;
            while (j > left && array[j - 1] > temp)
            {
                array[j] = array[j - 1];
                j--;
            }
            array[j] = temp;
        }
    }
}

//希尔排序
void shell_sort(int* array, int left, int right)
{
    if (NULL == array || left+1 > right) return;

    int gap;
    for (gap=(right-left)/2; gap>0; gap/=2)
    {
        for (int i=gap; i<right; ++i)
        {
            if (array[i - gap] > array[i])
            {
                int temp = array[i];
                int j = i - gap;
                for (; j >= 0 && array[j] > temp; j -= gap)
                {
                    array[j + gap] = array[j];
                }
                array[j + gap] = temp;
            }
        }
    }
}

int adjust_array(int* array, int left, int right)
{
    if (NULL == array || left >= right) return 0;

    int i = left;
    int j = right;
    int pos = left;

    while(j > i)
    {
        while(j > i)
        {
            if (array[j] < array[pos])//从右向左找小于基准数，找到则交换位置
            {
                swap(array[j], array[pos]);
                pos = j;
                break;
            }
            j--;
        }

        while(j > i)
        {
            if (array[i] > array[pos])//从左向右找大于基准数，找到则交换位置
            {
                swap(array[i], array[pos]);
                pos = i;
                break;
            }
            i++;
        }
    }


    return pos;
}

//快速排序
void quick_sort(int* array, int left, int right)
{
    if (NULL == array || left >= right) return;

    int pos = adjust_array(array, left, right);
    quick_sort(array, left, pos-1);
    quick_sort(array, pos+1, right);
}

int get_left(int pos)
{
    return (2*pos + 1);
}

int get_right(int pos)
{
    return (2*pos + 2);
}

int get_parent(int pos)
{
    return int(float(pos - 1)/2);
}

void adjust_heap(int* array, int i, int n)
{
    if (NULL == array || i >= n) return;

    int left = get_left(i);
    int right = get_right(i);
    int large = i;

    if (left < n && array[left] > array[large])
    {
        large = left;
    }

    if (right < n && array[right] > array[large])
    {
        large = right;
    }

    if (large != i)
    {
        swap(array[large], array[i]);
        adjust_heap(array, large, n);
    }
}

void build_heap(int* array, int n)
{
    if (NULL == array || n <= 1) return;

    for (int i = n/2 - 1; i >= 0; --i)
    {
        adjust_heap(array, i, n);
    }
}

//堆排序
void heap_sort(int* array, int n)
{
    if (NULL == array || n <= 1) return;
    
    build_heap(array, n);
    for (int i = n - 1; i > 0; --i)
    {
        swap(array[0], array[i]);
        adjust_heap(array, 0, i);
    }
}

void merge_array(int* array, int left, int mid, int right)
{
    if (left > right || left > mid || mid > right) return;

    int i = left;
    int j = mid+1;
    int k = 0;

    int* temp = new int[right - left + 1];
    if (NULL == temp) return;
    
    int m = mid;
    int n = right;
    while(i <= m && j <= n)
    {
        if (array[i] > array[j])
            temp[k++] = array[j++];
        else
            temp[k++] = array[i++];
    }

    while(i <= m)
    {
        temp[k++] = array[i++];
    }

    while(j <= n)
    {
        temp[k++] = array[j++];
    }

    for (int i=0; i<k; ++i)
    {
        array[left+i] = temp[i];
    }

    if (NULL != temp)
    {
        delete []temp;
    }
}

void _merge_sort(int* array, int left, int right)
{
    if (NULL == array) return;

    if (left < right)
    {
        int mid = (left + right)/2;
        _merge_sort(array, left, mid);
        _merge_sort(array, mid+1, right);
        merge_array(array, left, mid, right);
    }
}

//归并排序
void merge_sort(int* array, int n)
{
    if (NULL == array || n <= 1) return;

    _merge_sort(array, 0, n-1);
}


void main()
{
    int array[] = {4, 6, 3, 2, 90, 45, 23};
    int length = sizeof(array)/sizeof(array[0]);
    cout<<"sizeof array: "<<length<<endl;
    cout<<"sort before:"<<endl;
    for (int i=0; i<length; ++i){
        cout<<array[i]<<"\t";
    }
    cout<<endl;

    cout<<"请输入你要排序的算法："<<endl;
    cout<<"1 选择排序"<<endl;
    cout<<"2 冒泡排序"<<endl;
    cout<<"3 插入排序"<<endl;
    cout<<"4 希尔排序"<<endl;
    cout<<"5 快速排序"<<endl;
    cout<<"6 堆排序"<<endl;
    cout<<"7 归并排序"<<endl;
    
    int n;
    cin>>n;
    switch (n)
    {
    case 1:
        select_sort(array, 0, length);
        break;
    case 2:
        bubble_sort(array, 0, length);
        break;
    case 3:
        insert_sort(array, 0, length);
    break;
    case 4:
        shell_sort(array, 0, length);
        break;
    case 5:
        quick_sort(array, 0, length - 1);
        break;
    case 6:
        heap_sort(array, length);
        break;
    case 7:
        merge_sort(array, length);
        break;
    default:
        break;
    }
    
    cout<<"sort latter:"<<endl;
    for (int i=0; i<length; ++i){
        cout<<array[i]<<'\t';
    }
}