归并排序及统计数组逆序对



1.归并排序

《算法导论》P19

参考网址：

白话经典算法系列之五 归并排序的实现 - MoreWindows Blog -博客频道 - CSDN.NET

http://blog.csdn.net/morewindows/article/details/6678165

#include "stdafx.h"
#include <iostream>
using std::cout;

#define ARRAY_LENGTH 11

//排序两个已经排好序的数组
//参数：data原始数组，copy组合成的数组,start，mid，end记录两个数组在原始数组中的位置
//      mid表示第一个数组的截止位置
void Merge(int data[],int copy[],size_t start,size_t mid,size_t end)
{
//判断输入参数是否合法
if ((data != nullptr) && (copy != nullptr) && (start <= mid) && (mid < end))
{
size_t i = start;    //左数组开始位置
size_t j = mid + 1;  //右数组开始位置
size_t index = start;//辅助数组开始位置
while ((i <= mid) && (j <= end))
{
//比较两个值，较小者放入辅助数组中，并将指针前移
if (data[i] <= data[j])
{
copy[index++] = data[i++];
}
else
{
copy[index++] = data[j++];
}
}

//处理一个数组遍历完，另一个数组还有剩余元素的情况
while (i <= mid)
{
copy[index++] = data[i++];
}

while (j<=end)
{
copy[index++] = data[j++];
}

//整理排序好后的data数组
for (size_t k = 0; k <= end; k++)
{
data[k] = copy[k];
}
}
}

//归并算法核心算法
void Merge_Sort(int data[], int copy[], size_t start, size_t end)
{
if ((data != nullptr) && (copy != nullptr))
{
if ((start < end))
{
size_t mid = (start + end) / 2;
//分治思想
Merge_Sort(data, copy, start, mid);
Merge_Sort(data, copy, mid + 1, end);
//对数组进行排序
Merge(data, copy, start, mid, end);
}
}
else
{
cout << "数组参数输入有误";
}
}

//打印数组
void printf_array(int data[], size_t length)
{
for (size_t i = 0; i < length; i++)
{
cout << data[i] << std::endl;
}
}

int _tmain(int argc, _TCHAR* argv[])
{
int data[] = {10,32,9,1,23,42,5,67,88,23,7};
//printf_array(data, ARRAY_LENGTH);
int copy[ARRAY_LENGTH];
Merge_Sort(data, copy, 0, ARRAY_LENGTH - 1);
printf_array(data, ARRAY_LENGTH);
return 0;
}

Java版，代码几乎相同：

public class Merge_Sort {

// 排序算法
private void Merge(int[] data, int[] copy, int start, int mid, int end) {

//判断输入参数是否合法
if ((data != null) && (copy != null) && (start <= mid) && (mid < end))
{
int i = start;    //左数组开始位置
int j = mid + 1;  //右数组开始位置
int index = start;//辅助数组开始位置
while ((i <= mid) && (j <= end))
{
//比较两个值，较小者放入辅助数组中，并将指针前移
if (data[i] <= data[j])
{
copy[index++] = data[i++];
}
else
{
copy[index++] = data[j++];
}
}

//处理一个数组遍历完，另一个数组还有剩余元素的情况
while (i <= mid)
{
copy[index++] = data[i++];
}

while (j<=end)
{
copy[index++] = data[j++];
}

//整理排序好后的data数组
for (int k = 0; k <= end; k++)
{
data[k] = copy[k];
}
}

}

public void Merge_Sort(int[] data, int[] copy, int start, int end) {
if (start < end) {
int mid = (start + end) / 2;
Merge_Sort(data, copy, start, mid);
Merge_Sort(data, copy, mid + 1, end);
Merge(data, copy, start, mid, end);
}

}

public static void main(String[] args) {

int data[] = {2,34,45,2,13,24,5,24,57};
new Merge_Sort().Merge_Sort(data, new int[data.length], 0, data.length-1);

for(int  num : data)
{
System.out.print(num);
System.out.print(" ");
}
}

}

2.使用归并排序处理相关问题，统计数组中的逆序对

《剑指Offer》P191

// InversePais1.cpp : 计算N个元素的数组的逆序对
//

#include "stdafx.h"

//计算逆序对函数
int get_InversePairs(int data[],int copy[],size_t start,size_t mid,size_t end)
{
int count = 0;
//判断数组是否为空，及输入的位置参数是否合法
if ((data!=nullptr)&&(copy!=nullptr)&&(start <= mid)&&(mid < end))
{
int i = mid;
int j = end;
int index = end;

while ((i >= start)&&(j >= mid + 1)&&(i * j >= 0))
{
//比较取最大者，放在辅助数组的末位
if (data[i] > data[j])
{
copy[index--] = data[i--];
count += (j - mid);//逆序对统计
}
else
{
copy[index--] = data[j--];
//此时表示后者大于前者，不满足逆序对的定义，故count不进行操作
}
}
//处理剩余数组(注：此情况count也不再会发生改变，因为已经统计完全)
while ((i >= start) && (i >= 0))
{
copy[index--] = data[i--];
}

while ((j >= mid + 1) && (j >= 0))
{
copy[index--] = data[j--];
}
printf("原始数据:");
for (size_t k = start; k <= end; k++)
{
printf("%d ", data[k]);
}
printf("\n当前数据:");
for (size_t k = start; k <= end; k++)
{
data[k] = copy[k];
printf("%d ", data[k]);
}
printf("\n");
printf("逆序对数:%d\n", count);
}
return count;
}

int Reverse_Pairs(int data[], int copy[], size_t start, size_t end)
{
if ((data == nullptr) || (copy == nullptr))
{
return 0;
}
if (start >= end)
{
return 0;
}
//分治策略
int mid = (start + end) / 2;
int left = Reverse_Pairs(data, copy, start, mid);
int right = Reverse_Pairs(data, copy, mid + 1, end);
int count = get_InversePairs(data, copy, start, mid, end);
return left + right + count;

}

int _tmain(int argc, _TCHAR* argv[])
{
int data[] = {7,5,6,4};
const size_t LENGTH = 4;
int copy[LENGTH];
printf("%d\n", Reverse_Pairs(data, copy, 0, LENGTH-1));
return 0;
}