Mensajes

Perdon que interrumpa pero me gustaría saber como trabajas con ese atributo Estudiante* siguiente;

Como sabes cual es su siguiente si creas secuencialmente a los estudiantes A, B y C por ejemplo
estudiante A luego B, C o sea como es que A va a tener a B y B a C,
u otro caso al crear A, B, C este A tendrá a B y C, y B a C y C a NULL, bueno algo asi

Al parecer la función <insertar()> trabaja como si de una pila se tratase. Crea el primer estudiante A y hace <cabeza = A>. Luego crea al estudiante B pero en lugar de hacer:

Código (cpp) [Seleccionar] Expandir


A->siguiente = B;
Lo que hace es:

Código (cpp) [Seleccionar] Expandir


B->siguiente = cabeza; // en este caso cabeza es A
cabeza = B;
Por lo que si inserta los estudiantes A, B, C, D, la lista quedaría de la siguiente manera:

Código [Seleccionar] Expandir


D(cabeza)->C->B->A->NULL

cin.get();
return 0;

+1 para el <cin.get()> antes que usar <system("pause")>. 

Sólo he llegado hasta la clase <Estudiante> pero ya te puedo decir que el error (o al menos uno de ellos) está en el constructor.

Código (cpp) [Seleccionar] Expandir


class Estudiante{
    public:
        char codigo[5];
        string nombre;
        float poderado;
        Estudiante* siguiente;
       
        Estudiante( char* cod, string nom,float pode ){
            cod=codigo; // esta al reves
            nom =nombre; // esta al reves
            pode = poderado; // esta al reves
            siguiente = NULL;
        }
};
Cada objeto de la clase <Estudiante> tiene 4 datos miembros que son: <codigo>, <nombre>, <poderado> y <siguiente>. Los datos miembros no son <cod>, <nom> y <pode>. Estos últimos son los nombres que tendrán los parámetros del constructor mientras este se ejecuta. Estos nombres son temporales y en cada función pueden tener nombres distintos.

Aparte de eso cuidado al guardar el código. Para "copiar" cadenas de tipo C (o dicho de otra manera, arrays de <char>) debes usar métodos como <strcpy()> o más recomendable <strncpy()>. No vale con usar el operador de igual =.

[la dirección de memoria]

La función <scanf()> tiene que recibir como segundo parámetro la dirección de memoria de la variable donde quieres guardar el número en este caso.
Corrección:

Código (c) [Seleccionar] Expandir


int numero;
scanf("%d", &numero);
Otra forma de hacerlo para no crear la variable <numero> es guardarlo directamente en el parámetro <variable> así:

Código (c) [Seleccionar] Expandir


void modificar_variable(int *variable){
   printf("Introduzca el valor que desee que tenga la variable: ");
   scanf("%d", variable); // en este caso no se usa & porque lo estas pasando con un puntero
}

PD: Para futuras consultas coloca tus códigos entre etiquetas de Código GeSHi para facilitar la lectura a los demás. Suerte

[solo necesito saber que correcciones hago puntualmente, porque tus explicaciones no me quedan muy claras]

me has dejado mas perdido desde que arranque, me dices una cosa y luego otra , no logro entender que es lo que me quieres decir , solo necesito saber que correcciones hago puntualmente, porque tus explicaciones no me quedan muy claras

Pero si te digo cambia esto por esto y no entiendes por qué lo haces, es lo mismo que no avanzar. El objetivo es que entiendas el problema y seas capaz de encontrar la solución por ti mismo.
Te expliqué lo que era un grafo conexo y un grafo completo, te comenté las características de la matriz de adyacencia de un grafo conexo y de un grafo completo y te puse un pseudocódigo de cómo identificar un grafo conexo.
No me has entendido, no pasa nada. Prefiero hacer otro intento para explicártelo en vez de darte la solución. Me he dado cuenta de que yo te he puesto dos códigos en los que trato a la función <esConexo()> como una función de la clase principal y no de la clase <Matriz_de_adyacencia>, fallo mío. Igual eso te ha confundido más. Empiezo otra vez:

Aquí tienes un ejemplo de una matriz de adyacencia de un grafo conexo (ya que ninguna fila ni ninguna columna está compuesta únicamente de 0) y no dirigido (ya que la matriz es simétrica respecto a la diagonal principal):

