c++ - reservar - matriz dinamica java

¿Cómo apuntar una matriz dentro de una matriz dinámica a algo?

Question

Tengo una struct como esta:

struct Key_Node
{
    int key;
    struct Package_Node *next_package;
};

struct Key_Node arrayMain[X] una matriz dinámica " struct Key_Node arrayMain[X] " donde el usuario ingresará el valor de X y, dependiendo de él, crearé la matriz dinámica.

Como no sé el tamaño de la matriz, obviamente no puedo apuntar cada puntero de la matriz dinámica a algo. Entonces, ¿qué tendré que hacer aquí?

Tengo otra struct que se ve así.

struct Package_Node
{
    int bar_code;
    float package_weight;
    struct Package_Node *next_packaged;
};

Key_Node mainArray[dynamicvalue] y

package_node totalPackages[dynamicvalue]

son una matriz dinámica y una lista vinculada en orden. Crearé paquetes aleatorios y los ordenaré usando métodos hashtable. Si mi X es 3 y mi código de barras aleatorio es 10, estaré haciendo 10 % 3 que resulta en 1, por lo que el package_node aleatorio se agregará a mainArray[1] y la lista crecerá así.

Answer 1

De acuerdo, creo que lo entiendo, pero podría estar muy lejos.

Nota importante: Esto es C ++, pero no puedo estar seguro de que realmente no estés usando C (que es más complicado). El código que ha publicado hasta ahora y la tarea que intenta realizar se sienten como C.

Primero, una introducción rápida a las listas enlazadas. Tienen un elemento "cabeza", y luego cada elemento apunta al siguiente en la lista:

struct Item {
    Item *next;
    // data here
};

struct ItemList {
    Item *first;
};

ItemList myList;
myList.first = new Item( );
myList.first->next = new Item( );
myList.first->next->next = new Item( );

Esta es una manera tonta de configurar una lista vinculada, pero demuestra la estructura; encontramos los nodos pasando por cada elemento de a uno por vez.

Desea una tabla hash que utiliza listas vinculadas (por lo que puedo deducir). Eso significa que tendrá una matriz de longitud fija de listas enlazadas y la posibilidad de agregar elementos a ella:

struct Item {
    Item *next;
    int key;
    int something;
};

struct ItemList {
    Item *first;
};

const int NUM_BUCKETS = 3;

ItemList keys[NUM_BUCKETS];

Item *addItemKey( int key, Item *o ) {
    int index = key % NUM_BUCKETS;
    if( keys[index].first != NULL ) {
        o->next = keys[index].first;
    }
    o->key = key;
    keys[index].first = o;
    return o;
}

int main( ) {
    Item *myItem1 = addItemKey( 10, new Item( ) );
    myItem1->something = 7;
    Item *myItem2 = addItemKey( 5, new Item( ) );
    myItem2->something = 3;
}

¿Entonces, Que es lo que hace eso? Bien addItemKey pondrá el elemento que le das en uno de los "cubos" de la tabla hash. Si ya había un elemento allí, lo empuja a convertirse en el segundo elemento. También devuelve el artículo como una conveniencia. Es importante que entiendas lo que está pasando aquí, así que pasa un rato jugando con la muestra a la que me dirijo al final de esta publicación.

Para encontrar un elemento de una clave, debe volver a calcular el índice y recorrer la lista correspondiente hasta que uno de los elementos coincida:

Item *findItemKey( int key ) {
    int index = key % NUM_BUCKETS;
    Item *test = keys[index].first;
    while( test != NULL ) {
        if( test->key == key ) {
            return test;
        }
        test = test->next;
    }
    return NULL;
}

int main( ) {
    // set up the items as before here

    Item *myFoundItem = findItemKey( 10 );
    if( myFoundItem != NULL ) {
        cout << myFoundItem->something << endl; // should say 7 with the code above
    }
}

Véalo funcionar aquí: http://codepad.org/b03NxST2

Cosas para cambiar:

1. Esto no está configurado para su problema. Eso es intencional; ¡no aprenderías nada si lo hiciera por ti!
2. La matriz de claves tiene un tamaño fijo en tiempo de compilación. Vea si puede mezclar esto con la muestra de @ amdn para que el usuario elija un tamaño.
3. La estructura ItemList no es necesaria en absoluto; Solo lo incluí para mayor claridad. Vea si puede eliminarlo.
4. Esto usa valores globales, que son una mala idea en general. Deberías usar métodos de objetos, pero eso es probablemente un poco avanzado para ti en este momento.

Si alguna vez necesitas hacer esto de verdad, deberías mirar estos objetos estándar que hacen todo esto por ti:

• http://www.cplusplus.com/reference/map/map/
• http://www.cplusplus.com/reference/list/list/
• http://www.cplusplus.com/reference/vector/vector/

Answer 2

Parece que necesitas un poco de ayuda para que comiences. Parece que le piden que implemente una tabla hash . En C , utiliza malloc para asignar almacenamiento dinámico, en C++ usa new , consulte ¿En qué casos uso malloc vs new?

Esto debería hacerte comenzar, espero que ayude.

#include <iostream>
struct Key_Node
{
    int key;
    struct Package_Node *next_package;
};

struct Package_Node
{
    int bar_code;
    float package_weight;
    struct Package_Node *next_packaged;
};

int main() {
    size_t X;
    std::cout << "Enter X: ";
    std::cin >> X;
    Key_Node *mainArray = new Key_Node[X];

    for(size_t i=0; i<X; ++i) {
        mainArray[i].next_package = NULL;
    }

    //-- Rest of your program goes here

    delete [] mainArray;

    return 0;
}