二、分治算法

在算法设计中，常常引入分而治之的策略，称之为分治算法，其本质就是 将一个大规模的问题分解为若干规模较小的相同子问题，分而治之。

一、分治算法秘籍

1、条件：

1. 原问题可被分解为若干规模较小的相同子问题；
2. 子问题相互独立；
3. 子问题的解可以合并为原问题的解。

2、求解秘籍：

1. 分解：将原问题分解为若干规模较小、相互独立且与原问题形式相同的子问题。
2. 治理；求解各个子问题。由于各个子问题与原问题形式相同，只是规模较小，所以当 子问题划分得足够小时，就可以用较简单的方法解决。

3. 合并：按原问题的要求，将子问题的解逐层合并成原问题的解。

分治算法是将一个难以直接解决的大问题分割成一些规模较小的相同问题， 以便各个击破、分而治之。所以，递归是彰显分治算法优势的利器。

二、合并排序

 

package 贪心算法;

import java.util.Arrays;

public class 合并排序 {
	 public static void main(String[] args) {
	        int original[] = new int[] { 6, 10, 25, 3, 33, 90, 60, 100, 56 };
	        mergeSort(original);
	        print(original);
	    }

	    private static void mergeSort(int[] original) {
	        int length = original.length;
	        if (length > 1) {
	            int middle = length / 2;
	            int partitionA[] = Arrays.copyOfRange(original, 0, middle);// 拆分问题规模
	            int partitionB[] = Arrays.copyOfRange(original, middle, length);
	            // 递归调用
	            mergeSort(partitionA);
	            mergeSort(partitionB);
	            sort(partitionA, partitionB, original);
	        }
	    }

	    private static void sort(int[] partitionA, int[] partitionB, int[] original) {
	        int i = 0;
	        int j = 0;
	        int k = 0;
	        while (i < partitionA.length && j < partitionB.length) {
	            if (partitionA[i] <= partitionB[j]) {
	                original[k] = partitionA[i];
	                i++;
	            } else {
	                original[k] = partitionB[j];
	                j++;
	            }
	            k++;
	        }
	        if (i == partitionA.length) {
	            while (k < original.length) {
	                original[k] = partitionB[j];
	                k++;
	                j++;
	            }
	        } else if (j == partitionB.length) {
	            while (k < original.length) {
	                original[k] = partitionA[i];
	                k++;
	                i++;
	            }
	        }
	    }

	    private static void print(int[] array) {
	        if (array == null) {
	            throw new NullPointerException("The array can not be null !!!");
	        }
	        StringBuilder sb = new StringBuilder("[");
	        for (int element : array) {
	            sb.append(element + ", ");
	        }
	        sb.replace(sb.length() - 2, sb.length(), "]");
	        System.out.println(sb.toString());
	    }
	}
	

 三、快速排序

 

package 分治算法;

public class 快速排序 {

	public static void quickSort(int[] arr,int low,int high){
        int i,j,temp,t;
        if(low>high){
            return;
        }
        i=low;
        j=high;
        //temp就是基准位
        temp = arr[low];
 
        while (i<j) {
            //先看右边，依次往左递减
            while (temp<=arr[j]&&i<j) {
                j--;
            }
            //再看左边，依次往右递增
            while (temp>=arr[i]&&i<j) {
                i++;
            }
            //如果满足条件则交换
            if (i<j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }
 
        }
        //最后将基准为与i和j相等位置的数字交换
         arr[low] = arr[i];
         arr[i] = temp;
        //递归调用左半数组
        quickSort(arr, low, j-1);
        //递归调用右半数组
        quickSort(arr, j+1, high);
    }
 
 
    public static void main(String[] args){
        int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
        quickSort(arr, 0, arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}