I used two arrays. Original array should not be altered is the condition which i need to stick to. On the otherhand, I have to sort, get values in key-value pair in copied array. Once all values updated in copied array, I need to again copy back the values to original array. I have written the below code. I just wanted to confirm is this the correct approach and any other (optimal way) coding construct which I can follow so that original array indexes not getting changed.

Reason for sorting dup array:
In order to get values, the keys to be sorted based on index used in each key(internal condition).

 typedef struct
{
    char *key;
    char *value;
} kv_pair_t;

typedef struct
{
    kv_pair_t *vector;
    int num_entries;
} kv_vector_t;


char parameters[9][30] = {
    "STA.1.MacAddress",
    "STA.2.MacAddress",
    "STA.3.MacAddress",
    "STA.1.IPv4Address",
    "STA.2.IPv4Address",
    "STA.3.IPv4Address",
    "STA.1.IPv6Address",
    "STA.2.IPv6Address",
    "STA.3.IPv6Address",
};

char values[9][20] = {
    "192.168.18.1",
    "2000::A1B1",
    "AA:BB:CC:01:01:01",
    "192.168.18.2",
    "2000::A2B2",
    "AA:BB:CC:02:02:02",
    "192.168.18.3",
    "2000::A3B3",
    "AA:BB:CC:03:03:03",
};

int compare(const void *p1, const void *p2)
{
    kv_pair_t *pair1 = (kv_pair_t *)p1;
    kv_pair_t *pair2 = (kv_pair_t *)p2;
    return strcmp(pair1->key, pair2->key);
}

void frame_kv_params(kv_vector_t **params, int num_entries, int param_size)
{
    kv_vector_t *kv = NULL;
    int idx = 0;

    kv = malloc(sizeof(kv_vector_t));
    kv->num_entries = num_entries;
    kv->vector = malloc(sizeof(kv_pair_t) * num_entries);

    for(idx = 0; idx < num_entries; idx++) {
        memset(&kv->vector[idx], 0, sizeof(kv_pair_t));
        kv->vector[idx].key = calloc(1, param_size);
        strncpy(kv->vector[idx].key, parameters[idx], param_size-1);
    }

    //Update
    *params = kv;
}

void update_kv_params(kv_vector_t *kv)
{
    int idx = 0;
    kv_pair_t *pair = NULL;
    for (idx = 0; idx < kv->num_entries; idx++) {
        pair = &kv->vector[idx];
        pair->value = strdup(values[idx]);
    }
}

void print_kv_params(kv_vector_t *params)
{
    int idx = 0;
    kv_pair_t *pair = NULL;

    printf("%s(%d), num entries : %dn", __FUNCTION__, __LINE__, params->num_entries);
    for(idx = 0; idx < params->num_entries; idx++) {
        pair = &params->vector[idx];
        printf("key : %s, value[%p] : %sn", pair->key, pair->value, pair->value);
    }
}

int main()
{
    int idx = 0;
    int param_size = 30;
    int nmembs = sizeof(parameters)/sizeof(parameters[0]);
    kv_vector_t *params = NULL;
    kv_vector_t dup_params;

    // Fram kv vector
    frame_kv_params(&params, nmembs, param_size);

    // Print kv vector
    printf("nOriginal params without values updatedn");
    print_kv_params(params);

    // Get a copy of params kv vector
    memset(&dup_params, 0, sizeof(kv_vector_t));

    dup_params.vector = malloc(nmembs* sizeof(kv_pair_t));
    memset(dup_params.vector, 0, nmembs* sizeof(kv_pair_t));

    memcpy(dup_params.vector, params->vector, nmembs* sizeof(kv_pair_t));
    dup_params.num_entries = params->num_entries;
    printf("params->vector:%p, dup_params.vector:%pn", params->vector, dup_params.vector);

    // Do sort dup_params
    qsort(dup_params.vector, dup_params.num_entries, sizeof(kv_pair_t), compare);

    //printf("nAfter Sorting dup paramsn");
    //print_kv_params(&dup_params);

    //update values locally in duplicated sorted array
    printf("nAfter updating sorted dup paramsn");
    update_kv_params(&dup_params);
    print_kv_params(&dup_params);

    // Assign values back to original
    int i, j = 0;
    int max_entries = params->num_entries;
    kv_pair_t *pair1, *pair2 = NULL;

    for (i=0; i< max_entries; i++) {
        for (j=0; j< max_entries; j++) {
            pair1 = &params->vector[i];
            pair2 = &dup_params.vector[j];
            if (strcmp(pair1->key, pair2->key) == 0) {
                //printf("Original Key[%d]: %s, dup key[%d]: %sn", i, pair1->key, j, pair2->key);
                //printf("Original Key[%d]: %p, dup key[%d]: %pn", i, pair1->key, j, pair2->key);
                pair1->value = strdup(pair2->value);
                printf("Original value[%d]: %p, dup value[%d]: %pn", i, pair1->value, j, pair2->value);
                free(pair2->value);
            }
        }
    }

    //Free dup_params
    free(dup_params.vector);

    // Print original kv vector finally
    printf("nOriginal paramsn");
    print_kv_params(params);

}