排序算法的c++實現——快速排序

    快速排序是分治思想的又一典型代表，是應用最廣的排序算法。分治思想就是把原問題的解分解為兩個或多個子問題解，求解出子問題的解之后再構造出原問題的解。

    在快速排序算法中，它的思想是把一個待排序的數組分成前半部分和后半部分，並且要求前半部分的值都大於等於或都小於等於后半部分的解, 當前半部分與后半部分都變成有序（通過遞歸調用快速排序來實現）后，我們就不需要合並兩個子問題的解就已經得到了原問題的解。這也是為什么要求前半部分都大於等於或都小於等於后半部分的原因。所以呢，快速排序的核心在於如何把一個待排序的數組分成兩部分！

說明幾點：
1. 如何把待排序的數組划分為符合要求的兩部分！
2. 期望的時間復雜度為O(NlogN), 最壞的時間復雜度為O(N*N)
 3. 快速排序為原址排序，不需要額外的內存空間.
 4. 快速排序不是穩定排序, 在交換過程中會破壞穩定性。

代碼如下：

/***********************************************************************
  *   Copyright (C) 2019  Yinheyi. <[e-mail]>
  *   
  * This program is free software; you can redistribute it and/or modify it under the terms
  * of the GNU General Public License as published by the Free Software Foundation; either 
  * version 2 of the License, or (at your option) any later version.
  
  *   Brief:    
  *   Author: yinheyi
  *   Email: [e-mail]
  *   Version: 1.0
  *   Created Time: 2019年05月08日 星期三 21時54分04秒
  *   Modifed Time: 2019年05月10日 星期五 22時16分17秒
  *   Blog: http://www.cnblogs.com/yinheyi
  *   Github: https://github.com/yinheyi
  *   
  ***********************************************************************/
  
  
  // 1. 快速排序是分治思想的又一典型代表，是應用最廣的排序算法。
  // 2. 分治思想就是把原問題的解分解為兩個或多個子問題解，求解出子問題的解之后再構造出原
  // 問題的解。
  // 3. 在快速排序算法中，它的思想是把一個待排序的數組分成前半部分和后半部分，並且要求
  // 前半部分的值都大於等於或都小於等於后半部分的解, 當前半部分與后半部分都變成有序（通
  // 過遞歸調用快速排序來實現）后，我們就不需要合並兩個子問題的解就已經得到了原問題的解。
  // 這也是為什么要求前半部分都大於等於或都小於等於后半部分的原因。
  // 4.所以呢，快速排序的核心在於如何把一個待排序的數組分成兩部分！
  //
  // 核心點：
  // 1. 如何把待排序的數組划分為符合要求的兩部分！
  // 2. 期望的時間復雜度為O(NlogN), 最壞的時間復雜度為O(N*N)
  // 3. 快速排序為原址排序，不需要額外的內存空間.
  // 4. 快速排序不是穩定排序, 在交換過程中會破壞穩定性。
  //
  #include<cassert>
  #include <stdexcept>
  #include <iostream>
  static inline void swap(int&, int&);
  bool less(int lhs, int rhs);
  bool greate(int lhs, int rhs);
  static void PrintArray(int array[], int nLength_);
  typedef bool (*Compare)(int, int);
  
  /****************  版本一：使用數組的長度作為參數        ***************/
  // 該函數實現對數組數列的划分;
  // 輸入值為數組指針/數組的長度/比較函數指針，
  // 返回值為划分點的下標, 也就是后半部分第一個元素的下標;
  int Partition(int array[], int nLength_, Compare CompFunc)
  {
      if (array == nullptr || nLength_ <= 0 || CompFunc == nullptr)
      { 
          assert(false);
          throw std::invalid_argument("參數不合法！");
      }       
  
      int _nBoundValue = array[0];        // 划分區間的邊界值
      int _nBoundIndex = 0;               // 指向邊界的下標, 即第二部分第一個元素的下標;
      for (int i = 1; i < nLength_; ++i)      
      {   
          if (CompFunc(array[i], _nBoundValue))
          {
              swap(array[i], array[_nBoundIndex]);
              ++_nBoundIndex;
          }       
      }  
  
      // 如果第一個元素正好是最大或最小元素時，把返回值加1, 也就是把數組划分為第一個元素
      // 和剩余的其它元素兩部分。
      if (0 == _nBoundIndex)
          return _nBoundIndex + 1;
      else
          return _nBoundIndex;
  }
  
  // 快速排序的功能函數
  void QuickSort(int array[], int nLength_, Compare CompFunc)
  {
      if (array == nullptr || nLength_ <=1 || CompFunc == nullptr)
          return;
  
      int _nPartionIndex = Partition(array, nLength_, CompFunc);
      QuickSort(array, _nPartionIndex, CompFunc);
      QuickSort(array + _nPartionIndex, nLength_ - _nPartionIndex, CompFunc);
  }
  
  /****************  版本二：使用數組的下標區間作為參數        ***************/
  // 該函數實現對數組的划分。
  // 輸入參數為數組指針/半閉半開區間[start, end)表示的數組范圍/比較謂詞
  // 返回值為划分點的下標, 也即后半部分第一個元素的下標。
  int Partition_Version2(int array[], int nStart_, int nEnd_, Compare CompFunc)
  {
      if (array == nullptr || nEnd_ - nStart_ <= 0 || CompFunc == nullptr)
      {
          assert(false);
          throw std::invalid_argument("參數不合法！");
      }
  
      int _nBoundValue = array[nStart_];      // 划分區間的邊界值
      int _nBoundIndex = nStart_;             // 指向邊界的下標, 即第二部分第一個元素的下標;
      for (int i = nStart_ + 1; i < nEnd_; ++i)
      {
          if (CompFunc(array[i], _nBoundValue))
          {
              swap(array[i], array[_nBoundIndex]);
              ++_nBoundIndex;
          }
      }
  
      // 如果第一個元素正好是最大或最小元素時，把返回值加1, 也就是把數組划分為第一個元素
      // 和剩余的其它元素兩部分。
      if (_nBoundIndex == nStart_)
          return _nBoundIndex + 1;
      else
          return _nBoundIndex;
  }
  
  void QuickSort_Version2(int array[], int nStart_, int nEnd_, Compare CompFunc)
  {
      if (array == nullptr || nEnd_ - nStart_ <= 1 || CompFunc ==nullptr)
          return;
  
      int _nPartionIndex = Partition_Version2(array, nStart_, nEnd_, CompFunc);
      QuickSort_Version2(array, nStart_, _nPartionIndex, CompFunc);
      QuickSort_Version2(array, _nPartionIndex, nEnd_, CompFunc);
  }
  
  // 測試函數
  /***************    main.c     *********************/
  int main(int argc, char* argv[])
  {
      int array[10] = {-12, 23, 443, 112, 12, -9098, 3432, 0, 0, 0};
      std::cout << "原數組的順序為：" << std::endl;
      PrintArray(array, 10);
      std::cout << "版本一的快速排序：" << std::endl;
      std::cout << "從小到大：" << std::endl;
      QuickSort(array, 10, less);
      PrintArray(array, 10);
      std::cout << "從大到小：" << std::endl;
      QuickSort(array, 10, greate);
      PrintArray(array, 10);
      std::cout << std::endl;
  
  
      int array2[10] = {-12, 23, 443, 112, 12, -9098, 3432, 0, 0, 0};
      std::cout << "版本二的快速排序：" << std::endl;
      std::cout << "從小到大：" << std::endl;
      QuickSort_Version2(array2, 0, 10, less);
      PrintArray(array2, 10);
      std::cout << "從大到小：" << std::endl;
      QuickSort_Version2(array2, 0, 10, greate);
      PrintArray(array2, 10);
  
      return 0;
  }
  
  
  inline void swap(int& lhs, int& rhs)
  {
      int _nTemp = lhs;
      lhs = rhs;
      rhs = _nTemp;
  }
  
  // 小於比較函數
  bool less(int lhs, int rhs)
  {
      return lhs < rhs;
  }
  
  // 大於比較函數
  bool greate(int lhs, int rhs)
  {
      return lhs > rhs;
  }
  
  // 打印數組函數
  static void PrintArray(int array[], int nLength_)
  {
      if (nullptr == array || nLength_ <= 0)
          return;
  
      for (int i = 0; i < nLength_; ++i)
      {
          std::cout << array[i] << " ";
      }
  
      std::cout << std::endl;
  }