Mensajes

De nada hombre.

Un placer.

Obviamente todos los almacenes de información a lo largo de un algoritmo implican un mayor consumo de recursos... en C, C++, C#, Java, Perl, PHP, ADA, Pascal, javascript y cualquier otro.

Sin embargo la cosa cambia cuando te encuentras con algo tal que:

Código (c) [Seleccionar] Expandir


#include <limits.h>
#include <iostream>

int main( )
{
  for ( unsigned int i=0; i<UINT_MAX; i++ )
  {
    for ( unsigned int j = 0; j < UINT_MAX; j++ )
    {
      string variable = "ALGO" + std::to_string( i ) + std::to_string( j );
      std::cout << variable << std::endl;
    }
  }
}

Código (csharp) [Seleccionar] Expandir


public class Program
{
  public static void Main()
  {
    for ( uint i=0; i<uint.MaxValue; i++ )
    {
      for ( uint j = 0; j < uint.MaxValue; j++ )
      {
        string variable = "ALGO" + i.ToString( ) + j.ToString( );
        System.Console.WriteLine( variable );
      }
    }
  }
}

Ya te garantizo yo que el consumo total de memoria del segundo programa en C# es bastante superior. Y cuando digo "bastante superior" me refiero descontando el consumo adicional de memoria que por defecto tiene C# con respecto a C++.

En primer lugar, 'c' no está inicializado. Pero además, dado que el valor que tenga 'c' en la primera iteración es indiferente, deberías replantearte cambiar el while por un do-while.

Código (c) [Seleccionar] Expandir


