排序---排序算法1

冒泡排序

思想

所谓冒泡排序就是，一组数据，以递增的顺序来说明，从第一个数data[0]开始，依次和后面的数据比较大小，如果data[0]大于当前位置上的数就和这个数交换位置并继续和后面的数相比，如果遇到比自己大的数了，就不交换；下一次开始的位置是data[1],然后依次往后推。

基础代码

void myswap(int &num1,int &num2)
{
    int num = num1;
    num1 = num2;
    num2 = num;
}

void bubble_sort(int *array,int num)
{
    cout<<"bubble_sort"<<endl;
    for (int i=0;i<num-1;++i)
    {
        for (int j = 0;j< num-1-i;++j)
        {
            if (array[j] > array[j+1])
            {
                myswap(array[j],array[j+1]);
            }
        }
    }
}

上述代码是算法思想的基本实现，但是如果这个数组的后一半元素是有序的，效率就低了很多，那么怎么优化呢？

解决方案

思想

设置一个标记位，如果不发生数据交换，说明数组数据已经有序，那么就没必要继续往下循环了，就可以直接退出了，这么做的好处是可以减少循环次数，避免空循环的发生。

效率

O(n^2)

实现

void bubble_sort_ex(int *array,int num)
{
    cout<<"buble_sort_ex"<<endl;
    bool flag = false;
    int count = 0;
    for (int i=0;i<num-1;++i)
    {
        for (int j = 0;j< num-1-i;++j)
        {
            if (array[j] > array[j+1])
            {
                count++;
                flag = true;
                myswap(array[j],array[j+1]);
            }
        }
        if (flag == false)
        {
            break;
        }
    }
}

插入排序

思想

每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。简单说，就是将每一个元素和它前面的每一个数据相比较，然后根据其数值的大小关系插入到合适的位置上，直到最后一个元素也完成这种操作。
插入排序的分类有三种，分别为直接插入排序、折半插入排序、希尔排序。

效率

O(n^2),和冒泡排序一样，都是稳定的排序方法，当然它们的效率也是最低的，在数据量很小时，这两种方法的效率还是不错的。

实现

直接插入排序

void insert_sort(int*array,int num)
{
    cout<<"insert_sort"<<endl;
    int j = 0;
    for (int i =0;i<num;++i)
    {
        int key = array[i];
        for (j=i-1;j >= 0;--j)
        {
            if (array[j] > key)
            {
                array[j+1] = array[j];
            }
            else
            {
                break;
            }
        }
        array[j+1] = key;
    }
}

折半插入排序

原理

折半插入排序原理很简单，只有两步：
第一步，在已经排好序的数组中找到要插元素的位置；
第二步，将这个位置后面的元素整体向后移动一个单位，然后插入这个元素；
排序操作做的是循环的工作，每一次都是对其中一个元素操作，直到数组末尾。

实现

void binary_insert_sort(int*arr,int len)
{
    if (arr == NULL ||len < 1)
    {
        return;
    }
    cout<<"binary_insert_sort"<<endl;
    for (int i = 1;i< len;++i)
    {
        int tmp = arr[i];
        int left = 0;
        int right = i -1;
        while (left <= right)
        {
            int mid = (left + right)/2;
            if (tmp < arr[mid])
            {
                right = mid-1;
            }
            else
            {
                left = mid+1;
            }
        }
        for (int j= i;j > left;--j)
        {
            arr[j] = arr[j-1];
        }
        arr[left] = tmp;
    }
}

效率

我认为这种算法的排序，在数组中还未出现有序子序列之前，这种操作和直接插入排序的效率是一样的，而这种相比于直接插入排序的好处在于，如果一开始数组是基本有序的，那么数组就没必要从起始元素开始循环遍历了，二分效果很明显；这么做减少了遍历的次数，但是程序中在移动元素的时候并没有改进多少，所以它的时间复杂度依然是O(n^2)。

希尔排序

原理

希尔排序也是对直接插入排序的一种改进，它的基本做法是：
对于n个元素的数组，设置增量h，
第一趟，从第一个元素开始，隔h位置取下一个元素，并且边取边直接插入这n/h个元素；
第二趟，从第二个元素开始，隔h位置取下一个元素，和上面一样；
。。。
第h趟，从第h个元素开始，和上面一样的操作；
(注意：此时数组还不是有序的)
减小h的值，重复上面的操作，直到h的值为1，然后排序完成。

实现

void shell_sort(int *arr,int len)
{
    if (arr == NULL || len <1)
    {
        return;
    }
    cout<<"shell_sort"<<endl;
    int h = len/3;
    for (;h >0;--h)
    {
        for (int i = 0;i< h;i++)
        {
            for (int x = i+h;x < len;x += h)
            {
                int tmp = arr[x];
                int j=0;
                for (j = x-h; j>=0 && arr[j] > tmp;j -=h)
                {
                    arr[j+h] = arr[j];
                }
                arr[j+h] = tmp;
            }
        }
    }
}

效率

虽然说希尔排序是直接插入排序的一种改进，但是效率上并没有多少提高，时间复杂度，额，还是O(n^2)吧。

选择排序

思想

从第i个(i=0;i小于最后一个元素的下标)元素开始，在它后面的序列中找到比第一个元素小的数，用min记录下最小元素的下标，每一趟结束后，判断这个min对应的坐标是不是i，如果不是就交换对应的数据，直到最后一趟。

实现

void select_sort(int *arr,int len)
{
    if (arr == NULL ||len < 1)
    {
        return;
    }
    cout<<"select_sort"<<endl;
    int min = 0;
    int i = 0;
    int j = 0;
    for (;i< len-1;++i)
    {
        min = i;
        for (;j < len;++j)
        {
            if (arr[min] > arr[j])
            {
                min = j;
            }
        }
        if (min != i)
        {
            int tmp = arr[i];
            arr[i] = arr[min];
            arr[min] = tmp;
        }
    }
}

效率

相比于冒泡排序，选择排序的交换次数变少了，虽然它的比较次数和冒泡排序基本差不多，最好的情况是已经有序的序列，交换0次，最坏情况就交换n-1次，相比于冒泡排序是一个很大的提升。

稳定性

选择排序是个不稳定的算法。在例如{5,5,2}这样的数组中，在第一次交换的时候，第一个5已经置于第二个5之后了，虽然这是一个数组，一组无关紧要的数据，但是在实际应用中，比如一个抢票系统，在等待队列中的用户，因为数据的位置更改，会直接影响到结果的。

这一篇主要介绍简单的排序算法吧，效率也是比较低的，下一篇向高效率算法进军。