算法导论之归并排序

归并排序的思想就是分治法；

分治法：为了解决一个给定的问题，算法一次或多次递归地调用其自身以解决紧密相关的若干子问题。

分治模式在每层递归时都有三个步骤：

一，分解原问题为若干子问题。

二，解决这些子问题，递归求解各子问题。

三，合并这些子问题的解成原问题的解。

了解了分治法之后，我们再来看下归并排序：

1，分解：分解待排序的n个元素的序列各具n/2个元素的两个子序列。

2，解决：使用归并排序递归地排序两个子序列。

3，合并：合并两个已排序的子序列以产生已排序的答案。

下面先附上代码：

//
//  main.cpp
//  算法导论
//
//  Created by SJCHEN on 2019/1/19.
//  Copyright © 2019 SJCHEN. All rights reserved.
//
#include <iostream>
using namespace std;
#define MAX 100000//定义哨兵
int A[] = {5,2,4,7,1,3,2,6};
int len = sizeof(A)/sizeof(A[0]);
void printA()
{
    for (int i = 0; i < len); ++i) {
        cout << A[i] << " ";
    }
    cout << endl;
}

void Merge(int start,int mid, int end)
{
    int LeftSortLen = mid - start + 1;//左边需要排序的个数
    int RightSortLen = end - mid;//右边------
    int *ALeft = new int[LeftSortLen + 1];//增加一个1用来存放哨兵
    int *ARight = new int[RightSortLen + 1];//右边数组
    for (int i = 0; i < LeftSortLen; ++i)
        ALeft[i] = A[start + i];
    for (int j = 0; j < RightSortLen; ++j)
        ARight[j] = A[mid + j + 1];
    ALeft[LeftSortLen] = MAX;//哨兵
    ARight[RightSortLen] = MAX;
    int i = 0, j = 0;
    for (int k = start; k <= end; ++k) {
        if (ALeft[i] <= ARight[j]) {
            A[k] = ALeft[i];
            i++;
        }
        else {
            A[k] = ARight[j];
            j++;
        }
    }
    delete[] ALeft;
    delete[] ARight;
}

void MergeSort(int start, int end)
{
    if (start >= end) return;
    int mid = (start + end) / 2;
    MergeSort(start, mid);
    MergeSort(mid + 1, end);
    Merge(start, mid, end);
}

int main()
{
    MergeSort(0,len - 1);
    printA();
    return 0;
}

下面是不使用哨兵的做法

void Merge(int start,int mid, int end)
{
    int LeftSortLen = (mid - start + 1);
    int RightSortLen = end - mid;
    int *ALeft = new int[LeftSortLen];
    int *ARight = new int[RightSortLen];
    for (int i = 0; i < LeftSortLen; ++i)
        ALeft[i] = A[start + i];
    for (int j = 0; j < RightSortLen; ++j)
        ARight[j] = A[mid + 1 + j];
    int i = 0, j = 0;
    for (int k = start; k <= end; ++k) {
        if (i < LeftSortLen && j < RightSortLen) {
            if (ALeft[i] <= ARight[j]) {
            A[k] = ALeft[i];
            i++;
            continue;
            }
            else {
                A[k] = ARight[j];
                j++;
                continue;
            }
        }
        if (i >= LeftSortLen && j < RightSortLen) {
            A[k] = ARight[j];
            j++;
            continue;
        }
        if (i < LeftSortLen && j >= RightSortLen) {
            A[k] = ALeft[i];
            i++;
            continue; 
        }
    }
    delete[] ALeft;
    delete[] ARight;
}