Principiante Eliminando el primer elemento de una matriz de estructuras (C)

Tengo una matriz de estructuras (en realidad es una matriz de stack ordenada por prioridad).

typedef struct { char name[MAX_CHARACTERS+1]; int priority; } person; person p[MAX_HEAPSIZE+1]; 

y quiere eliminar el primer elemento de la matriz. No estoy seguro de cómo o qué comando utilizar.

Hasta ahora, he estado haciendo

 void remove(){ swap(0, heapsize-1); strcpy(p[heapsize-1].name, p[MAX_HEAP_SIZE+1].name); p[heapsize-1].priority = p[MAX_HEAP_SIZE+1].priority; } 

esto intercambia el primer y último elemento no vacío en la matriz. Luego intenta copiar los datos en un elemento vacío al último elemento no vacío (elemento que quiero eliminar) en la matriz.

Pero creo que solo copia las posiciones de memoria. ¿Hay algo simple donde pueda hacer?

p [0] = NULL?

Una matriz es un bloque continuo de memoria. Por lo tanto, si desea eliminar el primer elemento, debe mover todos los elementos siguientes hacia el principio mediante un elemento:

 void remove(void) { memmove(&p[0], &p[1], (MAX_HEAPSIZE - 1) * sizeof(person)); } 

Esto es bastante ineficiente. Destacar el primer elemento es una operación común con un montón, por lo que normalmente lo haría al revés: eliminar el último elemento de una matriz, que es muy rápido, porque los otros elementos de la matriz no están afectados.

 void remove(void) { heapsize--; } 

heapsize se puede usar como el índice del elemento superior del montón (asumiendo que usted preserva la propiedad del montón, por supuesto).

Si desea sobrescribir el primer elemento de la matriz con el último y poner a cero la memoria del último elemento, que ya no se usa, puede usar memcpy y memset:

 void remove(void) { memcpy(&p[0], &p[heapsize - 1], sizeof(person)); memset(&p[heapsize - 1], 0x00, sizeof(person)); } 

Sin embargo, no es estrictamente necesario poner a cero la memoria del último elemento porque, en primer lugar, no deberías acceder a ella. En lugar de sobrescribir el primer elemento con el último uso de memcpy, también se puede hacer con strcpy y la asignación de la prioridad (como en su remove ); usar memcpy es simplemente más fácil.

Parece que está intentando implementar una ordenación de stack. En realidad, no es necesario “eliminar” el primer elemento del montón, ni siquiera el último.

En cambio, el algoritmo es copiar los valores del primer elemento (el elemento con la prioridad más alta) para la salida, luego copiar el nodo desde el “final” de la matriz a la primera posición en preparación para burbujear hacia abajo en el posicion correcta. El “final” de la matriz se indica mediante el tamaño de stack actual.

Para “eliminar” el último elemento de la matriz, simplemente reduzca el tamaño de heap en 1.

Recuerdo vagamente que el burbujeo hacia abajo se logra al verificar las prioridades de los niños en el elemento en movimiento, y luego intercambiarlo con el de mayor prioridad. Repita esto en el elemento movido hasta que el elemento tenga la misma o mayor prioridad que sus elementos secundarios.

El truco para encontrar los elementos secundarios de un elemento es fácil: son los nodos en 2 * i y 2 * i + 1, donde la matriz comienza en 1 en lugar de 0. (Sería 2 * (i + 1) -1 y 2 * (1 + 1) para arreglos basados ​​en 0? Revise mis cálculos, por favor. O simplemente desperdicie un elemento del arreglo para mantener los cálculos simples.)