七、排序，选择、冒泡、希尔、归并、快速排序实现

一、排序的基本概念

排序：将“无序”的数据元素调整为“有序”的数据。

排序算法的稳定性：如果待排列的排序表中有两个元素R1、R2，其对应的关键字Key1 = Key2，且在排序前R1就在R2的前面，如果使用某一种排序算法后，R1仍然在R2的前面，则称这个排序算法是稳定的，否则是不稳定的。

注：对于不稳定的算法，只需举出一个范例即可正面不稳定性。

多关键字排序：按照优先级，分别进行排序。

排序中的关键操作：

比较：任意两个数据元素通过比较操作确定先后顺序；

交换：数据元素之间需要交换才能得到预期效果。

排序的审判：

1、时间性能：差异体现在比较和交换的数量，主要看循环次数

2、空间：存储空间的多少，必要时可以：空间换时间

3、算法的实现复杂性：过于复杂可能会影响可读性和可维护性。

排序的时间性能是区分排序算法好坏的主要因素。

交换函数模板的实现

    template<typename T>
    static void Swap(T& a, T& b)  //定义交换函数  静态的
    {
        T c(a);
        a = b;
        b =c;
    }

二、选择排序与插入排序

选择排序：先比较、再交换，即选定最小（最大）的数据。

    template < typename T>
    static void Select(T array[], int len, bool min2max = true)  //不稳定的排序算法
    {
        for(int i=0; i<len; i++)
        {
            int min = i;

            for(int j=i+1; j<len; j++)
            {
                if( min2max ? (array[min] > array[j]) : (array[min] < array[j]) )
                {
                    min = j;  //当前最小值的位置
                }
            }

            if( min != i)
            {
                Swap(array[i], array[min]);
            }
        }
    }

插入排序：先比较，再插入，再后移。

    template < typename T>
    static void Insert(T array[], int len, bool min2max = true) //稳定的排序算法
    {
       for(int i=1; i<len; i++)
       {
           int k = i;
           T e = array[i];  //要插入的数据

           for(int j=i-1; (j>=0) && (min2max ? (array[j] > e) : (array[j] < e)); j--)
           {
                  array[k] = array[j]; // k = j+1 后移一位直至a[i]的前面的数字比a[i】小（为真的前提下 ）
                  k = j;
           }

           if( k != i)
           {
                array[k] = e;
           }
       }
    }

选择排序和插入排序的时间复杂度都为O（n2）。

三、冒泡排序与希尔排序

冒泡排序：从后向前，两两比较，逆序交换。

    template < typename T>
    static void Bubble(T array[], int len, bool min2max = true)  // O(n2) 最坏的情况下   稳定的排序法
    {
      bool exchange = true;

      for(int i=0; (i<len) && exchange ; i++)
      {
          exchange = false;

          for(int j=len-1; j>i; j--)
          {
             if( min2max ? (array[j] < array[j-1]) : (array[j] > array[j-1]))
             {
                Swap(array[j], array[j-1]);
                exchange = true;  //进行下一次循环的条件，否则循环结束
             }
          }
      }
    }

希尔排序：将待排序列分为若干组，在每一组内进行插入排序，以使整个序列基本有序，然后对整个序列进行插入排序。

步长！步长！步长！——划分序列的依据。

    template < typename T>
    static void Shell(T array[], int len, bool min2max = true) //不稳定的排序法 O（n3/2)）
    {
        int d = len;

        do
        {
            d = d/3 + 1;  //实践证明

            for(int i=d; i<len; i+=d)
            {
                int k = i;
                T e = array[i];

                for(int j=i-d; (j>=0) && (min2max ? (array[j] > e) : (array[j] < e)); j-=d)
                {
                       array[j+d] = array[j];
                       k = j;
                }

                if( k != i)
                {
                     array[k] = e;
                }
            }

        }while( d > 1);
    }

划时代的意义：将排序算法的复杂度从n的平方降低。

也可以通过冒泡的方法，将每组内的数据进行排列，具体实现如下：

    template < typename T>
    static void Shell2Bubble(T array[], int len, bool min2max = true)
    {
        int d = len;

        do
        {
            d = d/3 + 1;  //实践证明

            bool exchange = true;

            for(int i=0; (i<len) && exchange ; i+=d)
            {
                exchange = false;

                for(int j=len-d; j>i; j-=d)
                {
                   if( min2max ? (array[j] < array[j-1]) : (array[j] > array[j-1]))
                   {
                      Swap(array[j], array[j-1]);
                      exchange = true;
                   }
                }
            }

        }while( d > 1);
    }

四、归并排序与快速排序

归并排序的基本思想：

将两个或两个以上的有序序列合并成一个新的有序序列，这种归并方法称为2路归并。

所以，对于无序序列，就必须先分别进行排序。如何排序呢？————降维、递归！

