Mensajes

Un problema que tienes es que no actualizas el arbol al eliminar los nodos.

Por ejemplo:

Código (c) [Seleccionar] Expandir

void ArbolBinario::cortarNodo(Nodo *q, Nodo *p){

    //Si el nodo a eliminar es una hoja, se borra sin problemas.   

    if(p->izquierdo == NULL && p->derecho == NULL){

        delete p;
        return;

    }
    // ...
}

haces el delete... ok... pero "p" sigue apuntando a una dirección... solo que no es válida.

Deberías pasar un puntero doble a esa función para poder hacer algo tal que:

Código (c) [Seleccionar] Expandir

void ArbolBinario::cortarNodo(Nodo *q, Nodo **p){

    //Si el nodo a eliminar es una hoja, se borra sin problemas.   

    if((*p)->izquierdo == NULL && (*p)->derecho == NULL){

        delete *p;
        *p = NULL;
        return;

    }
    // ...
}

El problema es que el código no se puede probar porque el código que has pasado está incompleto.

Más cosillas:

Código (cpp) [Seleccionar] Expandir


        Nodo *actual;
        Nodo *detras;

        while(actual != NULL){

Usar variables sin inicializar directamente en un bucle??? mala idea, quizás debieras plantearte un bucle do-while e inicializar "actual" y "detras" a nullptr ( nullptr es nuevo en el estandard C++11 y viene a sustituir a NULL.

Y en cuanto a errores, así a simple vista veo esos. El diseño de la clase ArbolBinario deja que desear... si todos los métodos van a ser públicos no se qué sentido tiene crear una clase... pero eso no afecta al funcionamiento del programa.

La pantalla no es sino una matriz más o menos grande... tiene filas y columnas.

Tu tienes un array de 8x8.

Imagínate que coges una porción de la pantalla de 8x8 y dibujas en esa porción una representación de tu matriz.

Basta con recorrer la matriz por filas... para cada fila recorres sus columnas... en cada posición compruebas el valor de la celda e imprimes por pantalla el caracter que corresponde con ese valor... pasas al siguiente valor. Cuando terminas una fila introduces un salto de línea y repetir.

Cual es la diferencia de funciones virtuales y vistuales puras?

Las funciones virtuales son funciones que pueden ser sobreescritas en las clases hijas. Las funciones virtuales puras son funciones virtuales que no tienen código en la clase padre.

Cuando tú en una clase defines una función virtual pura la clase pasa a ser abstracta, es decir, no puedes crear instancias de esta clase.

Código (cpp) [Seleccionar] Expandir



class A
{
  public:
    virtual void func( ) = 0;
};

class B : public A
{
  public:
    void func( )
    { std::cout << "B" << std::endl; }
};

class C : public A
{
  public:
    void otro( )
    { std::cout << "C" << std::endl; }
};
void main( )
{
  A* var1 = new A( ); // Error, A es abstracta
  A* var2 = new B( ); // Correcto
  A* var3 = new C( ); // Error C es abstracta porque no implementa 'func'
}

Como el ejemplo que pones.
Noto que en la clase A describes los métodos virtuales a usar, y en la clase B, que seria la hija, llama a la función virtual solo que con las funcionalidad que necesito (o código que deseo poner, por si no me explico).

Los métodos virtuales permiten que las clases hijas implementen un código propio sobre una función declarada en el padre, de tal forma que ese código sea llamado siempre independientemente de cual sea "la forma" mediante la cual se acceda a dicho método:

Código (cpp) [Seleccionar] Expandir


class A
    {
     public:
       void func1( )
       { std::cout << "A" << std::endl; }
    };

    class B : public A
    {
     public:
       void func1( )
       { std::cout << "B" << std::endl; }
    };

    void main( )
    {
     A* ptr1 = new A( );
     A* ptr2 = new B( );
     B* ptr3 = dynamic_cast< B*>( ptr2 );

     ptr1->func1( );
     ptr2->func1( );
     ptr3->func1( );
    }

Fíjate que he quitado el modificador de "virtual" en la clase padre. En este caso la salida del programa será:

Código [Seleccionar] Expandir


A
A
B

Esto es así porque, al no ser virtual, el resultado de func1( ) dependerá del tipo de puntero ( A o B ) y no del tipo de la instancia a la que apunta ( A o B ).

Como corolario, en C++11 se añaden dos modificadores adicionales para estos casos; uno de ellos es especialmente útil. Se trata del modificador "override".

"override" se usa en las funciones virtuales que sobreescribes en las clases hijas y su función es obligar al compilador a que se asegure de que realmente la función esta sobreescribiendo una función virtual... si no es así resulta un error de compilación.

Código (cpp) [Seleccionar] Expandir


class A
{
  public:
    virtual void func( )
    { }

    virtual void funcConNombreRarillo( )
    { }
};

class B : public A
{
  public:
    // ok
    voif func( ) override;

    // Error: no hay ninguna func( int ) declarada virtual en el padre
    void func( int param ) override;

    // Error: Se me ha colado una l de mas en el nombre
    void funcConNombreRarilllo( ) override;
};

El modificador "override" es bastante útil porque, de otra forma" no tenemos posibilidad de detectar estos errores a la hora de programar. Es muy sencillo equivocarse en la firma de la función y es ciertamente complicado detectar el problema.

lo que pasa es que en la solucion de leosansan el solicitante puede entender por desconocimiento que esa es la ecuacion final y llevarlo a fallar la nota del trabajo por (obviamente flojo y no saber que dice ahí)

rayos! estoy oxidado en mate! nada más vi una ecuacion XD no habia notado la segunda

eferion

Código (c) [Seleccionar] Expandir

int main()
{
  P R O G R A M
  T E S T
}
solo te puedo decir que te fumaste algo raro y ya vencido! D:

Jajajajajaja... la idea es ofuscar con cierto estilo... la verdad es que solo me llevó unos 10 minutos conseguir ese código, tampoco es que me esmerase en exceso. Se puede conseguir código bastante más complicado de leer XDDDD

Si he entendido bien... lo que necesitas es guardar los resultados intermedios... cierto??

Si es así necesitarás crear tantos arrays como resultados intermedios quieras guardar ... lo suyo entonces es meter tu algoritmo en una función que admita dos arrays... uno que contiene los valores iniciales y otro para almacenar los resultados tras la permutación. Lo único que tienes que hacer entonces es ir pasando los arrays de forma ordenada para almacenar los resultados intermedios.

Código (c) [Seleccionar] Expandir


void permutacion( char* origen, char* destino );

// Lo de void main () lo pongo para escribir menos, al fin y al cabo es solo
// un ejemplo
void main( )
{
  char* inicio;
  char* permutacion1;
  char* permutacion2;
  char* permutacion3;
  char* final;

  // Inicializacion de los arrays
  // ...

  permutacion( inicio, permutacion1 );
  permutacion( permutacion1, permutacion2 );
  permutacion( permutacion2, permutacion3 );
  permutacion( permutacion3, final );

  // Liberación de recursos
  // ...
}

El polimorfismo es un concepto de lo más sencillo... bien es cierto que yo en la universidad veía a gente temblando solo de pensar en ello... pero yo creo que es más por el nombre que por otra cosa.

Tú tienes una jerarquía de clases, por ejemplo

Código [Seleccionar] Expandir


    A
    |
 -------
|       |
B       C

Donde A es la clase padre y B y C las hijas.

Si tú creas una clase B o una clase C ( es indiferente ) puedes gestionarlas como si fuesen directamente del tipo A:

Código (cpp) [Seleccionar] Expandir


std::vector< A* > lista;
lista.push_back( new B( ) );
lista.push_back( new C( ) );

Los cast a los padres son automáticos, no hace falta hacer un dynamic_cast... sin embargo moverte hacia abajo en la herencia sí requiere un dynamic_cast por motivos obvios... C es de tipo A, pero no es de tipo B:

Código (cpp) [Seleccionar] Expandir


A* clase = new C( );
C* c = dynamic_cast< C* >( clase ); // puntero valido
B* b = dynamic_cast< B* >( clase ); // puntero nulo, no es posible el cast

También es lógico pensar que si haces un cast al padre, los métodos propios de las clases hijas no son accesibles... no hasta que vuelvas a hacer un cast a la clase hija:

Código (cpp) [Seleccionar] Expandir


class A
{
 public:
   void func1( );
};

class B : public A
{
 public:
   void func2( );
};

void main( )
{
 A* puntero = new B( );
 puntero->func1( ); // ok
 puntero->func2( ); // error, A no tiene un miembro func2

 B* puntero2 = dynamic_cast< B* >( puntero );
 puntero2->func1( ); // ok
 puntero2->func2( ); // ok
}

La excepción a esta última norma son los métodos virtuales. Si tu sobrecargas un método virtual de una clase padre, se llamará al método de la clase hija SIEMPRE.

Código (cpp) [Seleccionar] Expandir


class A
{
 public:
   virtual void func1( )
   { std::cout << "A" << std::endl; }
};

class B : public A
{
 public:
   void func1( )
   { std::cout << "B" << std::endl; }
};

void main( )
{
 A* ptr1 = new A( );
 A* ptr2 = new B( );

 ptr1->func1( );
 ptr2->func1( );
}

La salida del programa será:

Código [Seleccionar] Expandir


A
B

Un aspecto importante del polimorfismo es que al moverse en la jerarquía los punteros no tienen por qué coincidir... esto se hace muy patente con herencia múltiple:

Código (cpp) [Seleccionar] Expandir


class A
{
 int dummy;
};

class B
{
 int dummy;
};

class C : public A, public B
{
 int dummy;
};

void main( )
{
 C* puntero1 = new C( );
 B* puntero2 = puntero1;
 A* puntero3 = puntero1;

 std::cout << "Puntero clase C: " << static_cast< void* >( puntero1 ) << std::endl;
 std::cout << "Puntero clase B: " << static_cast< void* >( puntero2 ) << std::endl;
 std::cout << "Puntero clase A: " << static_cast< void* >( puntero3 ) << std::endl;
}

Este comportamiento es debido a que C++ introduce unos identificadores en las clases para poder navegar por la jerarquía ( estos identificadores son los que usa dynamic_cast para saber si un cast es válido o no )

Y poco más que contar... ah sí, se me olvidaba... si en vez de puntero trabajas con la pila has de tener en cuenta que si haces un cast al padre vas a perder la herencia, ya que estarás llamando al constructor copia...

Código (cpp) [Seleccionar] Expandir


class A
{
 public:
   virtual void func1( )
   { std::cout << "A" << std::endl; }
};

class B : public A
{
 public:
   void func1( )
   { std::cout << "B" << std::endl; }
};

void main( )
{
 A clase1 = B( );
 B clase2 = B( );

 clase1.func1( );
 clase2.func1( );
}

Salida:

Código [Seleccionar] Expandir


A
B

Y esto es el polimorfismo... la gracia de esto es que es extensible... yo he puesto ejemplos con 3 clases... pero en el programa en el que trabajo el polimorfismo abarca unas 300 clases repartidas por una decena de niveles de jerarquía con herencias múltiples y demás guarrerías XD

[no es una librería]

mysql.h no es una librería, es un archivo de cabecera. Como te he comentado en mi anterior hilo: una solución es coger dichas dependencias ( en Windows son DLL ).

Además, el compilador de windows te obliga también a arrastrar una dependencia propia... pero no recuerdo el nombre. En google la encontrarás rápido.

una propuesta rápida... con algo más de tiempo se puede currar más

Código (c) [Seleccionar] Expandir


#include <stdio.h>

#define _ 369+35
#define M (100-(_
#define A *i)/24-i)*75
#define C +99*(_*i
#define R )/24+40*i==7869
#define O && (100-(_*i)/24-i>=1)

int main()
{
 int i=0;
 for(i=0;i<98;i++){
   if (M A C R O ){
     printf ("\nhombres=%d   mujeres=%d   ni\xA4os=%d\n",100-(_*i)/24-i,(_*i)/24,i);
   }
 }
 return 0;
}


segunda versión...

Código (c) [Seleccionar] Expandir


#include <stdio.h>

#define _ 369 H 35 X i
#define A U Y Y F Z X J X V W >=1 Z
#define B Y _ Z /24
#define C ;
#define D = 0 C
#define E } }
#define F 100 I B I G
#define G i
#define H +
#define I -
#define J 75 H 99
#define K printf
#define L B H 40 X G
#define M Z { K Y "\nhombres=%d   mujeres=%d   ni\xA4os=%d\n" ,F,B,G Z
#define N if
#define O for(
#define P int G
#define Q C G++ Z {
#define R D
#define S return 0
#define T C
#define U G < 98 Q N
#define V L == 7869 &&
#define W Y F
#define X *
#define Y (
#define Z )


int main()
{
 P R O G R A M
 T E S T
}

[eferion]

Como comentó eferion quería que el código quedará "ofuscado" para que no se diga que había resuelto el ejercicio. [/size]

Podías haberle puesto alguna macro de por medio... jejejeje

leosansan... la intención del foro es aprender, no hacer el trabajo...

En este caso concreto, el que copie esa ecuación no creo que sea capaz de explicarla... no porque sea complicada, sino porque copiar eso literal implica una falta total de conocimientos.

El que copia y no entiende suspende fijo... es ley de vida... llámalo selección natural.

por otro lado... wtf con la ecuación? XD de donde rayos sacaste?
por otros lado me suena a que es dependiente del valor final, ya que tienes 3 variables independientes y una sola ecuación

No es más que llevar, en el sentido literal y estricto, la ecuación de papel a código.

Se puede hacer de forma mucho más clara y comprensible, pero apostaría que lo ha hecho así precisamente para no hacerle la tarea a nadie.