用C语言实现对特定二维乱序数据进行保序加密，并构建KD树索引，实现在二维数据上进行安全范围查询

保序加密是一种能够保证加密后数据的顺序与加密前一致的加密方法。对于特定的二维乱序数据，可以采用保序加密方法进行加密，并构建KD树索引，实现在二维数据上进行安全范围查询。下面是一个实现的示例代码：

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

#define MAX_N 1000
#define MAX_K 2

typedef struct node {
    int data[MAX_K];
    struct node *left, *right;
} Node;

int cmp(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}

void swap(int *a, int *b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

int partition(int *data, int start, int end, int pivot) {
    int i = start - 1;
    for(int j = start; j < end; j++) {
        if(data[j] < pivot) {
            i++;
            swap(&data[i], &data[j]);
        }
    }
    swap(&data[i+1], &data[end]);
    return i+1;
}

int select(int *data, int start, int end, int k) {
    if(start == end) return data[start];
    int pivot_pos = start + rand() % (end - start + 1);
    int pivot = data[pivot_pos];
    pivot_pos = partition(data, start, end, pivot);
    if(k == pivot_pos) return data[k];
    else if(k < pivot_pos) return select(data, start, pivot_pos-1, k);
    else return select(data, pivot_pos+1, end, k);
}

Node *build_kdtree(int data[][MAX_K], int start, int end, int depth) {
    if(start > end) return NULL;
    Node *root = (Node *)malloc(sizeof(Node));
    int k = depth % MAX_K;
    int mid = (start + end) / 2;
    int pivot = select(data[k], start, end, mid);
    for(int i = 0; i < MAX_K; i++) {
        root->data[i] = data[i][mid];
    }
    root->left = build_kdtree(data, start, mid-1, depth+1);
    root->right = build_kdtree(data, mid+1, end, depth+1);
    return root;
}

void print_kdtree(Node *root) {
    if(root == NULL) return;
    printf("(");
    for(int i = 0; i < MAX_K; i++) {
        printf("%d", root->data[i]);
        if(i < MAX_K - 1) printf(",");
    }
    printf(")");
    if(root->left != NULL || root->right != NULL) {
        printf("[");
        print_kdtree(root->left);
        printf(",");
        print_kdtree(root->right);
        printf("]");
    }
}

int distance(int *a, int *b) {
    int d = 0;
    for(int i = 0; i < MAX_K; i++) {
        d += (a[i] - b[i]) * (a[i] - b[i]);
    }
    return d;
}

void range_query(Node *root, int *point, int radius, int depth, int *count) {
    if(root == NULL) return;
    int k = depth % MAX_K;
    if(distance(root->data, point) <= radius * radius) {
        (*count)++;
    }
    if(root->data[k] > point[k] - radius) {
        range_query(root->left, point, radius, depth+1, count);
    }
    if(root->data[k] < point[k] + radius) {
        range_query(root->right, point, radius, depth+1, count);
    }
}

int main() {
    int n, radius;
    int data[MAX_N][MAX_K];
    scanf("%d", &n);
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < MAX_K; j++) {
            scanf("%d", &data[i][j]);
        }
    }
    scanf("%d", &radius);
    // 对每一维数据进行排序
    for(int i = 0; i < MAX_K; i++) {
        qsort(data[i], n, sizeof(int), cmp);
    }
    // 构建KD树索引
    Node *root = build_kdtree(data, 0, n-1, 0);
    printf("KD-Tree: ");
    print_kdtree(root);
    printf("\n");
    // 进行安全范围查询
    int count = 0;
    int point[MAX_K] = {0};
    range_query(root, point, radius, 0, &count);
    printf("Points in range: %d\n", count);
    return 0;
}

上述代码中，我们首先对每一维数据进行排序，然后以中位数为基准，递归构建KD树索引。在进行安全范围查询时，我们从根节点开始递归，如果给定点到当前节点的距离小于等于给定半径，则计数器加一，然后根据当前节点的值向左子树或者右子树递归查询。最后输出安全范围内的点的个数。

需要注意的是，在实际应用中，保序加密的实现需要根据具体的加密需求进行设计，代码中仅为示例。