Mensajes

... solo algo sobre M y n, por definicion en arboles B, n es el numero maximo de ramas que puede tener el nodo y M-1 es el numero maximo de claves por nodo ...

Si para programar decides usar este tipo de terminologías, más te vale no olvidar nunca las variables utilizadas para cada algoritmo y tener siempre presente qué algoritmo estás editando en cada momento.

Si en vez de 'M', te encuentras 'max_claves_nodo', y en vez de 'n' tienes 'max_ramas', por ejemplo, de seguro que nunca te confundirás al identificar dichas variables... ni tu ni nadie que pase por ese código.

Por cierto, tal y como está modelada tu estructura, 'n' no significa "máximo de ramas", sino "número actual de ramas". Básicamente es así porque mientras ( n < M ), podré añadir ramas nuevas e incrementar 'n' y el sistema seguirá funcionando... si 'n' fuese un máximo no podría incrementarlo.

Ese matiz es importante y da idea de que usar caracteres sueltos para poner nombres a variables no suele ser una buena idea.

A ver si me entero.

* Tienes una matriz con valores determinados, entre ellos al menos una I y una F.

* Se elige una I y se le van pidiendo al usuario una serie de pasos. Cada paso desplaza I por la matriz.

* Si en uno de los pasos resulta que I va a estar ubicada en la posición donde se encuentra una F el programa deja de pedir más pasos

¿Es así?

Si estoy en lo cierto, tengo algunas dudas:

* Solo hay una I y una F o puede haber varias de cada una??

* Si se desplaza I por la matriz... que valor se pone en el espacio que queda vacío? Si I está en (1,0) y se mueve a (2,0), qué valor se pone en (1,0)??

Si no estoy en lo cierto, deberías replantearte un pequeño esfuerzo adicional para que se entienda el problema.

Un saludo.

... lo que hace es que cuanto la posición donde esta el carácter I es igual a F mi variable estado se vuelve verdad ...

Posición del carácter I igual a F ????

¿¿¿???

Perdón por el comentario, pero te explicas como un libro cerrado

Veo que estás usando C++.

En este caso, espero que hayas implementado el constructor de la clase Nodo. Si es así, dicho constructor debería inicializar los punteros "siguiente" y "anterior" a NULL, por lo que podrías evitar el uso de determinadas líneas en el código:

Código (cpp) [Seleccionar] Expandir


    if(Vacia())
    {
        inicio=temp;
        ultimo=temp;

        // Las siguientes lineas sobrarian
        //temp->siguiente=NULL;
        //temp->anterior=NULL;
    }

Y luego, en el bucle de inserción:

Código (cpp) [Seleccionar] Expandir


temp2->siguiente=temp->anterior;
temp2->siguiente=temp;

¿No ves nada raro?

[El Benjo]

una constante, por definición, no puede ser modificada durante la ejecución del programa... en caso contrario no sería "constante".

Si necesitas cambiar ese valor de forma dinámica, tienes que usar, por definición, memoria dinámica. La memoria dinámica se reserva como te ha comentado El Benjo, es decir, usando malloc o calloc para reservar la memoria y free para liberarla.

El proceso en sí es sencillo:

1. Modifica tu estructura para poder hacer reservas dinámicas de memoria:

Código (c) [Seleccionar] Expandir


struct nodo
{
   int n; // n < M n? de claves en el nodo siempre ser? menor que el orden del B tree
   int *arreglo_claves; //arreglo de claves
   struct nodo **p; // (n+1 punteros que van a ser usados
};

2. Crea una función que te permita hacer las reservas de memoria:

Código (c) [Seleccionar] Expandir


struct nodo* NuevoNodo( int n, int M )
{
  struct nodo* nuevo_nodo = (struct nodo*)malloc( sizeof( struct nodo ) );
  nuevo_nodo->arreglo_claves = (int*)calloc( M - 1, sizeof( int ) );
  nuevo_nodo->p = (struct nodo**)calloc( M, sizeof( struct nodo* ) );

