排序算法（1）

1.冒泡排序

void bubblesort(int num[],const int len)
{
    if (len <= 1) return;

    bool sign = false;
    int i, j, tmp;

    for ( i = 0; i < len - 1; i++)
    {
        sign = false;
        for ( j = len - 1; j > i; j--)
        {
            if (num[j] < num[j - 1])
            {
                sign = true; //本轮循环存在排序操作
                tmp = num[j - 1];
                num[j - 1] = num[j];
                num[j] = tmp;
            }
        }
        if (!sign) break; //本轮循环排序已经结束
    }
}

最好时间复杂度为O(n)，最差和平均时间复杂度均为O(n^2),稳定排序。

2.鸡尾酒排序（可以理解为双向冒泡排序）

void cocktail_sort(int num[], const int len)
{
    if (len <= 1) return;

    int i, left = 0, right = len - 1, temp;

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

效果基本与冒泡排序接近，对于大量乱序数据，其效率还是呵呵。

3.直接插入排序

void insertsort(int num[],const int len)
{
    if (len <= 1) return;

    int i, j, temp;

    for ( i = 1; i < len; i++)
    {
        if (num[i] < num[i - 1])
        {
            temp = num[i];
            for (j = i - 1; j >= 0 && num[j] > temp; j--)
            {
                num[j + 1] = num[j];
            }
            num[j + 1] = temp;
        }
    }
}

引用自：http://www.cnblogs.com/heyuquan/p/insert-sort.html中解释

设数组为a[0…n]。

1. 将原序列分成有序区和无序区。a[0…i-1]为有序区，a[i…n] 为无序区。（i从1开始）
2. 从无序区中取出第一个元素，即a[i]，在有序区序列中从后向前扫描。
3. 如果有序元素大于a[i]，将有序元素后移到下一位置。
4. 重复步骤3，直到找到小于或者等于a[i]的有序元素，将a[i]插入到该有序元素的下一位置中。
5. 重复步骤2~4，直到无序区元素为0

时间复杂度：最好O(n)，最差、平均都是O(n)。

4.归并算法（采用递归，办法很棒）

//子区间归并函数
void merge(int num[], const int left, const int mid, const int right)
{
    int n1, n2, i, j, k;
    int *L = nullptr, *R = nullptr;

    n1 = mid - left + 1;
    n2 = right - mid;

    L = new int[n1];
    R = new int[n2];

    for ( i = 0; i < n1; i++)
        L[i] = num[left + i];
    for ( i = 0; i < n2; i++)
        R[i] = num[mid + 1 + i];

    i = j = 0; k = left;
    while (i < n1&&j < n2)
    {
        if (L[i] <= R[j])
            num[k++] = L[i++];
        else
            num[k++] = R[j++];
    }

    //左数组或者右数组存在剩余元素
    //将剩余元素合并至原数组末尾处
    for (; i < n1; i++)
        num[k++] = L[i];
    for (; j < n2; j++)
        num[k++] = L[j];

    delete[] L;
    delete[] R;
}

//采用递归的方式,划分子区间进行排序,最后对子区间进行归并
void mergesort(int num[],const int left,const int right)
{
    if (left >= right) 
        return;
    else if (right - left >= 50)
    {
        int mid = (left + right) / 2;
        mergesort(num, left, mid);
        mergesort(num, mid + 1, right);
        merge(num, left, mid, right);
    }
    else
    {
        insertsort(num + left, right - left + 1);
    }
}

此处为归并排序的改进版，即字串的数据较少时，采用直接插入法进行排序。在较大数据量的情况下，提升效果较为明显。

使用该改进方法，归并排序仍然为稳定排序，在处理大数据的时候，若要求为稳定，使用此方法较为不错