java实现最近点对_编程之美2.11寻找最近点对Java版一

/*

* To change this license header, choose License Headers in Project Properties.

* To change this template file, choose Tools | Templates

* and open the template in the editor.

*/

package Test;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

/**

*

* 2.11寻找最近的点对

*/

public class SearchLengthMinPoints {

public static void main(String[] args) {

int[] arry = new int[]{8,3,12,18,26};

//解法一 一维 把每两个点之间的距离都求出来;二维情况一样，求两点间距离|x1-x2|^2+|y1-y2|^2再开根号

int[] num1 = searchLength1(arry);

System.out.println("距离最近的两个点:" + num1[0] + "、" + num1[1]);

//解法二 先排序，然后求两点间距离;无法扩展到二维

int[] num2 = searchLength2(arry);

System.out.println("距离最近的两个点:" + num2[0] + "、" + num2[1]);

//解法三 一维 分治思想

List list = new ArrayList();

for (int i = 0; i < arry.length; i++) {

list.add(arry[i]);

}

List num3 = searchLength3(list);

System.out.println("距离最近的两个点:" + num3.get(0) + "、" + num3.get(1) + "距离为:" + num3.get(2));

}

private static int[] searchLength1(int[] arry) {

int[] result = new int[2];

int sub = Math.abs(arry[0] - arry[1]);

for (int i = 0; i < arry.length; i++) {

for (int j = i + 1; j < arry.length; j++) {

int tmp = Math.abs(arry[i] - arry[j]);

if (sub > tmp) {

sub = tmp;

result[0] = arry[i];

result[1] = arry[j];

}

}

}

return result;

}

private static int[] searchLength2(int[] arry) {

int[] result = new int[2];

quick_sort(arry, 0, arry.length - 1);

int sub = Math.abs(arry[0] - arry[1]);

for (int i = 2; i < arry.length; i++) {

int tmp = Math.abs(arry[i - 1] - arry[i]);

if (sub > tmp) {

sub = tmp;

result[0] = arry[i - 1];

result[1] = arry[i];

}

}

return result;

}

static void quick_sort(int s[], int l, int r) {

if (l < r) {

//Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1

int i = l, j = r, x = s[l];

while (i < j) {

while (i < j && s[j] >= x) // 从右向左找第一个小于x的数

{

j--;

}

if (i < j) {

s[i++] = s[j];

}

while (i < j && s[i] < x) // 从左向右找第一个大于等于x的数

{

i++;

}

if (i < j) {

s[j--] = s[i];

}

}

s[i] = x;

quick_sort(s, l, i - 1); // 递归调用

quick_sort(s, i + 1, r);

}

}

private static List searchLength3(List list) {

List result = new ArrayList();

if (list.size() <= 2) {

if (list.size() == 2) {

result.add(list.get(1));

result.add(list.get(0));

result.add(Math.abs(list.get(0) - list.get(1)));

} else {

result.add(list.get(0));

result.add(list.get(0));

result.add(0);

}

return result;

}

int mid = list.size() / 2;

int k = list.get(mid);

List list_left = new ArrayList();

List list_right = new ArrayList();

for (int i = 0; i < list.size(); i++) {

if (list.get(i) < k) {

list_left.add(list.get(i));

} else if (list.get(i) > k) {

list_right.add(list.get(i));

}

}

if (list_left.size() > list_right.size()) {

list_right.add(k);

} else {

list_left.add(k);

}

List result_left = searchLength3(list_left);

List result_right = searchLength3(list_right);

//左边的最大值和右边的最小值的差

Collections.sort(list_left);

Collections.sort(list_right);

int sub = Math.abs( list_left.get(list_left.size()-1)- list_right.get(0));

int sub_left = result_left.get(2);

int sub_right = result_right.get(2);

if (sub_left > 0 && result_left.get(2) < sub) {

if (sub_right > 0 && sub_right < sub_left) {

result.addAll(result_right);

} else {

result.addAll(result_left);

}

} else {

if (sub_right > 0 && sub_right < sub) {

result.addAll(result_right);

} else {

result.add(list_left.get(list_left.size()-1));

result.add(list_right.get(0));

result.add(sub);

}

}

return result;

}

}

没觉得一维的分治算法有多简化啊。。。还是我的代码太复杂了