Código [Seleccionar] Expandir


0  1  1  0  1
1  0  1  0  1
1  1  0  1  0
0  0  1  0  1
1  1  0  1  0
Y aquí tienes un ejemplo de una matriz de adyacencia de un grafo completo (ya que los únicos 0 están en la diagonal principal) y no dirigido (ya que la matriz es simétrica también respecto a la diagonal principal):

Código [Seleccionar] Expandir


0  1  1  1  1
1  0  1  1  1
1  1  0  1  1
1  1  1  0  1
1  1  1  1  0

Ahora vamos a ver cómo funciona tu función:

Código (java) [Seleccionar] Expandir


public boolean esConexoo(){
    boolean conexoo = true; // supones que el grafo es conexo
    for(int i = 0; i < matriz.length; i++){ // para cada fila i...
        for(int j = 0; j < matriz.length; j++){ // ...recorremos cada columna j y...
            if(i != j && matriz[i][j] == 0){ // ...si no estamos en la diagonal principal y esa casilla tiene un 0...
                conexoo = false; // ...el grafo deja de ser conexo
                break; // y dejamos de comprobar columnas para esa fila y pasamos a la siguiente fila
            }
        }
    }
    System.out.println(conexoo); // mostramos el resultado de la funcion
    return false; // y retornamos siempre false
}

Cuál es el problema de esta función? Que en cuanto se cumplen las dos condiciones del <if>, se determina que la matriz no es conexa y eso no es cierto. Esa función sería correcta si su función fuese determinar si un grafo es o no completo. Además como consejo personal y que es una buena práctica te recomiendo quitar el <System.out.println(conexoo)> porque es mejor no mostrar el resultado por pantalla dentro de la propia función. Es mejor retornar el resultado y aprovecharlo fuera de la función como indico aquí:

Código (java) [Seleccionar] Expandir


public static void main(String[] args){
    Matriz_de_adyacencia matriz = new Matriz_de_adyacencia[5][5];
    // dar valores a la matriz de adyacencia

    if(matriz.esConexo())
        System.out.println("El grafo es conexo");
    else
        System.out.println("El grafo no es conexo");
}

Te explico también porque es mejor no poner el mensaje dentro de la función. Imagina que tienes 50 grafos (es decir, 50 matrices) en un vector y quieres guardar en otro vector sólo los que son conexos. Tendrías que hacer un bucle para las 50 matrices y si se cumple que es conexo, guardarla en otro vector. Para realizar ese cálculo seguramente no te interese mostrar por pantalla cada resultado, no? Por eso es mejor no mostrar mensajes dentro de la función.
Y el último problema de tu función que he citado un poco más arriba es la última línea: <return false>. La "gracia" de la función es devolver <true> cuando el grafo es conexo y devolver <false> cuando no lo es. Si devuelves siempre <false> pues no tendrá mucho sentido. Entonces para devolver <true> o <false> dependiendo de lo que valga la variable <conexoo> lo que tienes que hacer es devolver la propia variable: <return conexoo>. Así cuando <conexoo> valga <true>, estarás retornando <true> y cuando <conexoo> valga <false>, estarás retornando <false>.

Para intentar dejarlo lo más claro posible te explico ahora el pseudocódigo que te puse anteriormente en otro mensaje:
PD: Lo he modificado un poco para hacerlo más fácil de entender aunque un poco menos eficiente. El original seguirá estando en el otro mensaje que puse anteriormente.

Código [Seleccionar] Expandir


matriz[N][N]
i := 0
conexo = true // suponemos que el grafo es conexo
mientras conexo and i < N // mientras siga siendo conexo y no se acaben las filas, para cada fila...
    conexo = false // ...suponemos que no es conexo y empezamos a comprobar cada columna de esa fila...
    j := 0
    mientras !conexo and j < N // ...mientras siga sin ser conexo y no se acaben las columnas...
        conexo = (matriz[i][j] != 0) // ...si la casilla vale 0, sigue sin ser conexo (false) pero si es distinto de 0, vale true para pasar a la siguiente fila directamente
        j := j + 1
    fin mientras
    i := i + 1
fin mientras
return conexo // ...cuando acabas de recorrer toda la matriz devuelves el valor de <conexo> ya sea true o false

