Austauschen von Elementen in einem Array von Zeichenfolgen

Question

Ich versuche, ein Programm zu erstellen, um zufällige Testfälle zu generieren. Ich habe ein Array von Strings (char **), die geordnet sind, und ich möchte sie randomisieren. Mein Ansatz besteht darin, zwei Elemente zufällig auszuwählen und sie zu tauschen. Allerdings bekomme ich immer einen Fehler und es scheint, als ob ich etwas Wissen verpasst habe.

Probenarray (64 Elemente): {"1 2 3", "3 2 1", "4 5 6".....}

char ** randomizeOrder(char ** list, int size){ 

    char temp[6]; 
    temp[5] = '\0'; 

    srand(time(NULL)); 
    int count = 64; 
    int x, y; 
    while(count > 0){ 
     fprintf(stderr, "Starting...\n"); 
     x = rand() % 64; 
     y = rand() % 64; 

     strcpy(temp, list[x]); 
     fprintf(stderr, "Copying %s from Y to X\n", list[y]); 
     strcpy(list[x], list[y]); 
     fprintf(stderr, "Copying %s from temp to Y\n", temp); 
     strcpy(list[y], temp); 
     count--; 
    } 

    return list; 

} 

Es scheint für die ersten paar Elemente zu arbeiten, und dann beginnt das Lesen Müll. Die Elemente sind wie das Array malloziert, alle Elemente drucken einwandfrei. Irgendwelche Ideen, was schief geht?

Answer 1

Denken Sie, Sie sollten nur die Zeiger, nicht den String-Inhalt selbst tauschen. Ein char** ist natürlich nur ein Array von Zeigern.

würde wie folgt aussehen:

while(count > 0){ 
    x = rand() % 64; 
    y = rand() % 64; 

    char* tmp = list[x]; 
    list[x] = list[y]; 
    list[y] = tmp; 
    count--; 
} 

Wenn Sie sehr klug sein wollen, können Sie verwenden this trick:

while(count > 0){ 
    x = rand() % 64; 
    y = rand() % 64; 

    list[x] |= list[y]; 
    list[y] |= list[x]; 
    list[x] |= list[y]; 

    count--; 
} 

Answer 2

Ein Problem des Codes ist, dass es möglich ist, x und y haben die gleiche Nummer sein, und Sie sind strcpy in sich selbst wenn strcpy(list[x], list[y]);. Afaik, das funktioniert nicht garantiert.

(Obwohl ich Ihr eigentliches Problem glauben kann zu tun hat, wie Sie die Eingabe char** füllen kann nicht überprüfen, da es Mangel an Informationen jetzt.)

Answer 3

Ich glaube, sie einige Probleme in Ihrem Code sind:

• Sie übergeben size zu randomize(), aber Sie verwenden es nie. Es wäre besser zu machen:

  size_t x = rand() % size; 
  size_t y = rand() % size; 
  

  Statt schwer, einen Größenwert von 64 in diese Linien Codierung.

• Da Sie Zeiger vertauschen, ist es nicht notwendig, einen temporären Puffer und strcpy() Zeiger in sie zu erstellen. Sie können die Zeiger einfach selbst austauschen. Ich empfehle, mit nur einer Funktion wie folgt aus:

  void swap(char **s1, char **s2) { 
      char *temp = *s1; 
      *s1 = *s2; 
      *s2 = temp; 
  } 
  

  dann können Sie einfach swap(&list[x], &list[y]); geben Ihre Zeiger zu tauschen.

• Ich glaube nicht, dass Ihre Funktion randomize()char** zurückgeben muss. Es wäre einfacher, wenn es einfach void wäre.

Hier finden Sie einige Testcode, dies zeigt:

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

#define ARRAYSIZE(x) (sizeof x/sizeof x[0]) 

void randomize(char **list, size_t size); 
void print_list(char **list, size_t size); 
void swap(char **s1, char **s2); 

int main(void) { 
    char *list[] = {"1 2 3", "3 2 1", "4 5 6", "6 5 4", "7 8 9", "9 8 7"}; 

    printf("Original list:\n"); 
    print_list(list, ARRAYSIZE(list)); 

    randomize(list, ARRAYSIZE(list)); 

    return 0; 
} 

void randomize(char **list, size_t size) { 
    size_t x, y; 

    srand(time(NULL)); 

    for (size_t i = 0; i < size; i++) { 
     x = rand() % size; 
     y = rand() % size; 

     swap(&list[x], &list[y]); 

     printf("Swapping list[%zu] and list[%zu]:\n", x, y); 
     print_list(list, size); 
    } 
} 

void print_list(char **list, size_t size) { 

    printf("{"); 
    for (size_t i = 0; i < size-1; i++) { 
     printf("%s, ", list[i]); 
    } 
    printf("%s}\n\n", list[size-1]); 
} 

void swap(char **s1, char **s2) { 
    char *temp = *s1; 
    *s1 = *s2; 
    *s2 = temp; 
} 

Zufalls Ausgang:

Original list: 
{1 2 3, 3 2 1, 4 5 6, 6 5 4, 7 8 9, 9 8 7} 

Swapping list[0] and list[4]: 
{7 8 9, 3 2 1, 4 5 6, 6 5 4, 1 2 3, 9 8 7} 

Swapping list[4] and list[1]: 
{7 8 9, 1 2 3, 4 5 6, 6 5 4, 3 2 1, 9 8 7} 

Swapping list[0] and list[1]: 
{1 2 3, 7 8 9, 4 5 6, 6 5 4, 3 2 1, 9 8 7} 

Swapping list[3] and list[3]: 
{1 2 3, 7 8 9, 4 5 6, 6 5 4, 3 2 1, 9 8 7} 

Swapping list[2] and list[1]: 
{1 2 3, 4 5 6, 7 8 9, 6 5 4, 3 2 1, 9 8 7} 

Swapping list[4] and list[1]: 
{1 2 3, 3 2 1, 7 8 9, 6 5 4, 4 5 6, 9 8 7}