C++排序算法

C++排序

排序算法是编程中常用的算法之一，实际上，排序大概是最最常用的了，下面，我们来介绍一下c++的排序算法,不过介绍之前，我们可以先看一个非常容易理解的函数：

template<class t>
inline size_t size(t ax[])
{
    return sizeof(ax)/sizeof(t);
}//简单的数组大小内联函数

该函数大部分时候可以帮我们干许多事，尽管并不要求一定需要，我们用这个函数还是挺方便的

冒泡排序(Bubble Sort)

好吧，这是一种所蕴含的思想极其朴素的一种算法，其主要思想是：给定一个数集（在c++里可以理解成数组之类的）并将第二个数与第一个数比较，找出小的，然后把比较的小的换到前边，之后把现在的第二个数与第三个数再一次比较，并找到小的，再换，以此类推，在比较完最后一个数后，我们就找到了最小的，把最小的放在第一个，然后，我们便可以在剩下的数中再一次进行一轮比较，又一次，又一次，最终，我们就按照升序排序好了一个数集。
不过在看代码前，您可能想知道冒泡排序为什么叫做冒泡排序：

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。（来源自维基）

以下是代码：

#include<stdio.h>

using namespace std;

template<class t>
t[] BubbleSort(t[])
int main()
{

}
template<class t>
void BubbleSort(t ax[],size_t len)//升序的冒泡排序，直接改变数组内的值,其中len是排序数量
{

    size_t i, j;
    t temp;
    for (i = 0; i < len - 1; i++)
    {
        for (j = 0; j < len - 1 - i; j++)
        {
            if (ax[j] > ax[j + 1])
            {
                temp=ax[j];
                ax[j]=ax[j+1];
                ax[j+1]=temp;//交换位置
            }
        }
    }
}

以上就是冒泡排序的代码，当然，main函数啥也没干，我加上main函数只是为了您以后的测试。
下边介绍下冒泡函数的性质，引自维基百科

在最坏的情况，冒泡排序需要 O(n^2)次交换

在最好情况下，冒泡需要O(n)次比较。
当然，冒泡排序可以被改进改进，这会在下边讲，而现在，我们先来看一看下一个算法：

插入排序(Insertion Sort)

又一种简单的算法，不过，该算法需要一点额外的空间，但是，如果你家电脑不是dos机的话，这些额外的内存非常划算。
首先，我们先看一个例子：
{2,8,1,35,6}
我们用插入排序的思想来排序：
首先，我们从头开始，先认为2，也就是开头的数字是已经被排序好的。
然后，我们看下一个数，8，从该数往前依次比较，直到找到一个小于或等于8的数，然后，把这个数与8交换，然而找了一圈，并没有。
然后，我们可以继续按照上边的方法排序，直到找到一个数比前边排序好的数列小的，然后，将该数插入进小于等于其的数的后边，并把后边的排序好的数列往后移动一次。
之后，我们就可以不断这样，便可以排序好了。
以下的代码引自维基百科：

#include<stdio.h>
template<typename T> //整数或浮点数皆可使用,若要使用class，需有定义>运算符
  void insertion_sort(T* arr, int len) {
    size_t i, j;
    T temp;
    for (i = 1; i < len; i++) {
        temp = arr[i];
        j = i - 1; // 如果将赋值放到下一行的for循环内, 会导致在第10行出现j未声明的错误
        for (; j >= 0 && arr[j] > temp; j--)
            arr[j + 1] = arr[j];//最后一次执行该语句后，跳出当前for循环前，会再一次执行j--
        arr[j + 1] = temp;//执行完上一个语句（即for语句）后，跳出的位置保存在j中，此时arr[j]的值是没有经过移动的，不能替换，应该替换的是arr[j+1]
    }
 }
 //以下是添加进来的啥也不干的main函数
 void main()
 {

 }
 ```

 值得说明的一点是插入排序的复杂度与冒泡排序一样，时间复杂度最坏情况下为O(N^2)最好情况下为O(n)但是，俩算法的交换次数不同，最坏时，冒泡排序需要O(n^2)次交换，而插入排序则只有O(n)次，也就是说，插入排序的最坏情况所需时间应该会比冒泡排序好的多。
 当然，此排序算法也可以改进，以后再说。
## 选择排序(Selection sort)
选择排序，其道理简单易懂，先找数组中最小的，找到后便会把这个数与第1个数交换，之后，在剩下的数中再一次找到最小的，并且与第2个数交换，然后是第3个，第4个，就这样，不停的交换之后，就排序成功了。
以下代码依然引自维基百科：

``
include<stdio.h>
template<typename T> //整数或浮点数皆可使用,若要使用class，需有定义>运算符
void selection_sort(T arr[])
{
    size_t size=sizeof(arr)/sizeof(T)-1;
    T temp;
    for (size_t i = 0; i < size; i++)
    {
        int min = i;
        for (int j = i + 1; j < arr.size(); j++)
        {
            if (arr[j] < arr[min])
            {
                min = j;
            }
        }
        temp=ax[j];
        ax[j]=ax[j+1];
        ax[j+1]=temp;//交换位置
    }
}
void main()
{

}

选择排序的比较次数为O(n^2)而交换次数为O(n)，由于交换需要的时间较多，因此，当n较小时，选择排序比冒泡排序好那么一丁点，而且，选择排序能够原地