具体实现如下：

    template <typename T>
    static void Merge( T array[], int len, bool min2max = true)
    {
       T *helper = new T[len];

       if( helper != NULL)
       {
            Merge(array, helper, 0, len-1, min2max);
       }

       delete[] helper;
    }

    template <typename T>  //二路归并排序
    static void Merge( T src[], T helper[], int begin, int end, bool min2max )
    {
        if( begin < end)
        {
            int mid = (begin + end) / 2;
            
/*****************************递归******************************/
            Merge(src, helper, begin, mid, min2max);
            Merge(src, helper, mid+1, end, min2max);
            Merge(src, helper, begin, mid, end, min2max);
        }
    }

    template <typename T>  //二路归并排序
    static void Merge( T src[], T helper[], int begin, int mid, int end, bool min2max )
    {
       int i = begin;
       int j = mid + 1;
       int k = begin;

       while( (i <= mid) && (j <= end) )
       {
           if( min2max ? (src[i] < src[j]) : (src[i] > src[j]) )
           {
               helper[k++] = src[i++];
           }
           else
           {
               helper[k++] = src[j++];          
           }
        }

           while( i <= mid)
           {
               helper[k++] = src[i++];
           }

           while( j <= end)
           {
               helper[k++] = src[j++];
           }

           for(i=begin; i<=end; i++)
           {
               src[i] = helper[i];

               //cout<< " src[i]" << src[i]<<endl;
           }

    }

可以用下面的示意图来表示上述归并过程，通过递归，不断增加参数来进行排序。

快速排序：任取序列中的某个数据元素作为基准将整个序列划分为左右两个子序列

左侧子序列中的所有元素都小于或等于基准元素；

右侧子序列中的所有元素都大于基准元素；

基准元素排在这两个子序列中间。

分别对这两个子序列重复继续划分（递归），直到所有的数据元素都排在相应位置上为止。

最重要的是要找到基准元素！

实现代码如下：

    template <typename T>
    static int Partition(T array[], int begin, int end, bool min2max)
    {
        T pv = array[begin];

        while( begin < end )
        {
            while( (begin < end) && (min2max ? (array[end] > pv) : (array[end] < pv)))
            {
                end--; //大于基准则往前进一位
            }
            /**************跳出循环后进行交换******************/
            Swap(array[begin], array[end]);

            while((begin < end) && (min2max ? (array[begin] <= pv) : (array[begin] >= pv)))
            {
                begin++; //小于则往后进一位
            }

            Swap(array[begin], array[end]);
        }

        array[begin] = pv;  //基准就位

        return begin;  //返回基准的最终下标
    }

通过上面的函数，就可以确定在快速排序中进行比较的基准元素的位置，

在Quick函数中，实现如下：

    template<typename T>
    static void Quick(T array[], int begin, int end, bool min2max )
    {
        if( begin < end)
        {
            int pivot = Partition(array, begin, end, min2max);

            Quick(array, begin, pivot-1, min2max);
            Quick(array, pivot+1, end, min2max);
        }
    }

封装成接口如下：

    template<typename T>
    static void Quick(T array[], int len, bool min2max = true)
    {
        Quick(array, 0, len-1, min2max);
    }

小结：

归并排序需要额外的空间才能完成，空间复杂度为O(n)；

归并排序的时间复杂度为O(n*logn)，是一种稳定的排序法；

快速排序通过递归的方式对排序问题进行划分；

快速排序的时间复杂度为O(n*logn)，是一种不稳定的排序法。

五、排序的工程应用实例

数组类（array()）与排序类（Sort()）的关系：

array():T*     ——返回C++、C数组的首地址。

    T* array() const
    {
        return m_array;  //返回原生数组的首地址
    }

在排序类（Sort()）中针对自定义的数组类（array()）对象进行函数重载，分别实现数组类对象的不同排序方法。

    template <typename T>
    static void Select(Array<T>& array, bool min2max = true)
    {
        Select(array.array(), array.length(), min2max);
    }

    template <typename T>
    static void Insert(Array<T>& array, bool min2max = true)
    {
        Insert(array.array(), array.length(), min2max);
    }

    template <typename T>
    static void Bubble(Array<T>& array, bool min2max = true)
    {
        Bubble(array.array(), array.length(), min2max);
    }

    template <typename T>
    static void Shell(Array<T>& array, bool min2max = true)
    {
        Shell(array.array(), array.length(), min2max);
    }

    template <typename T>
    static void Merge(Array<T>& array, bool min2max = true)
    {
        Merge(array.array(), array.length(), min2max);
    }

    template <typename T>
    static void Quick(Array<T>& array, bool min2max = true)
    {
        Quick(array.array(), array.length(), min2max);
    }

排序类能够对数组类对象进行排序。