陣列重排序演算法-有解無憂

我需要取出帶有索引的元素，i然后重新排序陣列。例如，如果我1 2 3 4在陣列中有并取出3，我需要在1 2 4最后得到 NULL 元素。

我需要采取的要素：

INVENTORY_AMOUNT_ARRAY[i];
INVENTORY_PRICES_ARRAY[i];
INVENTORY_NAMES_ARRAY[i];

我的陣列定義：

static intmax_t INVENTORY_AMOUNT_ARRAY[MAX_SIZE_OF_ARRAYS];
static intmax_t INVENTORY_PRICES_ARRAY[MAX_SIZE_OF_ARRAYS];
static char     INVENTORY_NAMES_ARRAY[MAX_SIZE_OF_ARRAYS][MAX_SIZE_OF_ARRAYS];

我的功能：

void cache_remove_product() {
    int i = 0;
    for (; (strlen(INVENTORY_NAMES_ARRAY[i])) != 0; i  ){}
    printf("Enter the product's name u want to remove:");
    char temp_string_for_prname[MAX_SIZE_OF_STRINGS];
    scanf("%s", &temp_string_for_prname);
    for (int i = 0; (strlen(INVENTORY_NAMES_ARRAY[i])) != 0; i  ) {
        if ((strcmp(temp_string_for_prname, INVENTORY_NAMES_ARRAY[i])) == 0) {
            memset(INVENTORY_NAMES_ARRAY[i], 0, sizeof(INVENTORY_NAMES_ARRAY[i]));
            INVENTORY_PRICES_ARRAY[i] = 0;
            INVENTORY_AMOUNT_ARRAY[i] = 0;
            int j = 0;
            for (;;) {
            }       
        }
    }
}

我需要將演算法放在空白處for

uj5u.com熱心網友回復：

代碼中有多個問題：

第一個回圈沒用，只需將其洗掉
您必須告訴scanf()要存盤到目標陣列中的最大字符數，以避免在無效輸入上出現未定義的行為。沒有簡單的方法可以做到這一點scanf()，因為陣列的長度不是顯式常量。我建議使用fgets()這種方式：
```
char prname[MAX_SIZE_OF_STRINGS   1];
if (!fgets(prname, sizeof prname, stdin))
    return;
size_t len = strlen(prname);
if (len > 0 && prname[len - 1] == '\n')
    prname[--len] = '\0';
if (len == 0)
    return;
```

陣列結尾的測驗可以簡化為

