java分治排序算法_分治策略对数组进行排序（二分排序算法）

分治策略对数组进行排序(二分排序算法)

今天我来熟悉巩固一下分治算法对数组进行排序，分治问题就是把复杂的大问题拆解成简单的小问题，再将小问题依次解决，假设我们要对下面这个数组进行排序输出：

[ 32, 11, 22, 17, 222, 42, 162, 82, 1, 1231, 12, 2 ]

如果使用分治策略的话，我们需要先将大问题分解成小问题，我们可以先将长度 12 的数组分解为两个长度为 6 的数组，分解后如下

[ 32, 11, 22, 17, 222, 42 ]

[ 162, 82, 1, 1231, 12, 2 ]

分解过后是否可以直接进行排序了呢？好像还是不太行，那么我们可以继续分解，分解到可以直接进行比较为止

// 第二次分解

[ 32, 11, 22 ]

[ 17, 222, 42 ]

[ 162, 82, 1 ]

[ 1231, 12, 2 ]

// 第三次分解

[ 32, 11 ]

[ 22 ]

[ 17, 222 ]

[ 42 ]

[ 162, 82 ]

[ 1 ]

[ 1231, 12 ]

[ 2 ]

// 第四次分解

[ 32 ]

[ 11 ]

[ 22 ]

[ 17 ]

[ 222 ]

[ 42 ]

[ 162 ]

[ 82 ]

[ 1 ]

[ 1231 ]

[ 12 ]

[ 2 ]

我们的最终目标是将复杂数组分解成为长度为 1 的小数组，这样我们就可以直接对两个数组进行比较，比如 [32] 与 [11] 比较，此时应该进入一个循环，比较两个数组的首个元素，比较完成后将其合并得到 [ 11, 32 ]，再使用 [ 11, 32 ] 与 [ 22 ] 比较数组的首个元素大小，比较完成后进行合并得到 [ 11, 22, 32 ]，以此类推，最后得到的将会是一个排序完成的。

我们将上面的分析进行步骤划分，我们应该需要实现两个功能：

将复杂数组划分为原子级别的简单数组；

将原子级别的数组进行比对后依次合并，重新组成排序好的复杂数组；

我们现在来进行代码的实现，首先我们创建一个接口来形容这个排序算法类

public interface Sort {

public int[] sort(int[] arr);

}

然后我们来编辑这个类的实现，最后的调用效果应该是这样的：

import java.util.Arrays;

public class DivisionSort implements Sort {

@Override

public int[] sort(int[] arr) {

//...

return arr;

}

public static void main(String[] args) {

int[] arr = new int[] { 32, 11, 22, 17, 222, 42, 162, 82, 1, 1231, 12, 2 };

Sort divisionSort = new DivisionSort();

int[] sortedArr = divisionSort.sort(arr);

System.out.println(Arrays.toString(sortedArr));

}

}

我们现在先进行第一步，将复杂数组分解为简单数组：

private void splitArr(int[] arr, int start, int end) {

// 当数组开始位置等于结束位置才停止分割(此时数组长度为 1)

if (end != start) {

// 取中点位置，递归调用将数组分为两份

int mid = (end + start) / 2;

splitArr(arr, start, mid);

splitArr(arr, mid + 1, end);

}

}

分解的函数就是一个递归调用，递归将数组分割为原子级别，而合并的函数，我们可以好好想一下，如何对比 [ 11, 32 ] 和 [ 22 ]，应该依次取出两个数组的第一个元素，比对完成后将较小的一个推入合并后的数组。

所以这里应该是先比较 11 和 22 的大小，然后将 11 推入合并后的数组，比较完成后再比较 32 和 22，然后将 22 推入合并后的数组，最后的比较将会判断到某个数组已经无元素可对比，那么另一个数组剩余的数字均是大数，直接推入合并后的数组即可，那么实现出来以后就是：

private void mergeArr(int[] arr, int start, int end) {

// 将数组分为左右两边进行对比

// 比如 { 11 32 22 } 将被分为 { 11 32 } 和 { 22 } 两个数组

int mid = (start + end) / 2;

int[] leftArr = Arrays.copyOfRange(arr, start, mid + 1);

int[] rightArr = Arrays.copyOfRange(arr, mid + 1, end + 1);

int i = 0, j = 0;

for (int k = start; k <= end; k++) {

// 判断数组是否已经没有多余元素

if (i == leftArr.length) {

arr[k] = rightArr[j];

j++;

continue;

}

if (j == rightArr.length) {

arr[k] = leftArr[i];

i++;

continue;

}

if (leftArr[i] < rightArr[j]) {

arr[k] = leftArr[i];

i++;

} else {

arr[k] = rightArr[j];

j++;

}

}

}

最后组成后的 DivisionSort 类就是这个样子的：

import java.util.Arrays;

public class DivisionSort implements Sort {

@Override

public int[] sort(int[] arr) {

this.splitArr(arr, 0, arr.length - 1);

return arr;

}

private void splitArr(int[] arr, int start, int end) {

if (end != start) {

int mid = (end + start) / 2;

splitArr(arr, start, mid);

splitArr(arr, mid + 1, end);

mergeArr(arr, start, end);

}

}

private void mergeArr(int[] arr, int start, int end) {

int mid = (start + end) / 2;

int[] leftArr = Arrays.copyOfRange(arr, start, mid + 1);

int[] rightArr = Arrays.copyOfRange(arr, mid + 1, end + 1);

int i = 0, j = 0;

for (int k = start; k <= end; k++) {

if (i == leftArr.length) {

arr[k] = rightArr[j];

j++;

continue;

}

if (j == rightArr.length) {

arr[k] = leftArr[i];

i++;

continue;

}

if (leftArr[i] < rightArr[j]) {

arr[k] = leftArr[i];

i++;

} else {

arr[k] = rightArr[j];

j++;

}

}

}

public static void main(String[] args) {

int[] arr = new int[] { 32, 11, 22, 17, 222, 42, 162, 82, 1, 1231, 12, 2 };

Sort divisionSort = new DivisionSort();

int[] sortedArr = divisionSort.sort(arr);

System.out.println(Arrays.toString(sortedArr));

}

}

最后输出的结果为 [1, 2, 11, 12, 17, 22, 32, 42, 82, 162, 222, 1231]，排序完成。