  return nuevo_nodo;
}

La diferencia entre malloc y calloc es que calloc pone todos los bits a 0, malloc deja la memoria con los datos que tuviese previamente ( basura ).

3. Estaría bien tener una función que permita liberar toda esa memoria.

En este caso te hace falta un free por cada malloc o calloc... esta parte te la dejo a tí.

4. Usa variables con sentido, M y n no significan absolutamente nada.

el operador '.' se usa para acceder a los miembros de una instancia de una estructura o clase cuando ésta está siendo utilizada por valor o por referencia.

el operador '->' se usa para acceder a los miembros de una instancia de una estructura o clase cuando accedemos a ella a través de un puntero.

el operador '::' permite acceder a los miembros estáticos de una clase o estructura.

Este ejemplo te demostrará que un diseño incorrecto con smart pointers puede acabar con lagunas de memoria:

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <memory>

class Nodo
{
    static int id;

  public:
    Nodo( )
      : _id( id++ )
    {  std::cout << "Nodo " << id << " creado" << std::endl; }

    ~Nodo( )
    { std::cout << "Nodo " << id << " destruido" << std::endl; }

    std::shared_ptr< Nodo > puntero;

  private:

    int _id;
};

int Nodo::id = 0;

void func( )
{
    std::shared_ptr< Nodo > nodo1 = std::make_shared< Nodo >( );
    std::shared_ptr< Nodo > nodo2 = std::make_shared< Nodo >( );
    std::shared_ptr< Nodo > nodo3 = std::make_shared< Nodo >( );

    nodo1->puntero = nodo2;
    nodo2->puntero = nodo1;
}

int main( )
{
  std::cout << "Llamada a func" << std::endl;

  func( );

  std::cout << "Y la llamada a los destructores de nodo1 y nodo2?" << std::endl;
}

Efectivamente, un shared_ptr está diseñado para borrar su contenido cuando éste ya no esté referenciado... el problema es que, si se crean referencias circulares, se crea una dependencia mutua que impide que los elementos se borren.

Sigue estos pasos:

Project Properties
       -> Configuration Properties
           -> Linker (General)
              -> Enable Incremental Linking -> "No (/INCREMENTAL:NO)"

Después de realizar algunas comprobaciones debo reconocer que .NET ha mejorado enormemente los problemas que comento.

Me apunto probar con strings más grandes... ya que el "tamaño" que ocupa uno de estos es francamente pequeño... y no se puede hacer un subclass de "string" porque es una clase "sealed".

Aún así me ha sorprendido la mejora de rendimiento al respecto.

Se hace uso intensivo de memoria porque cada vez que creas un string, en la versión de C# (igual pasaría con Java) se está creando bajo la figura de un puntero... cuando se sale del ámbito, la instancia de string se marca para ser reciclada por el recolector de basura. Dado que el proceso está ocupado con la ejecución del bucle, el recolector de basura no entra en juego... y eso sucede a lo largo de toda la vida del código que he puesto.

Resultado: 4 * 4,294,967,295^2 instancias de string esperando a ser liberadas... y ocupando espacio en memoria.

el 4 viene porque:

Código (csharp) [Seleccionar] Expandir

string variable = "ALGO" + i.ToString( ) + j.ToString( );

Esta línea implica la creación de 4 strings:

* primer string: "ALGO"
* segundo string: i.ToString( )
* tercer string: j.ToString( )
* cuarto string: variable = todo_lo_demas

Bueno, realmente creo que sería más correcto decir que en cada iteración se crean 5 strings... ya que los operadores de suma se resuelven uno a uno.

En C++, el uso de punteros ya no es tan necesario. Para modificar variables y tal, prefiero mil veces las referencias.

El único uso que le veo a los punteros en C++ es para el polimorfismo. Para todo lo demás tienes las STL y las referencias:

Los punteros son suceptibles a los memoryleaks, las STL no ^^

Totalmente de acuerdo.

Además, usando referencias evitas la tentación de hacer delete donde no corresponde