最近对问题-蛮力法、分治法

蛮力法：

int ClosestPoints(point p[], int n){
    int index1, index2; //记录下标
    int d, minDist = 1000; //设最大距离
    int i, j;
    for(i = 0; i < n - 1; i++ ){
        for(j = i+1; j < n; j++){
            d = (p[i].x - p[j].x)*(p[i].x - p[j].x) + (p[i].y - p[j].y) * (p[i].y - p[j].y);
            if( d < minDist){
                minDist = d;
                index1 = i;
                index2 = j;
            }
        }
    }
    printf("最近的点对是：第 %d 个点和第 %d 个点", index1 + 1, index2 + 1);

    return minDist;
}

分治法：

int ClosestPoints_1(point p[], int low, int high){
    int d1, d2, d3, d;
    point p1[N]; // 存放2d宽度内的点
    int mid, i, j, index;


    if(high - low == 1){ //两个点时

        return Distance(p[low], p[high]);
    }
    if(high - low  == 2) //三个点时
    {

        d1 = Distance(p[low], p[low + 1]);
        d2 = Distance(p[low + 1], p[high]);
        d3 = Distance(p[low], p[high]);

        if((d1 > d2) && (d3 > d2))
            return d2;
        else if((d1 > d3) && (d2 > d3))
            return d3;
        else
            return d1;
    }
    mid = (low + high) / 2;

    d1 = ClosestPoints_1(p, low, mid);
    d2 = ClosestPoints_1(p, mid + 1, high);

    if(d1 <= d2)
        d = d1;
    else
        d = d2;

    index = 0;


    for(i = mid; (i >= low) && (p[mid].x - p[i].x < d); i--){
        p1[index++] = p[i];
    }

    for(i = mid + 1; (i <= high) && (p[i].x - p[mid].x < d); i++){
        p1[index++] = p[i];
    }

    QuickSort_y(p1, 0, index-1);


    for(i = 0; i <index; i++){
        for(j = i+1;j < index; j++){
            if(p1[j].y - p1[i].y >= d)
                break;
            else
            {

                d3 = Distance(p1[i], p1[j]);

                if(d3 < d){
                    d = d3;


                }
            }
        }
    }


    return d;

}

排序（快速排序）：

int Partition_x(point p[], int first