Suppression d'éléments d'un tableau en C

J'ai juste une simple question sur les tableaux en C

Quelle est la meilleure façon de supprimer des éléments d'un tableau et dans le processus de faire de la matrice plus petite.

je.e le tableau est de taille n, alors je prends des éléments de la matrice, puis la matrice diminue par la quantité que je l'ai retiré.

fondamentalement, je suis le traitement de la matrice comme un jeu de cartes et une fois que je prends une carte du dessus du paquet, il ne devrait pas être plus là.

EDIT: je vais vous conduire moi-même fou avant la fin de la journée, merci pour toute l'aide que je suis en train de la valeur de la permutation de chose mais ça ne marche pas droit.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
enum faces{Ace = 0, Jack = 10, Queen, King};
char * facecheck(int d); 
int draw(int deck, int i); 
int main() 
{ 
int deck[52], i, n;
char suits[4][9] = 
{
"Hearts",
"Diamonds",
"Clubs",
"Spades"};
n = 0;
for(i = 0; i<52; i++)
{
deck[i] = n;
n++;
};
for(i=0; i<52; i++)
{       
if(i%13 == 0 || i%13 == 10 || i%13 == 11 || i%13 == 12)
printf("%s ", facecheck(i%13) );
else printf("%d ", i%13+1);
printf("of %s \n", suits[i/13]);
}
draw(deck, i);
return 0; 
}  
char * facecheck(int d)
{
static char * face[] = 
{
"Ace",
"Jack",
"Queen",
"King" };
if(d == Ace)
return face[0];
else
{
if(d == Jack) 
return face[1];
else
{
if(d == Queen)
return face[2];
else 
{ 
if(d == King)
return face[3];
}
}
} 
}
int draw(int deck,int i ) 
{ 
int hand[5], j, temp[j];
for(i=0; i<52; i++)
{
j = i
}; 
for(i = 0; i < 5; i++)
{
deck[i] = hand[]; 
printf("A card has been drawn \n");
deck[i] = temp[j-1];
temp[j] = deck[i];
};
return deck;
}

source d'informationauteur Rini Posny

  1. 9

    Il y a deux questions distinctes. La première est de garder les éléments du tableau dans le bon ordre afin qu'il n'y a pas de "trous" après la suppression d'un élément. La deuxième est en fait le redimensionnement de la matrice elle-même.

    Tableaux en C sont attribués sous forme d'un nombre fixe d'éléments contigus. Il n'y a aucun moyen de supprimer de la mémoire utilisée par un individu élément dans le tableau, mais les éléments peuvent être décalées de remplir le trou laissé par la suppression d'un élément. Par exemple:

    void remove_element(array_type *array, int index, int array_length)
{
int i;
for(i = index; i < array_length - 1; i++) array[i] = array[i + 1];
}

    Allouée statiquement les tableaux ne peuvent pas être redimensionnées. Des tableaux alloués dynamiquement peut être redimensionnée avec realloc(). Cela pourrait déplacer l'ensemble du tableau dans un autre endroit de la mémoire, de sorte que tous les pointeurs vers le tableau ou à ses éléments devront être mis à jour. Par exemple:

    remove_element(array, index, array_length);  /* First shift the elements, then reallocate */
array_type *tmp = realloc(array, (array_length - 1) * sizeof(array_type) );
if (tmp == NULL && array_length > 1) {
/* No memory available */
exit(EXIT_FAILURE);
}
array_length = array_length - 1;
array = tmp;

    realloc va retourner un pointeur NULL si la taille demandée est de 0, ou si il y a une erreur. Sinon, elle retourne un pointeur vers la réaffectées tableau. Le temporaire pointeur est utilisé pour détecter les erreurs lors de l'appel de realloc parce qu'au lieu de sortir, il est également possible de ne laisser que le tableau d'origine tel qu'il était. Lorsque le realloc ne parvient pas à réaffecter un tableau, il ne modifie pas le tableau d'origine.

    Noter que deux de ces opérations sera assez lent, si le tableau est grand ou si beaucoup d'éléments sont supprimés. Il existe d'autres structures de données comme les listes et les tables de hachage qui peut être utilisé si efficace, l'insertion et la suppression est une priorité.

  2. 4

    Vous ne voulez pas vraiment être reallocing de la mémoire chaque fois que vous supprimez quelque chose. Si vous connaissez le résumé de la taille de votre pont puis choisissez une taille appropriée pour votre tableau et de garder un pointeur à l'actuel fin de la liste. C'est un pile.

    Si vous ne connaissez pas la taille de votre deck, et pense qu'il pourrait être vraiment grande, ainsi que ne cesse de changer de taille, alors vous aurez à faire quelque chose d'un peu plus de complexité et de mettre en œuvre un liste liée.

    En C, vous avez deux façons simples pour déclarer un tableau.

    1. Sur la pile, comme un tableau statique

      int myArray[16]; //Static array of 16 integers

    2. Sur le tas, comme un tableau alloué dynamiquement

      //Dynamically allocated array of 16 integers
int* myArray = calloc(16, sizeof(int));

    C Standard ne permet pas de tableaux de l'un de ces types de être redimensionnée. Vous pouvez soit créer un nouveau tableau de taille spécifique, puis copiez le contenu de l'ancien tableau à l'autre, ou vous pouvez suivre l'une des suggestions ci-dessus pour un autre type abstrait de données (ie: lien de la liste, pile, file d'attente, etc).

  3. 2

    Il est intéressant de noter matrice aléatoire est accessible par l'index. Et retrait au hasard un élément peut avoir un impact sur les indices des autres éléments.

        int remove_element(int*from, int total, int index) {
if((total - index - 1) > 0) {
memmove(from+i, from+i+1, sizeof(int)*(total-index-1));
}
return total-1; //return the new array size
}

    Noter que memcpy ne fonctionnera pas dans ce cas en raison du chevauchement de la mémoire.

    L'un des moyen efficace (mieux que la mémoire se déplacer) pour supprimer un élément aléatoire est échanger avec le dernier élément.

        int remove_element(int*from, int total, int index) {
if(index != (total-1))
from[index] = from[total-1];
return total; //**DO NOT DECREASE** the total here
}

    Mais l'ordre est changé après l'enlèvement.

    De nouveau si le retrait est effectué dans un fonctionnement en boucle puis la réorganisation peut avoir un impact sur le traitement. La mémoire se déplacer est un cher alternative pour maintenir l'ordre lors de la suppression d'un élément de tableau. Un autre de la façon de garder le tout dans une boucle, est de retarder le retrait. Elle peut être réalisée par période de validité tableau de la même taille.

        int remove_element(int*from, int total, int*is_valid, int index) {
is_valid[index] = 0;
return total-1; //return the number of elements
}

    Il va créer un tableau fragmenté. Enfin, le tableau fragmenté peut être faite compact(qui ne contient pas de deux éléments qui contiennent de l'élément non valide entre eux) en faisant de la réorganisation.

        int sparse_to_compact(int*arr, int total, int*is_valid) {
int i = 0;
int last = total - 1;
//trim the last invalid elements
for(; last >= 0 && !is_valid[last]; last--); //trim invalid elements from last
//now we keep swapping the invalid with last valid element
for(i=0; i < last; i++) {
if(is_valid[i])
continue;
arr[i] = arr[last]; //swap invalid with the last valid
last--;
for(; last >= 0 && !is_valid[last]; last--); //trim invalid elements
}
return last+1; //return the compact length of the array
}