优化版冒泡排序

冒泡排序：属于贪心的一种，即短视，只看到自己周围，和相邻的元素进行比较，根据从小到大或从大到小的规则进行交换排列。
一般的冒泡，采用两重for循环

for (int j = 0; j < length; j++)  //冒泡排序
    {
        for (int k = 0; k<length - j - 1; k++)
        {
            if (c[k]>c[k + 1])
            {
                int temp = c[k];
                c[k] = c[k + 1];
                c[k + 1] = temp;
            }
        }
    }

即用第一层中的j来控制第二层中的循环次数——每一次循环排好最后一个值后，下一次就可以不用再对它进行排序，所以每次都会减1。

在这个的基础上，输入的数据可能是部分有序，即并不是完全的乱序，或者是在排序过程中，有一部分的顺序不需要进行改变，那么这一部分的比较就是不必要的。

思路：设置一个临时值，把最后发生交换的位置传给临时值，之后只要将最小的位置和这个临时值进行比较，而不是每次都按部就班减1。好处是，可以跳过最后一次交换位置后有序部分的数据，免去无意义的比较。

#include "stdafx.h"
#include<iostream>
#include<vector>
#include<ctime>
using namespace std;

void bubble(int *p, int lo, int hi)
{
    
    int last = lo;           //设置一个位，作为最后发生交换的位置
    for (int i = lo; i < hi; )
    {
        last = lo;        //将last重置，作为终止条件
        for (int j = lo; j < hi; ++j)
        {
            if (p[j] >p[j + 1])
            {
                last = j ;      //每当发生交换，就更新last的值
                swap(p[j], p[j + 1]);
                
            }
        }
        hi = last;
    }
}




int _tmain(int argc, _TCHAR* argv[])
{
    time_t begin, end;
    begin = clock();
    int buf[] = { 1, 2, 8, 4, 55, 77, 99, 45, 76, 35, 78, 96, 13, 56, 78, 90, 76, 45, 78 };
    int length = sizeof(buf) / sizeof(int);
    bubble(buf, 0, length-1);
    for (int s : buf)
    {
        cout << s << endl;
    }
    end = clock();
    cout << "runtime: " << double(end - begin) / CLOCKS_PER_SEC << endl;
    return 0;
}

输入的数据量越大，两者花费时间差距越明显。