归并排序

归并排序是建立在归并操作上的一种稳定的排序算法。

归并排序的思路

• 分割：递归的将当前序列分割成两部分
• 合并：将两个有序的序列合并成一个有序序列

归并排序的递归实现

• 准备辅助空间，使其大小为两个有序数列大小之和。
• 设两个指针分别指向两个数列的起始位置。
• 比较两指针所指元素的大小，选择小(大)的放入合并空间，然后移动指针。
• 重复上一步，直到其中一个指针移到了数列尾部
• 将另一个数列剩下的元素复制到合并序列尾。

C++源码

namespace Algorithm {
  namespace Sort {
    template<typename T>
    void Merge(T* A, int begin, int end, int mid) {
      T* B = new T[end - begin + 1]();
      for(int i = 0; i <= (end - begin); i++) {
        B[i] = A[i + begin];
      }
      int i = begin;
      int j = mid + 1;
      int t = begin;
      while(i <= mid && j <= end) {
        if(B[i] <= B[j]) {
          A[t++] = B[i++];
        }
        else {
          A[t++] = B[j++];
        }
      }
      while(i <= mid) {
        A[t++] = B[i++];
      }
      while(j <= end) {
        A[t++] = B[j++]; 
      }

      delete[] B;
    }

    template<typename T>
    void MergeSort(T* A, int begin, int end) {
      if(begin >= end) {
        return;
      }
      int mid = (begin + end) / 2;
      MergeSort(A, begin, mid);
      MergeSort(A, mid + 1, end);
      Merge(A, begin, end, mid);
    }
  }
}

归并算法的迭代实现

• 将待排序的序列每相邻两个数字进行归并，形成若干个序列长度为1或2的有序数列。
• 将序列长度不是1的数列再次归并，形成若干个长度为3或4的有序数列。
• 重复上述归并步骤，直到排序完毕。

C++源码

namespace Algorithm {
  namespace Sort {
    template<typename T>
    void MergeSort(T* A, int len) {
      T* temp_a = A;
      T* B = new T[len];
      for(int part = 1; part < len; part += part) {
        for(int begin = 0; begin < len; begin += 2 * part) {
          int low = begin;
          int mid = (begin + part) > len ? len : (begin + part);
          int high = (begin + 2 * part) > len ? len : (begin + 2 * part);
          int i = low;
          int j = mid + 1;
          int t = low;
          while(i < mid && j < high) {
            if(A[i] < A[j]) {
              B[t++] = A[i++];
            }
            else {
              B[t++] = A[j++];
            }
          }
          while(i < mid) {
            B[t++] = A[i++];
          }
          while(j < high) {
            B[t++] = A[j++];
          }
        }
        T* temp = A;
        A = B;
        B = temp;
      }
      if(temp_a != A) {
        for(int i = 0; i < len; i++) {
          B[i] = A[i];
        }
        B = A;
      }
      delete[] B;
    }
  }
}