分治法（二）
参考 《算法设计与分析》 第四章 分治法 Anany Levitin著 翻译版 清华大学出版社
在上一篇文章中，介绍了分治策略的思想，主定理，以及几个用分治策略的经典案例。这一篇文章将继续探讨分治算法的其他应用，包括大整数乘法和Strassen矩阵乘法，最近点对问题和凸包问题这4个算法，一般来说常规的数据结构教程上不包括这些内容。
--------------------------------------------------------------------------------------------------------------------------------------------------
4.5 大整数乘法和Strassen矩阵乘法
两个算法都试图以增加少量的加法为代价，减少乘法运算的次数。
1）大整数乘法
书上讲述的是2个位数都为n位的数相乘，我这里扩展一下，写一个更为一般的方法，任意位数的2个数相乘：
对于任意位数的2个数相乘a * b，写成：
a = a1 * 10^(n1/2) + a0 -----n1为a的位数
b = b1 * 10^(n2/2) + b0 -----n2为b的位数
分治策略就是基于以上变换，将a，b写成前一半数字和后一半数字相加的形式，例如若a = 5423678，那么a1 = 542，a0 = 3678（注意若不是偶数截取较小一半）
这样a和b相乘就可以写为：a * b = { a1 * 10^(n1/2) + a0 } * { b1 * 10^(n2/2) + b0 }
展开后整理得： a * b = a1*b1 * 10^[ (n1+n2)/2 ] + a1*b0 * 10^(n1/2) + a0*b1 * 10^(n2/2) + a0*b0 四项
这样就很容易递归的来求a * b，如果你嫌分解后的数还太大，就可以继续分解。（你可以自己规定在何时结束递归）
实现方法：我们定义一个支持方法Mul(String s1,String s2)，用于在结束递归时（在本例中，我定义有一个数是1位时结束递归，直接用普通乘法）计算两个字符串的乘积（为了表示大数，用字符串来接受参数）。有了这个支持方法，分治递归实现两个大数乘法的实现如下：
public static long Mutiply(String a,String b)//用字符串读入2个大整数
{
long result = 0;
if(a.length() == 1 || b.length() == 1) //递归结束的条件
result = Mul(a,b);
else //如果2个字符串的长度都 >= 2
{
String a1 = a.substring(0, a.length() / 2 ); //截取前一半的字符串(较短的一半)
String a0 = a.substring(a1.length(), a.length()); //截取后一半的字符串
//System.out.println(a1);
//System.out.println(a0);
String b1 = b.substring(0, b.length() / 2);
String b0 = b.substring(b1.length(), b.length());
//分治的思想将整数写成这样： a = a1 * 10^(n1/2) + a0, b = b1 * 10^(n2/2)，相乘展开得到以下四项
//其中n1，n2为2个整数a，b的位数
result = (long) (Mutiply(a1,b1) * Math.pow(10, a0.length() + b0.length())
+ Mutiply(a1,b0) * Math.pow(10, a0.length()) + Mutiply(a0,b1) * Math.pow(10, b0.length())
+ Mutiply(a0,b0));
}
return result;
}
可以看到如果我们2个字符串都大于1位，那么我们就继续分解a和b。
完整的代码和测试的例子：
BigIntegerMutiply
package Section4;
import java.util.Arrays;
/*第4章 分治法 大整数乘法--计算2个大整数的乘积*/
public class BigIntegerMutiply {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
long a = 95211154;
long b = 9039;
String s1 = "95211154";
String s2 = "9039";
long suppose = a * b;
long result = Mutiply(s1,s2);
System.out.println(suppose + " " + result);
System.out.println(suppose == result);
}
public static long Mutiply(String a,String b)//用字符串读入2个大整数
{
long result = 0;
if(a.length() == 1 || b.length() == 1) //递归结束的条件
result = Mul(a,b);
else //如果2个字符串的长度都 >= 2
{
String a1 = a.substring(0, a.length() / 2 ); //截取前一半的字符串(较短的一半)
String a0 = a.substring(a1.length(), a.length()); //截取后一半的字符串
//System.out.println(a1);
//System.out.println(a0);
String b1 = b.substring(0, b.length() / 2);
String b0 = b.substring(b1.length(), b.length());
//分治的思想将整数写成这样： a = a1 * 10^(n1/2) + a0, b = b1 * 10^(n2/2)，相乘展开得到以下四项
//其中n1，n2为2个整数a，b的位数
result = (long) (Mutiply(a1,b1) * Math.pow(10, a0.length() + b0.length())
+ Mutiply(a1,b0) * Math.pow(10, a0.length()) + Mutiply(a0,b1) * Math.pow(10, b0.length())
+ Mutiply(a0,b0));
}
return result;
}
private static long Mul(String s1,String s2){ //计算2个字符串表示的大整数的乘积
//实际上只有当一个字符串的长度为1时，这个函数才会被调用
int[] a = new int[s1.length()]; //存放大整数s1的各位
int[] b = new int[s2.length()]; //存放大整数s2的各位
for(int i = 0;i < a.length;i++) //将字符'i'转化为整数i放入整数数组
a[i] = (int) s1.charAt(i) - 48;
for(int i = 0;i < b.length;i++)
b[i] = (int) s2.charAt(i) - 48;
long num1 = toNum(a);
long num2 = toNum(b);
return num1 * num2;
}
private static long toNum(int[] a){ //将一个整数的位数组转化为它对应的数
long result = 0;
for(int i = 0;i < a.length;i++)
result = result * 10 + a[i];
//System.out.println(result);
return result;
}
}
95211154和903923的乘积：
86063551957142 86063551957142
true
注意，写这个算法仅仅是看看分治是怎样实现的，我的测试用例也算不上是大整数，真正的大整数在普通的计算机上会溢出，计算不出来。一些研究人员的实验显示，在大于600位的整数相乘时，分治策略的性能才超过普通的算法，显然，这么大的数字在常规的计算机上无法运算。
扩展一点，大整数加法怎么做？----------大整数乘法是为了提高效率，减少乘法运算次数而设计的，这里所说的大整数加法不是效率的问题，而是计算机无法表示的问题。例如对于100位甚至1000位的数字，计算机的表示范围显然无法达到，那么应该用数组来存放大整数的每一位，对于进位，直接向前一位加一即可。
2）Strassen矩阵乘法
理论上的分析就不多写了，涉及很多数学上的东西，计算麻烦，直接上书上的图：
分治策略将2个二阶矩阵采用下列方式来计算：
其中：
数一下，这样来计算2个二阶矩阵的乘法用了7次乘法，18次加法。而蛮力法用了8次乘法和4次加法。当然，这还不能体现出它的优越性，它的优越性表现在当矩阵的阶趋于无穷大时的渐进效率。
由上面的式子，根据矩阵的相关知识，对于分块矩阵，也可以写成上述形式：
用分治策略来计算矩阵乘法的方法如下：（支持方法较多，详见完整代码）
public static int[][] StrassenMul(int[][] a,int[][] b){ //a，b均是2的乘方的方阵
int[][] result = new int[a.length][a.length];
if(a.length == 2) //如果a,b均是2阶的，递归结束条件
result = StrassMul(a,b);
else //否则（即a，b都是4,8,16...阶的）
{
//a的四个子矩阵
int[][] A00 = copyArrays(a,1);
int[][] A01 = copyArrays(a,2);
int[][] A10 = copyArrays(a,3);
int[][] A11 = copyArrays(a,4);
//b的四个子矩阵
int[][] B00 = copyArrays(b,1);
int[][] B01 = copyArrays(b,2);
int[][] B10 = copyArrays(b,3);
int[][] B11 = copyArrays(b,4);
//递归调用
int[][] m1 = StrassenMul(addArrays(A00,A11),addArrays(B00,B11));
int[][] m2 = StrassenMul(addArrays(A10,A11),B00);
int[][] m3 = StrassenMul(A00,subArrays(B01,B11));
int[][] m4 = StrassenMul(A11,subArrays(B10,B00));
int[][] m5 = StrassenMul(addArrays(A00,A01),B11);
int[][] m6 = StrassenMul(subArrays(A10,A00),addArrays(B00,B01));
int[][] m7 = StrassenMul(subArrays(A01,A11),addArrays(B10,B11));
//得到result的四个子矩阵
int[][] C00 = addArrays(m7,subArrays(addArrays(m1,m4),m5));//m1+m4-m5+m7
int[][] C01 = addArrays(m3,m5); //m3+m5
int[][] C10 = addArrays(m2,m4); //m2+m4
int[][] C11 = addArrays(m6,subArrays(addArrays(m1,m3),m2));//m1+m3-m2+m6
//也可以按照下列方法来求C
//C00 = addArrays(StrassenMul(A00,B00),StrassenMul(A01,B10));
//C01 = addArrays(StrassenMul(A00,B01),StrassenMul(A01,B11));
//C10 = addArrays(StrassenMul(A10,B00),StrassenMul(A11,B10));
//C11 = addArrays(StrassenMul(A10,B01),StrassenMul(A11,B11));
//将四个子矩阵合并成result
Merge(result,C00,1);
Merge(result,C01,2);
Merge(result,C10,3);
Merge(result,C11,4);
}
return result;
}
完整代码：
Strassen
package Section4;
/*第4章 分治法 Strassen矩阵乘法*/
public class Strassen {
//该程序可以对两个同阶的2^n阶的矩阵采用Strassen算法做矩阵乘法
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int[][] a = {
{1,0,2,1},
{4,1,1,0},
{0,1,3,0},
{5,0,2,1}
};
int[][] b = {
{0,1,0,1},
{2,1,0,4},
{2,0,1,1},
{1,3,5,0}
};
int[][] result = StrassenMul(a,b);
System.out.println("输出矩阵：");
for(int i = 0;i < result.length;i++)
{
for(int j = 0;j < result.length;j++)
System.out.print(result[i][j] + " ");
System.out.println();
}
}
public static int[][] StrassenMul(int[][] a,int[][] b){ //a，b均是2的乘方的方阵
int[][] result = new int[a.length][a.length];
if(a.length == 2) //如果a,b均是2阶的，递归结束条件
result = StrassMul(a,b);
else //否则（即a，b都是4,8,16...阶的）
{
//a的四个子矩阵
int[][] A00 = copyArrays(a,1);
int[][] A01 = copyArrays(a,2);
int[][] A10 = copyArrays(a,3);
int[][] A11 = copyArrays(a,4);
//b的四个子矩阵
int[][] B00 = copyArrays(b,1);
int[][] B01 = copyArrays(b,2);
int[][] B10 = copyArrays(b,3);
int[][] B11 = copyArrays(b,4);
//递归调用
int[][] m1 = StrassenMul(addArrays(A00,A11),addArrays(B00,B11));
int[][] m2 = StrassenMul(addArrays(A10,A11),B00);
int[][] m3 = StrassenMul(A00,subArrays(B01,B11));
int[][] m4 = StrassenMul(A11,subArrays(B10,B00));
int[][] m5 = StrassenMul(addArrays(A00,A01),B11);
int[][] m6 = StrassenMul(subArrays(A10,A00),addArrays(B00,B01));
int[][] m7 = StrassenMul(subArrays(A01,A11),addArrays(B10,B11));
//得到result的四个子矩阵
int[][] C00 = addArrays(m7,subArrays(addArrays(m1,m4),m5));//m1+m4-m5+m7
int[][] C01 = addArrays(m3,m5); //m3+m5
int[][] C10 = addArrays(m2,m4); //m2+m4
int[][] C11 = addArrays(m6,subArrays(addArrays(m1,m3),m2));//m1+m3-m2+m6
//也可以按照下列方法来求C
//C00 = addArrays(StrassenMul(A00,B00),StrassenMul(A01,B10));
//C01 = addArrays(StrassenMul(A00,B01),StrassenMul(A01,B11));
//C10 = addArrays(StrassenMul(A10,B00),StrassenMul(A11,B10));
//C11 = addArrays(StrassenMul(A10,B01),StrassenMul(A11,B11));
//将四个子矩阵合并成result
Merge(result,C00,1);
Merge(result,C01,2);
Merge(result,C10,3);
Merge(result,C11,4);
}
return result;
}
private static void Merge(int[][] result,int[][] C,int flag){
//将C复制到result的相应位置
switch(flag)
{
case 1:
for(int i = 0;i < result.length/2;i++)
for(int j = 0;j < result.length/2;j++)
result[i][j] = C[i][j];
break;
case 2:
for(int i = 0;i < result.length/2;i++)
for(int j = result.length/2;j < result.length;j++)
result[i][j] = C[i][j-result.length/2];
break;
case 3:
for(int i = result.length/2;i < result.length;i++)
for(int j = 0;j < result.length/2;j++)
result[i][j] = C[i - result.length/2][j];
break;
case 4:
for(int i = result.length/2;i < result.length;i++)
for(int j = result.length/2;j < result.length;j++)
result[i][j] = C[i - result.length/2][j-result.length/2];
break;
}
}
private static int[][] copyArrays(int[][] a,int flag){
//得到分割矩阵的子矩阵
int[][] result = new int[a.length/2][a.length/2];
switch(flag)
{
case 1:
for(int i = 0;i < a.length/2;i++)
for(int j = 0;j < a.length/2;j++)
result[i][j] = a[i][j];
break;
case 2:
for(int i = 0;i < a.length/2;i++)
for(int j = a.length/2;j < a.length;j++)
result[i][j-a.length/2] = a[i][j];
break;
case 3:
for(int i = a.length/2;i < a.length;i++)
for(int j = 0;j < a.length/2;j++)
result[i - a.length/2][j] = a[i][j];
break;
case 4:
for(int i = a.length/2;i < a.length;i++)
for(int j = a.length/2;j < a.length;j++)
result[i-a.length/2][j-a.length/2] = a[i][j];
break;
}
return result;
}
private static int[][] StrassMul(int[][] a,int[][] b){
//计算2个二阶的矩阵乘法
//Strassen方法使用了7次乘法，18次加法（传统方法是8次乘法4次加法）
int[][] result = new int[2][2];
int m1 = (a[0][0] + a[1][1]) * (b[0][0] + b[1][1]);
int m2 = (a[1][0] + a[1][1]) * b[0][0];
int m3 = a[0][0] * (b[0][1] - b[1][1]);
int m4 = a[1][1] * (b[1][0] - b[0][0]);
int m5 = (a[0][0] + a[0][1]) * b[1][1];
int m6 = (a[1][0] - a[0][0]) * (b[0][0] + b[0][1]);
int m7 = (a[0][1] - a[1][1]) * (b[1][0] + b[1][1]);
result[0][0] = m1 + m4 - m5 + m7;
result[0][1] = m3 + m5;
result[1][0] = m2 + m4;
result[1][1] = m1 + m3 - m2 + m6;
return result;
}
private static int[][] addArrays(int[][] a,int[][] b){
//求2个同阶矩阵的和
int[][] result = new int[a.length][a.length];
//System.out.println(result.length);
for(int i = 0;i < result.length;i++)
for(int j = 0;j < result.length;j++)
//for(int j = 0;i < result.length;j++)
result[i][j] = a[i][j] + b[i][j];
return result;
}
private static int[][] subArrays(int[][] a,int[][] b){
//矩阵减法
int[][] result = new int[a.length][a.length];
for(int i = 0;i < result.length;i++)
for(int j = 0;j < result.length;j++)
//for(int j = 0;i < result.length;j++)
result[i][j] = a[i][j] - b[i][j];
return result;
}
}
对给出的2个矩阵，乘积输出如下：
输出矩阵：
5 4 7 3
4 5 1 9
8 1 3 7
5 8 7 7
当然，矩阵的阶较大时才能体现出它的优势。
提示：其实二阶的时候结束递归直接蛮力就行了，而且你可以在四阶的时候就结束递归也行，取决于你的实现
--------------------------------------------------------------------------------------------------------------------------------------------------
4.6 用分治法解最近点对问题和凸包问题
问题描述在蛮力法里都介绍过，不再介绍了。
1）最近点对问题
在蛮力法里写了一个2重循环的蛮力算法，时间复杂度是n^2。
a，预排序！
b，在预排序基础上，将点递归的分为左右一半。
实现方式：按照x坐标升序对所求点集进行升序排序。然后递归的将点集分为左右一半，在点集中仅剩2或3个点时用蛮力法结束递归。
注意分治的策略：
划分子问题：每次将问题规模递归的划分为2个一半
合并子问题的解：分别求的2个一半中距离最近的2个点，假设在左一半是点A，点B，右边是点C，点D。再取其距离更小的2个作为暂时的最小值。注意此时AB或CD还不是最终要求的2个点，最小值可能还来自于一个点在左子集中一个点在右子集中。（位于左右子集分割边界上的2个点，一个在左子集中，一个在由子集中）
主方法如下：该方法接受一个点数组，返回其中距离最近的2个点。
public static Point[] getNearestPoints(Point[] Points) {
//从一个点数组里面找到最近的两个点，并返回这两个点
Point[] result = new Point[2];
if (Points.length == 3 || Points.length == 2) //递归结束的条件
result = getNear(Points);
else //多于3个点，分治，分别找出两个子集合的最近点对，然后合并结果
{
Point[] left = Arrays.copyOfRange(Points, 0, Points.length / 2);//最后一个下标不包括
Point[] right = Arrays.copyOfRange(Points, Points.length / 2,
Points.length);
//得到2个子集里面分别最短距离的2个点
Point[] result1 = getNearestPoints(left);
Point[] result2 = getNearestPoints(right);
double d1 = dPoints(result1[0], result1[1]);
double d2 = dPoints(result2[0], result2[1]);
//忘了将result赋值
if (d1 <= d2)
result = result1;
else
result = result2;
//合并结果：找到全局距离最短的两个点
double dmin = Math.min(d1, d2);
int x1 = left.length - 1;//两个x的分界点
int x2 = x1 + 1;
//在Points.length/2是一个整数时是错误的
//int x1 = Points[Points.length/2 - 1].x;//两个x的分界点
//int x2 = Points[Points.length/2].x;
for (int i = x1; i >= 0; i--) {
//if(x2 - Points[i].x > dmin) //直接导致调试很久都不知道错在哪！！！！！！
if (Points[x2].x - Points[i].x > dmin)
break;
else
//for(int j = Points.length/2;j < Points.length;j++)
for (int j = x2; j < Points.length; j++) {
//System.out.println(Points[j].y);
//if(Points[j].x - x1 > dmin)
if (Points[j].x - Points[x1].x > dmin)
break;
else {
double temp = dPoints(Points[i], Points[j]);
//System.out.println(temp);
if (temp < dmin) {
dmin = temp;
result[0] = Points[i];
result[1] = Points[j];
}
}
}
}
}
return result;
}
注意要得到左右边界的值，然后从左右边界处往两边扩展，看看有没有更小的值。一开始再这个地方犯了错误，见注释。
其他支持方法见完整代码：
NearestPoint
package Section4;
import java.util.Arrays;
/*第4章 分治法 寻找最近点对*/
public class NearestPoint {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Point[] Points = new Point[10];
Points[0] = new Point(3, 4);
Points[1] = new Point(2, 5);
Points[2] = new Point(3, 8);
Points[3] = new Point(13, 9);
Points[4] = new Point(7, 8);
Points[5] = new Point(7, 12);
Points[6] = new Point(90, 0);
Points[7] = new Point(5, 8);
Points[8] = new Point(7, 9);
Points[9] = new Point(3, 6);
//Points[10] = new Point(3,41);
Arrays.sort(Points);//按照x坐标升序对点预排序,n*log(n)的复杂度---Arrays提供的静态排序方法
Point[] result = new Point[2];
result = getNearestPoints(Points);
System.out.println("输出距离最近的两个点是： ");
//System.out.println(result[0].x);
for (int i = 0; i < result.length; i++)
System.out.print("(" + result[i].x + "," + result[i].y + ") ");
}
public static Point[] getNearestPoints(Point[] Points) {
//从一个点数组里面找到最近的两个点，并返回这两个点
Point[] result = new Point[2];
if (Points.length == 3 || Points.length == 2) //递归结束的条件
result = getNear(Points);
else //多于3个点，分治，分别找出两个子集合的最近点对，然后合并结果
{
Point[] left = Arrays.copyOfRange(Points, 0, Points.length / 2);//最后一个下标不包括
Point[] right = Arrays.copyOfRange(Points, Points.length / 2,
Points.length);
//得到2个子集里面分别最短距离的2个点
Point[] result1 = getNearestPoints(left);
Point[] result2 = getNearestPoints(right);
double d1 = dPoints(result1[0], result1[1]);
double d2 = dPoints(result2[0], result2[1]);
//忘了将result赋值
if (d1 <= d2)
result = result1;
else
result = result2;
//合并结果：找到全局距离最短的两个点
double dmin = Math.min(d1, d2);
int x1 = left.length - 1;//两个x的分界点
int x2 = x1 + 1;
//在Points.length/2是一个整数时是错误的
//int x1 = Points[Points.length/2 - 1].x;//两个x的分界点
//int x2 = Points[Points.length/2].x;
for (int i = x1; i >= 0; i--) {
//if(x2 - Points[i].x > dmin) //直接导致调试很久都不知道错在哪！！！！！！
if (Points[x2].x - Points[i].x > dmin)
break;
else
//for(int j = Points.length/2;j < Points.length;j++)
for (int j = x2; j < Points.length; j++) {
//System.out.println(Points[j].y);
//if(Points[j].x - x1 > dmin)
if (Points[j].x - Points[x1].x > dmin)
break;
else {
double temp = dPoints(Points[i], Points[j]);
//System.out.println(temp);
if (temp < dmin) {
dmin = temp;
result[0] = Points[i];
result[1] = Points[j];
}
}
}
}
}
return result;
}
private static Point[] getNear(Point[] Points) {
//返回仅有2个点或者三个点的点数组中距离最小的两个点
Point[] result = new Point[2];
if (Points.length == 2)
result = Points;
else //有3个点,枚举求距离最短的两个点
{
double d1 = dPoints(Points[0], Points[1]);
double d2 = dPoints(Points[0], Points[2]);
double d3 = dPoints(Points[1], Points[2]);
if (d1 <= d2 && d1 <= d3) {
result[0] = Points[0];
result[1] = Points[1];
} else if (d2 <= d3) {
result[0] = Points[0];
result[1] = Points[2];
} else {
result[0] = Points[1];
result[1] = Points[2];
}
}
return result;
}
private static double dPoints(Point a, Point b) {
//求两个点之间的距离
return Math.pow(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2), 0.5);
}
}
class Point implements Comparable { //二维的点
public int x;
public int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public int compareTo(Object o) {
// TODO Auto-generated method stub
Point obj = (Point) o;
if (this.x < obj.x)
return -1;
else if (this.x > obj.x)
return 1;
return 0;
}
}
输出距离最近的两个点是：
(7,8) (7,9)
这个算法递归的关系式为：
根据主定理，时间复杂度为n * log（n），注意这仅仅是对于划分和合并子问题的解的递推式。还有一个预排序，由于预排序时间复杂也是n * log（n），故它不影响整体的复杂度。
提示：这个例子告诉我们，有时候合并子问题的解并不仅仅是简单的把子问题的解合并起来，它需要一些进一步的处理。最终的解可能并不在子问题的解中，但它来自于对子问题的解进一步的处理结果。
2）凸包问题
描述比较复杂，简单说下，先预排序，预排序后最左和最右的点肯定是凸包中的点。然后可以递归的从内向外扩展凸包，在当前直线的2侧寻找最高点，最高点肯定在凸包中，这里涉及到一些数学知识：
a，首先定义射线p1到p2的左侧：若p1 p2 p构成的顺序是逆时针，称p在射线的左侧
b，三角形p1 p2 p3的面积等于下列行列式的一半：
仅当p3在射线p1p2左侧时这个值才为正。
由此我们很容易求p1，p2左侧的最高点（离直线最远的点，这个点即凸包向外扩展得到的新顶点），得到一个最高点后，就得到了2条新边，继续向外扩展，如图：
注意我只定义了左侧，其实左右都一样，你把射线方向换一下，处理右侧不就等于处理左侧了吗，免得搞得那么麻烦。详见代码：
package Section4;
/*第4章 分治法 凸包问题的分治解法*/
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Stack;
public class ConvexHull {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Point[] Points = new Point[15];
Points[0] = new Point(-5, 7);
Points[1] = new Point(3,-6);
Points[2] = new Point(5, 4);
Points[3] = new Point(-5, -5);
Points[4] = new Point(1, 7);
Points[5] = new Point(6, 0);
Points[6] = new Point(0, 0);
Points[7] = new Point(-5, 0);
Points[8] = new Point(3, -2);
Points[9] = new Point(3, 4);
Points[10] = new Point(1, 6);
Points[11] = new Point(5, 3);
Points[12] = new Point(-4, -5);
Points[13] = new Point(-3, 6);
Points[14] = new Point(2, 5);
Arrays.sort(Points); //预排序处理
LinkedList<Point> list = new LinkedList<Point> ();
for(int i = 0;i < Points.length;i++)
list.add(Points[i]); //list存放全部的顶点
LinkedList<Point> result = getConvexHulls(list); //result用来存放最终的结果顶点
System.out.println("一共有 " + result.size() + " 个顶点, " + "凸包的顶点是： ");
Iterator it = result.iterator();
while(it.hasNext())
{
Point next = (Point) it.next();
System.out.print("(" + next.x + "," + next.y + ")" + " " );
}
}
public static LinkedList<Point> getConvexHulls(LinkedList<Point> list){
//将凸包顶点以result链表返回
LinkedList<Point> result = new LinkedList<Point>();
Point temp1 = list.removeFirst();
Point temp2 = list.removeLast();
result.add(temp1);
result.add(temp2);
//递归的处理temp1 ---> temp2左右两侧的点
dealWithLeft(temp1,temp2,result,list);
dealWithLeft(temp2,temp1,result,list);//注意每次要将result带着，存放结果集
return result;
}
private static void dealWithLeft(Point p1,Point p2,LinkedList result,LinkedList list){
//递归的处理p1，p2构成的射线左边的点
Iterator it = list.iterator();
//找出左边最高的点Pmax
Point Pmax = null;
int max = 0;
while(it.hasNext())
{
Point next = (Point) it.next();
int x1 = p1.x,y1 = p1.y;
int x2 = p2.x,y2 = p2.y;
int x3 = next.x,y3 = next.y;
//int max = 0;//小小的一个错误啊！！！！！！！
int compute = x1*y2 + x3*y1 + x2*y3 - x3*y2 - x2*y1 - x1*y3;
if(compute > max)
{
max = compute;
Pmax = next;
}
}
//又找到了一个顶点
if(Pmax != null)
{
result.add(Pmax);
list.remove(Pmax);
//递归
dealWithLeft(p1,Pmax,result,list);
dealWithLeft(Pmax,p2,result,list);
}
}
private static boolean onLeft(Point target,Point p1,Point p2){
//判断target是否在p1--->p2射线的左侧
int x1 = p1.x,y1 = p1.y;
int x2 = p2.x,y2 = p2.y;
int x3 = target.x,y3 = target.y;
int compute = x1*y2 + x3*y1 + x2*y3 - x3*y2 - x2*y1 - x1*y3;
if(compute > 0)
return true;
else
return false;
}
}
以上测试的14个点是精心构造的包含了各种特殊情况的14个点（包括有3点共线，有点的横坐标相等，等等），运行结果如下，有兴趣的可以在坐标系里画一下。
一共有 6 个顶点, 凸包的顶点是：
(-5,7) (6,0) (1,7) (5,4) (-5,-5) (3,-6)
提示：这个代码写的不好，其实每次判断一侧后，就可以将另一侧的点排除掉，这里还没有这样去做。
--------------------------------------------------------------------------------------------------------------------------------------------------
总结：
分治的策略
怎么划分子问题
怎么用递归
规模小的时候结束递归
怎么合并结果