Espero que con esta explicación te haya quedado un poco más claro. Si tienes alguna duda sobre una parte específica de todo lo explicado puedes citar esa parte y exponer tu duda para poder centrarme en aclararte esa parte.

[completo]

Primero de todo te recomiendo quitar el mensaje de la función <esConexo()>. Es mejor que la función sólo retorne un resultado y luego decidir tú si mostrarlo por pantalla o no. Respecto a tu duda de true/false. Piensa que vas a utilizar esta función:

Código (java) [Seleccionar] Expandir


public static void main(String[] args){
    Matriz_de_adyacencia matriz = new Matriz_de_adyacencia[5][5];
    // dar valores a la matriz de adyacencia

    if(esConexo(matriz))
        System.out.println("El grafo es conexo");
    else
        System.out.println("El grafo no es conexo");
}
Entonces si preguntamos si es conexo, la función tendrá que devolver <true> si sí que es conexo y false si no es cierto que sea conexo. En tu caso estás devolviendo siempre <false> porque has puesto <return false>.

Además de todo lo anterior, me parece que esa función que has implementado no es del todo correcta. En el momento que una casilla es 0, se cambia el valor de <conexo> a <false> y con que una casilla sea 0 el grafo no deja de ser conexo. Esa función sería correcta si se encargara de determinar si el grafo es completo, no conexo.

Yo crearía directamente una función:

Código (java) [Seleccionar] Expandir


public static boolean esConexo(matrizDeAdyacencia){
    // compruebas si es conexo
    // retornas el resultado
}
Y la forma de hacerlo depende como te he dicho antes de si el grafo es dirigido o no. Si sabemos como precondición del ejercicio que el grafo no es dirigido bastaría con comprobar filas o columnas (una de las dos). Si el grafo es dirigido o podría ser dirigido, entonces debemos comprobar filas y columnas. Te pongo una forma de hacerlo en pseudocódigo para grafos no dirigidos. Luego te queda que lo implementes en java.

Código [Seleccionar] Expandir


matriz[N][N]
i := 0
mientras conexo and i < N
    conexo = (matriz[i][0] != 0)
    j := 1
    mientras !conexo and j < N
        conexo = (matriz[i][j] != 0)
        j := j + 1
    fin mientras
    i := i + 1
fin mientras

Voy a comentarte la parte teórica de los grafos y cómo se relaciona esto con la matriz de adyacencia del correspondiente grafo. Primero 3 definiciones:

• Matriz de adyacencia: matriz en la que para cada i y para cada j, M[j] = 0 si no existe un camino del vértice i al vértice j y M[j] = 1 si sí que existe un camino del vértice i al vértice j.
  
  • Grafo conexo: grafo que para todo vértice Vi, existe j != i tal que Vi está conectado con Vj. Dicho de otra manera, un grafo conexo no tiene ningún vértice aislado.
    
  • Grafo completo: grafo que tiene todos los vértices conectados con todos los vértices. Dicho de otra manera puedes ir directamente desde cualquier vértice a cualquier otro vértice.
    Ahora viene la relación de estos grafos con su matriz de adyacencia:
    
  • Un grafo es conexo si en su matriz de adyacencia no existe ningún índice <i> tal que la fila <i> y la columna <i> estén compuestas únicamente por 0 (ambas al mismo tiempo, fila y columna). En grafos no dirigidos bastaría con comprobar una de las dos, la fila o la columna.
    
  • Un grafo es completo si en su matriz de adyacencia sólo existen 0 en la diagonal principal.
    
    Con todos estos datos creo que ya puedes implementarlo tú en tu programa. Espero que todas las explicaciones sean claras y sobre todo, correctas. Suerte

Siento ser el que te informe de que nadie te va a hacer el ejercicio. Este foro no funciona así, no podemos estar haciendo tareas a todos los que las piden.
Si quieres yo te animo a que lo intentes tú y que mires libros, pdfs, páginas sobre el lenguaje,... Cuando tengas un problema específico, muestra tus avances (todo el código o la parte que creas conveniente) y será entonces cuando recibas ayuda. Suerte

Si tu matriz tiene por ejemplo un tamaño de 5x5, los índices van de 0 a 4. Por lo que en la condición del while es: p < a.length (sobra el =).