浅谈比较排序算法中的冒泡排序算法和梳排序算法

作为一个刚考上计算机的准研究僧，闲来没事开始练练算法，希望能为以后的研究生生涯奠定一下基础。昨天晚上本来应该写的，拖到今天早上了。
今天准备谈谈我昨天练手的冒泡排序算法和梳排序算法。将一堆杂乱无章的元素按照某种规则有序排列的过程叫作“排序”，排序是非常基础和重要的算法。排序一般按照是否基于“比较”操作，分为比较排序和非比较排序。
在比较算法中，最基础的就是暴力搜索和比较每个数和全体序列的大小，但是这样既浪费计算机资源，又浪费时间，仅仅适用于容量小的序列。于是计算机届的大神们根据大的气泡会优先上浮到水面上的原理，设计了冒泡排序算法。冒泡排序算法的算法原理很简单：
1.比较相邻两个元素，如果左边的元素比右边的元素大，则交换。
2.对每一对元素都做上述操作，直到最后一对，这时最后一个元素应该是最大的。
3.重复上述过程，直到除最后一个元素外都被完成排序。
我们可以举个例子：
eg:
序列：1 3 2 5 4
第一次冒泡排序过程：（1） 1 **2 3** 5 4
第二次冒泡排序过程：（2） 1 2 3 **4 5**
直接上代码：

   //冒泡排序算法
void bubble_sort(int *input, int num)
{
    int i = 0, j = 0,k = 0,temp;
    for (i = 0; i < num-1; i++)
    {
        for (j = 0; j < num-1; j++)
        {
            if (input[j]>input[j + 1])
            {
                temp = input[j];
                input[j] = input[j + 1];
                input[j + 1] = temp;
            }
        }
} 

一定要注意循环顺序，冒泡排序的时间复杂度是O（n2）,虽然在时间上并不占优势，但是代码非常简单，实现难度低，但是冒泡排序算法的效率并不高，在针对小容量序列效率还可以，但是针对大容量效率明显下降。
所以接下又提出了一种优化的冒泡排序算法，梳排序算法。梳排序(Comb sort)是一种由Wlodzimierz Dobosiewicz于1980年所发明的不稳定排序算法，并由Stephen Lacey和Richard Box于1991年四月号的Byte杂志中推广。梳排序是改良自泡沫排序和快速排序，其要旨在于消除乌龟，亦即在阵列尾部的小数值，这些数值是造成泡沫排序缓慢的主因。相对地，兔子，亦即在阵列前端的大数值，不影响泡沫排序的效能。
在泡沫排序中，只比较阵列中相邻的二项，即比较的二项的间距(Gap)是1，梳排序提出此间距其实可大于1，改自插入排序的希尔排序同样提出相同观点。梳排序中，开始时的间距设定为阵列长度，并在循环中以固定比率递减，通常递减率设定为1.3。在一次循环中，梳排序如同泡沫排序一样把阵列从首到尾扫描一次，比较及交换两项，不同的是两项的间距不固定于1。如果间距递减至1，梳排序假定输入阵列大致排序好，并以泡沫排序作最后检查及修正。（本段摘自百度百科）
梳排序算法的编程代码：

//梳排序算法
void comb_sort(int *input, int num)
{
    int j = num,temp;
    double s = 1.3;
    bool flag = false;
    while ((j > 1) || (flag == true))
    {
        int i = 0;
        j = ((j / s) > 1) ? (j / s) : 1;
    //  cout << "update j:" << j << endl;
        flag = false;
        while (i + j <= num)
        {
            if (input[i]>input[j + i])
            {
                temp = input[i];
                input[i] = input[j + i];
                input[j + i] = temp;
                flag = true;
            }
            i = i + 1;
        }
    }
}

梳排序算法的基本思路是分组排序，当容量很大时，可以先分成很多组，这样每组的容量就会很小，工作量会小很多。当需要编写一个高效率的算法时，梳排序不失为一种很好的选择。
可以看出，这个效率的对比很明显。
最后，我把整个工程文件上传，希望对大家有帮助，序列采用随机数生成的。

#include <windows.h>
#include <iostream>
#include <cmath>
#include <time.h>
#include"stdlib.h"
#define N 10000
using namespace std;
int input_src[N];
int bubble_sort_input[N];
int comb_sort_input[N];
void bubble_sort(int *input, int num);
void comb_sort(int *input, int num);
int main()
{
    int i = 0,j =0,temp;
    double time_t = 0;
    LARGE_INTEGER nFreq;
    LARGE_INTEGER nBeginTime;
    LARGE_INTEGER nEndTime;
    srand((unsigned)time(NULL));
    for (; i < N; i++)
    {
        input_src[i] = rand()%(N+1);
        bubble_sort_input[i] = input_src[i];
        comb_sort_input[i] = input_src[i];
    }
    QueryPerformanceFrequency(&nFreq);
    QueryPerformanceCounter(&nBeginTime);//开始计时  
    bubble_sort(bubble_sort_input, N);
    //bubble_sort(sort_input, N);
    QueryPerformanceCounter(&nEndTime);//停止计时  
    time_t = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / (double)nFreq.QuadPart;//计算程序执行时间单位为s  
    cout << "容量为1000时冒泡排序算法执行时间：" << time_t * 1000 << "ms" << endl;

    QueryPerformanceFrequency(&nFreq);
    QueryPerformanceCounter(&nBeginTime);//开始计时  
    comb_sort(comb_sort_input, N);
    //bubble_sort(sort_input, N);
    QueryPerformanceCounter(&nEndTime);//停止计时  
    time_t = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / (double)nFreq.QuadPart;//计算程序执行时间单位为s  
     cout << "容量为1000时梳排序算法执行时间：" << time_t * 1000 << "ms" << endl;

    /*for (int j = 0; j < N; j++)
    {
        cout << "num:" << (j + 1) << "input_data:" << input_src[j] << ";  " << "output_data:" << comb_sort_input[j] << endl;
    }*/
    while (1);
    return 0;
}
//冒泡排序算法
void bubble_sort(int *input, int num)
{
    int i = 0, j = 0,k = 0,temp;
    for (i = 0; i < num-1; i++)
    {
        for (j = 0; j < num-1; j++)
        {
            if (input[j]>input[j + 1])
            {
                temp = input[j];
                input[j] = input[j + 1];
                input[j + 1] = temp;
            }
        }
}

}
//梳排序算法
void comb_sort(int *input, int num)
{
    int j = num,temp;
    double s = 1.3;
    bool flag = false;
    while ((j > 1) || (flag == true))
    {
        int i = 0;
        j = ((j / s) > 1) ? (j / s) : 1;
    //  cout << "update j:" << j << endl;
        flag = false;
        while (i + j <= num)
        {
            if (input[i]>input[j + i])
            {
                temp = input[i];
                input[i] = input[j + i];
                input[j + i] = temp;
                flag = true;
            }
            i = i + 1;
        }
    }
}