for (int i = 0; INVENTORY_NAMES_ARRAY[i][0] != '\0'; i  ) {

要從所有陣列中洗掉匹配的條目，您必須將以下每個條目復制到前一個位置并清除最后一個條目。

請注意，不需要重新排序陣列，因為通過將所有后續元素移動一個位置來移除元素不會改變剩余元素的相對順序。

這是修改后的版本：

#include <stdio.h>

static intmax_t INVENTORY_AMOUNT_ARRAY[MAX_SIZE_OF_ARRAYS];
static intmax_t INVENTORY_PRICES_ARRAY[MAX_SIZE_OF_ARRAYS];
static char     INVENTORY_NAMES_ARRAY[MAX_SIZE_OF_ARRAYS][MAX_SIZE_OF_ARRAYS];

void cache_remove_product(void) {
    int i, j;
    printf("Enter the product's name u want to remove:");
    char prname[MAX_SIZE_OF_STRINGS   1];
    if (!fgets(prname, sizeof prname, stdin))
        return;
    size_t len = strlen(prname);
    if (len > 0 && prname[len - 1] == '\n')
        prname[--len] = '\0';
    if (len == 0)
        return;
    // remove all matching entries
    for (i = 0; INVENTORY_NAMES_ARRAY[i][0] != '\0';) {
        if (strcmp(prname, INVENTORY_NAMES_ARRAY[i]) == 0) {
            // move subsequent entries
            for (j = i; j < MAX_SIZE_OF_ARRAYS - 1; j  ) {
                strcpy(INVENTORY_NAMES_ARRAY[j], INVENTORY_NAMES_ARRAY[j   1]);
                INVENTORY_PRICES_ARRAY[j] = INVENTORY_PRICES_ARRAY[j   1];
                INVENTORY_NAMES_ARRAY[j] = INVENTORY_NAMES_ARRAY[j   1];
                if (INVENTORY_NAMES_ARRAY[j][0] == '\0')
                    break;
            }
            INVENTORY_NAMES_ARRAY[j][0] = '\0';
        } else {
            i  ;
        }
    }
}

uj5u.com熱心網友回復：

您可以嘗試將所選專案一一交換到陣列的末尾，然后使其為空。

例如：你已經給{1, 2, 3, 4, 5, 6, 7}你想要洗掉3你在 3 到 7 之間進行交換操作，比如：
step 0 {1, 2, 3, 4, 5, 6, 7}
step 1 {1, 2, 4, 3, 5, 6, 7}
step 2 {1, 2, 4, 5, 3, 6, 7}
step 3 {1, 2, 4, 5, 6, 3, 7}
step 4 {1, 2, 4, 5, 6, 7, 3}
之后你可以分配陣列的最后一個索引為空。
array[lengthOfArray - 1] = NULL;
我們可以只交換最后一個元素和選擇的元素，但如果我們這樣做，我們的陣列將不再被排序。

uj5u.com熱心網友回復：

假設您要像這樣洗掉所有陣列。一個在陣列中向前移動，并在每個資料處測驗是否應該洗掉它：是的。它將每次將所有陣列移回一個位置。n洗掉物件的運行時間n(n 1)/2是O(n^2).

我們可以通過一個惰性洗掉操作來做得更好，該操作會記住該位置但在絕對必須洗掉之前不會洗掉。這一次運行O(n)。

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>

struct inventory {
    char name[128];
    uint64_t amount;
    uint32_t cent_price;
};
static const size_t max_size_of_strings = sizeof ((struct inventory *)0)->name;
struct database {
    struct inventory data[32];
    size_t size;
} db;
static const size_t max_size_of_arrays = sizeof db.data / sizeof *db.data;

typedef int (*predicate_fn)(const struct inventory *, const void *);

static void keep_if(const predicate_fn keep, const void *const param) {
    struct inventory *erase = 0, *i, *retain = 0, *end;
    int keep0 = 1, keep1 = 0;
    assert(keep);
    for(i = db.data, end = i   db.size; i < end; keep0 = keep1, i  ) {
        keep1 = !!keep(i, param);
        if(!(keep0 ^ keep1)) continue; /* Not a falling/rising edge. */
        if(keep1) { /* Rising edge. */
            assert(erase && !retain);
            retain = i;
        } else if(erase) { /* Falling edge. */
            size_t n = (size_t)(i - retain);
            assert(erase < retain && retain < i);
            memmove(erase, retain, sizeof *i * n);
            erase  = n;
            retain = 0;
        } else { /* Falling edge, (first time only.) */
            erase = i;
        }
    }
    if(!erase) return; /* All elements were kept. */
    if(keep1) { /* Delayed move when the iteration ended; repeat. */
        size_t n = (size_t)(i - retain);
        assert(retain && erase < retain && retain < i);
        memmove(erase, retain, sizeof *i * n);
        erase  = n;
    }
    /* Adjust the size. */
    assert((size_t)(erase - db.data) <= db.size);
    db.size = (size_t)(erase - db.data);
}

static int strcmp_name(const struct inventory *item, const void *const vname) {
    const char *const name = vname;
    return strcmp(name, item->name);
}

int main(void) {
    size_t i;
    strcpy(db.data[0].name, "A"); db.data[0].amount = 0;
    strcpy(db.data[1].name, "B"); db.data[1].amount = 1;
    strcpy(db.data[2].name, "A"); db.data[2].amount = 2;
    strcpy(db.data[3].name, "B"); db.data[3].amount = 3;
    strcpy(db.data[4].name, "A"); db.data[4].amount = 4;
    strcpy(db.data[5].name, "B"); db.data[5].amount = 5;
    strcpy(db.data[6].name, "C"); db.data[6].amount = 6;
    strcpy(db.data[7].name, "B"); db.data[7].amount = 7;
    strcpy(db.data[8].name, "B"); db.data[8].amount = 8;
    strcpy(db.data[9].name, "B"); db.data[9].amount = 9;
    strcpy(db.data[10].name, "B"); db.data[10].amount = 10;
    strcpy(db.data[11].name, "B"); db.data[11].amount = 11;
    strcpy(db.data[12].name, "B"); db.data[12].amount = 12;
    strcpy(db.data[13].name, "A"); db.data[13].amount = 13;
    strcpy(db.data[14].name, "C"); db.data[14].amount = 14;
    db.size = 15;
    keep_if(&strcmp_name, "B"); /* strcmp returns false if matched */
    for(i = 0; i < db.size; i  ) {
        const struct inventory *const item = db.data   i;
        printf("%llu, %d, %s\n", item->amount, item->cent_price, item->name);
    }
    return 0;
}

我已經用 a 簡化了代碼，struct所以所有資料都在一個物件中。（我認為第二個MAX_SIZE_OF_ARRAYS應該INVENTORY_NAMES_ARRAY是MAX_SIZE_OF_STRINGS。）

轉載請註明出處，本文鏈接：https://www.uj5u.com/qukuanlian/489407.html

標籤：数组 C

上一篇：從mongo檔案中獲取陣列的所有值

下一篇：從PHP中的有序串列創建層次結構