int mayorLinea(FILE *arch)
{
char c;
int contador = 0;
int aux = 0;

while(c != EOF){

En la siguiente sección, no reinicias la variable "contador", sino que estás forzando una comparación:

Código (c) [Seleccionar] Expandir


if(contador > aux){
aux = contador;
}
contador == 0;

A ese "==" le sobra uno de los dos caracteres.

Si yo hago un bucle con strings sin usar punteros... en C++ tendré un uso bastante estable de la memoria.

En C# y Java usaré punteros sí o sí, solo que yo no voy a verlos como punteros porque esa parte la enmascara el framework... en este caso, el mismo ejemplo que con C++ resultará en un consumo absurdamente elevado de memoria hasta que el algoritmo termine y le de un respiro al recolector de basura para poder hacer su trabajo.

Te recomiendo Java y C#.

Depende del uso... como necesites un algoritmo iterativo o recursivo con reservas de memoria en cada iteración... aunque luego las "liberes", te puedes encontrar con el caso de que el equipo se queda sin memoria en menos de un minuto... la razón es sencilla, al no tener tu control sobre el ciclo de vida sobre los objetos, éstos se quedan en estado latente esperando a ser eliminados por el recolector de basura... si tu aplicación no le da tiempo al recolector para trabajar, los objetos no se eliminan y la memoria se acumula hasta que te quedas sin nada.

Y no lo digo por decir, al menos en la versión 2.0 del framework de .Net es absurdamente sencillo... se puede hacer con bucles y clases de tipo string... no creo que las versiones posteriores hayan avanzado muchísimo en ese tema.

Moraleja: si el algoritmo o la aplicación hace un uso intensivo de memoria dinámica, .Net al menos ( y Java no creo que sea muy diferente ), no te sirven.

Sin ver el código es complicado comentar los errores.... no somos adivinos.

Una lista doblemente enlazada se caracteriza porque puedes recorrerla hacia adelante o hacia atrás indiferentemente.

La norma general para añadir un elemento es, una vez localizada la posición en la que se ha de insertar, realizar las siguientes operaciones:

1. nuevo_nodo->puntero_anterior = nodo_anterior;
2. nuevo_nodo->puntero_siguiente = nodo_siguiente;
3. nodo_anterior->puntero_siguiente = nuevo_nodo;
4. nodo_siguiente->puntero_anterior = nuevo_nodo;

Esta norma general tiene 2 excepciones:

* Si el nodo va en primer lugar, se omite el paso 3 y el 1 apunta a null.
* Si el nodo va al final, se omite el paso 4 y el 2 apunta a null.

Si resulta que la lista está vacía, se dan a la vez las dos circunstancias anteriores... basta con aplicarlas.

En tu caso concreto, hablando sobre el "cuarto caso", lo que tienes que hacer es seguir los 4 puntos que te he indicado. No tiene pérdida.

Por cierto, si la lista va a ser SIEMPRE ordenada, agregar_principio y agregar_ordenado colisionan entre sí, deberías eliminar una de las dos funciones para evitar código duplicado.

Es más, si tu idea es recorrer la lista para ubicar un elemento, no puedes usar un puntero a tipo "LISTA"... tienes que usar uno a tipo "NODO", para poder recorrer de forma recursiva la lista:

Código (c) [Seleccionar] Expandir


void agregar_elemento( LISTA* lista, NODO* nodo_ant, int dato )
{
  if (lista->inicio == NULL)
  {
    // Este caso se da cuando la lista esta vacia
    NODO *nuevo=(NODO *)calloc(1, sizeof(NODO));
    nuevo->dato = dato;
    lista->inicio = nuevo;
    lista->fin = nuevo;
  }
  else if ( nodo_ant->dato < dato )
  {
    // el nuevo nodo va "antes" que nodo_ant
    NODO *nuevo=(NODO *)malloc(sizeof(NODO));
    nuevo->dato = dato;
    nuevo->ant = nodo_ant->ant;
    nuevo->sig = nodo_ant;
    nodo_ant->sig = nuevo;

    if ( nodo_ant->ant )
      nodo_ant->ant->sig = nuevo;
    else
      lista->inicio = nuevo;
  }
  else if ( nodo_ant->dato > dato )
  {
    // El nuevo nodo va despues que "nodo_ant"
    // Hay que comprobar si hemos llegado al final de la lista

    if ( nodo_ant->sig )
      agregar_elemento( nodo_ant->sig );
    else
    {
      // nodo_ant es el ultimo elemento de la lista, el nuevo tiene que ir despues
      NODO *nuevo=(NODO *)calloc(1, sizeof(NODO));
      nuevo->dato = dato;
      nuevo->ant = nodo_ant;
      nodo_ant->sig = nuevo;
      lista->fin = nuevo;
    }
  }
}

Incluso se podría optimizar más el código usando dos funciones ( una para localizar la ubicación del nuevo nodo y otra para insertarlo ), pero eso ya te lo dejo a ti.

Son diferentes.

new y delete te dan un control muy preciso sobre el ciclo de vida de los objetos... pero ese control tiene un precio a pagar y es que vas a tener que estar muy pendiente para evitar lagunas de memoria.

los smart pointers son una característica bastante interesante de la stl. Te permite relajarte en la gestión de la memoria dinámica a costa de perder cierto control sobre el ciclo de vida de los objetos. Yo, a título personal, únicamente soy partidario de usar unique_ptr, ya que con shared_ptr el concepto de "ciclo de vida" queda demasiado difuso.

También recordar que shared_ptr puede provocar lagunas de memoria si creas relaciones circulares... y usar weak_ptr es, a veces, un coñazo

No es necesario repetir el código en cada función... repetir código es una fea costumbre que suele dar problemas... sobretodo porque vas a tener que corregir el mismo fallo varias veces.

En primer lugar, para almacenar un string, necesitas un buffer que sea, como mínimo, equivalente a la longitud de la cadena más uno ( para el carácter de final de cadena, '\0' )

En tu caso, amarillo tiene longitud 8, luego necesitas un buffer de tamaño 9 o más para poder almacenar esa cadena de forma segura.

EI: dejemos que haga sus propio codigo por favor.

Efectivamente la idea es confusa y hay varias lagunas en tu planteamiento:

* La matriz no se puede mover... se pueden mover sus valores. No queda claro si sólo quieres mover un carácter o todos ellos.

* ¿Por qué en el caso de mover al norte el carácter elegido es 'R'?

* Si desplazas un carácter, por ejemplo, hacia el norte, es decir, hacia arriba, ¿Cómo se rellena el hueco que deja?

* ¿Qué significado tienen los caracteres que has definido como especiales ("R", "S", "*", "@", "/" ) ?

* ¿Cómo determinas las posiciones "x" e "y" al elegir un movimiento ( norte, sur, este y oeste ) ?