从大的方面来说，排序可以分成内排序和外排序——内排序是外排序的基础。我们常用的内排序又可以粗略分成下面的类型：

    1.经典算法：如冒泡排序；

    2.插入排序及希尔排序；

    3.选择交换排序；

    4.堆排序；

    5.归并排序；

    6.快速排序。

别看排序有那么多种类型，但它们都离不开这样的核心思想   

一个待排序列总是被不断从无序序列转变为有序序

一。经典算法：冒泡排序
      原理 ：在每一遍历中，通过相邻元素的比较 （“冒泡”的比较形象），找到这趟遍历的最小值（或者最大值），并且放到合适的位置
     时间复杂度 O(n^2)

//////////////////////////////////////////////////////////////////////////
///// 冒泡排序
template<typename T>
inline void my_swap(T& l , T& r)
{
    T  tmp = l ;
    l =r ;
    r = tmp ;
}
 
template<typename T>
void BubbleSort(T Arr[] ,int N)
{    
    for (int i= 0 ; i < N  ; i++ )
    {
        for(int j= N-1 ; j > i ; j--)
        {
            if (Arr[j] < Arr[j -1])
            {
                my_swap(Arr[j] , Arr[j -1])   ;
            }
        }
    }
}

二。插入排序：

   原理  每一趟处理一个元素，将该元素放于该元素之前的子数组（有序）中的正确位置，共需n-1趟。    时间复杂度 O(n^2)
   (思想来源玩扑克的时候，插牌)

template<typename T>
void InsertSort(T Arr[] ,int N)
{
    int j ;
    for (int p =1 ; p < N ;p++)
    {
        T tmp = Arr[p] ;
        for (j = p ;j> 0 && tmp < Arr[j -1] ; j--)
        {
            Arr[j] = Arr[j-1]  ;
        }

        Arr[j] = tmp ;
    }
}

 
三 希尔排序

//////////////////////////////////////////////////////////////////////////
/// shell 发明者Donald Shell 该算法是冲破2次时间障碍的第一批算法，
///  通过比较一定间隔的元素工作，距离随着算法的进行而减小
//// 直到比较相邻元素最后一趟位置   ----》 也叫缩减增量排序
//// 最坏 Θ(O^2)  不同的增量最坏的时间复杂度 不一样                 
template<typename T>
void ShellSort(T Arr[] ,int N)
{
    for(int gap = N /2 ; gap > 0 ; gap /=2)
        for(int i =gap ; i < N ; i++)
        {
            T tmp= Arr[i] ;
            int j= i ;
            for( ; j>= gap && tmp<Arr[j -gap] ;j -= gap)
                Arr[j]  =Arr[j -gap] ;
        
            Arr[j] =tmp  ;
        }
}

/*****
* Function: 大整数相乘算法
* 参数：
*  a: 乘数,字符串，一个字符代表整数的一位，左侧是最高位，右侧是最低位
*  b: 乘数，同上
*  n: a的长度
*  m: b的长度
* 没有返回值，结果直接放到全局变量res数组中，如果不想要全局变量，也可以在函数中多加一个参数，保存结果。
  res中每一位存放相乘结果的各个位，跟输入不同，右侧放的是高位，即高位的对应的数组索引也是高的。
*****/

void Multiply(char *a,char *b,int n,int m)            // 大整数相乘
{
 int i,j,temp,t,tt;
 int num=0;
 memset(res,0,sizeof(res));
 for(i=0;i<m;i++)
 {
  temp=0;
  for(j=0;j<n;j++)
  {   
   t=(a[n-1-j]-'0')*(b[m-1-i]-'0')+temp;//从最低位开始计算
   if(0 == t)   
    continue;               
   num = j+i;       
   tt = res[num]+(t);   
   res[num] = tt%10;   
   temp = tt/10;
  }
  if( temp > 0 )
  {
   res[++num] += temp;
  }
 }
 for(i=num;i>=0;i--)                    // 输出结果
  printf("%d",res[i]);
 printf("\n");
}