C++数据结构基础——冒泡排序&选择排序

函数模板简单介绍

函数模板声明

template <typename 数据类型参数标识符>
<返回类型> <函数名>(参数表)
{
函数体
}
其中，template是定义模板函数的关键字；templat后面的尖括号不能省略；typename是声明数据类型参数标识的关键字，用以说明它后面的标识符是数据类型标识符。这样，在以后定义的这个函数中，凡是希望根据实参数据类型的变量，都可以用数据类型参数标识符来说明，从而使这个变量可以适应不同的数据类型。例如：
template
T funtion(T x,int y)
{
T z=x;
…
}
如果主调函数中有以下语句：
double d;
int a;
function(d,a);
则系统将用实参d的数据类型double去代替函数模板中的T生成函数：
double function(double x,int y)
{
double z = x;
…
}
注意：函数模板只是声明了一个函数的描述模板，不是一个可以直接执行的函数，只用根据实际情况用实参的数据类型代替类型参数标识符之后，才能产生真正的函数。
关键字typename也可以使用关键字class，这时数据类型参数标识符就可以使用所有的C++数据类型。
函数模板的数据类型参数标识符实际上是一个类型形参，在使用函数模板时，要将这个形参实例化为确定的数据类型。将类型形参实例化的参数称为模板实参，用模板实参实例化的函数称为模板函数。模板函数的生成就是将函数模板的类型形参实例化的过程。

冒泡排序

/*
 * 冒泡排序
 * 算法思想
 * 从左到右扫描数据，找出最大的元素，将其放到数组右边；
 *
 * 过程：
 * 循环比较相邻的两个数，如果左边的数比右边的大，则交换两个数
 * */

 template <typename Type>
 void bubbleSort(Type *begin,Type *end)
 {
     if((begin==end)||(begin == NULL)||(end == NULL))
         return ;

     int length = end - begin;
     //注意点（1）：保证一旦数组有序，则会直接停止排序，不会继续进行无用的循环
     bool isOrder = false;

     //外层循环控制扫描次数（Length - 1）
     //注意点（2）：N个元素其实只需N-1次扫描
     for(int i=0; !isOrder && i < length - 1;++i)
     {
         //首先假定这次数组已经有序
         isOrder = true;
         for(Type *iter = begin; iter < end - i - 1;++iter)
         {
             if(*iter > *(iter+1))
             {
                 //交换
                 std::swap(*iter,*(iter+1));
                 isOrder = false;
             }
         }
     }
 }

 template <typename Type>
 void bubbleSort(Type *array,int length)
 {
     return bubbleSort(array,array+length);
 }

选择排序

/*
 *选择排序
 *
 *思想：从当前尚未排序的序列中选择一个最小的元素，将之放到已排序的序列的队列的末尾
 *
 * 要点：
 * 1，注意三个指针（inner，outer，miner）所代表的含义
 * 2，同时注意是从未排序的序列进行查找最小元素
 * */

 template<typename Type>
 void selectSort(Type *begin,Type *end)
 {
     if((begin == end)||(begin == NULL)||(end == NULL))
         return ;

     //只要循环到最后一个元素的前一个就行了，因为剩下的那个肯定是最大的
     for(Type *outer = begin;outer < end - 1;++outer)
     {
         //注意：是从尚未排列的序列中查找（miner = outer,inner = outer+1)
         Type *miner = outer;
         //从miner+1开始遍历数组，寻找一个元素值小于*miner的
         for(Type *inner = outer+1;inner<end;++inner)
         {
             if(*inner < *miner)
             {
                 miner = inner;
             }
         }

         if(miner != outer)
         {
             std::swap(*miner,*outer);
         }
     }
 }

 //为了能够让STL的标准容器vector使用
 template <typename Iterator>
 void selectSort(Iterator iter1,Iterator iter2)
 {
     return selectSort(&(*iter1),&(*iter2));
 }


 template <typename Type>
 void selectSort(Type *array,int length)
 {
     return selectSort(array,array+length);
 }

测试程序

#include <iostream>
#include <vector>
#include <time.h>

using namespace std;
int main()
 {
     srand(time(NULL));
     vector<double> dVec;
     int count = 10;
     while(count --)
     {
         dVec.push_back((rand()%1000)/100.0);
     }

     selectSort(dVec.begin(),dVec.end());

     for(vector<double>::iterator iter = dVec.begin();iter < dVec.end();++iter)
     {
         cout << *iter <<endl;
     }

     return 0;
 }