C/Visual C - Lista simplemente enlazada

 
Vista:
sin imagen de perfil
Val: 10
Ha disminuido 1 puesto en C/Visual C (en relación al último mes)
Gráfica de C/Visual C

Lista simplemente enlazada

Publicado por julio leonel (6 intervenciones) el 01/05/2020 21:43:43
Buenas tardes, quisiera si alguien me puede orienter un poco sobre como resolver el punto c de este ejercicio, no se como eliminar los dos nodos en cuestion, dejo adjunto el codigo que hice donde resuelvo los dos primeros puntos,

Crear una lista de números enteros, diseñar las siguientes funciones:
a. Determinar cuál es el máximo elemento y mostrarlo por pantalla.
b. Determinar cuál es el mínimo elemento y mostrarlo por pantalla.
c. Eliminar de la lista el máximo y el mínimo, utilizando las funciones desarrolladas en los puntos anteriores.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#include <stdio.h>
#include <stdlib.h>
 
typedef struct nodo
{
 
    int dato;
    struct nodo * siguiente;
 
} Nodo;
 
Nodo * CrearNodo (int dato);
int InsertarInicio (Nodo **cabeza, int dato);
void ImprimirLista (Nodo * cabeza);
int MayorNodo (Nodo * cabeza);
int MenorNodo (Nodo * cabeza);
 
 
int main ()
{
 
    Nodo * cabeza = NULL;
    int mayor, menor;
 
    InsertarInicio(&cabeza,5);
    InsertarInicio(&cabeza,-23);
    InsertarInicio(&cabeza,25);
    InsertarInicio(&cabeza,14);
 
    printf("Lista de nodos con su contenido:\n");
    ImprimirLista(cabeza);
 
    printf("\n");
    mayor = MayorNodo (cabeza);
    printf("El nodo que contiene el dato mayor: %d", mayor);
 
    printf("\n");
    menor = MenorNodo (cabeza);
    printf("El nodo que contiene el dato menor: %d", menor);
 
    printf("\n");
 
    return 0;
}
 
Nodo * CrearNodo (int dato)
{
    Nodo * nuevo = NULL;
 
    nuevo = (Nodo *)malloc(sizeof(Nodo));
    if (nuevo == NULL)
    {
        printf("Me quede sin memoria");
        exit(-1);
    }
 
    nuevo->dato = dato;
    nuevo->siguiente = NULL;
 
}
 
int InsertarInicio (Nodo **cabeza, int dato)
{
 
    Nodo * nuevo = NULL;
    nuevo = CrearNodo(dato);
    if(nuevo != NULL)
    {
        nuevo->siguiente = *cabeza;
        *cabeza = nuevo;
    }
 
}
 
void ImprimirLista(Nodo * cabeza)
{
 
    Nodo * nAux = cabeza;
 
    while(nAux != NULL)
    {
 
        printf("Nodo: %d\n", nAux->dato);
        nAux = nAux ->siguiente;
    }
}
 
int MayorNodo (Nodo * cabeza){
 
    int mayor = cabeza->dato;
 
    while (cabeza != NULL)
    {
        if(cabeza->dato > mayor)
        {
            mayor = cabeza->dato;
        }
        cabeza = cabeza->siguiente;
    }
    return mayor;
}
 
int MenorNodo (Nodo * cabeza){
 
    int menor = cabeza->dato;
 
    while (cabeza != NULL)
    {
        if(cabeza->dato < menor)
        {
            menor = cabeza->dato;
        }
        cabeza = cabeza->siguiente;
    }
    return menor;
}
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Rodrigo
Val: 350
Bronce
Ha mantenido su posición en C/Visual C (en relación al último mes)
Gráfica de C/Visual C

Lista simplemente enlazada

Publicado por Rodrigo (119 intervenciones) el 01/05/2020 22:30:59
Recorre la lista y asignas y actualizas 2 punteros: puntero al nodo actual y puntero al nodo anterior al actual.
Cada vez que el valor dado no sea lo que quieres eliminar haces avanzar los 2 punteros.

Caso especial: el que quieres eliminar esta al inicio. En ese caso no haces esto de llevar 2 punteros, simplemente actualizas el puntero inicial de la lista.

Para los otros casos, una vez que llegue al nodo que quieres eliminar tendras, si lo has hecho bien esto:

1
.. -> puntero_anterior -> puntero_actual -> siguiente_al_actual -> ...

Para eliminar de la lista, bastaria actual la estructura apuntada por puntero anterior

1
puntero_anterior->siguiente = puntero_actual->siguiente
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
sin imagen de perfil
Val: 10
Ha disminuido 1 puesto en C/Visual C (en relación al último mes)
Gráfica de C/Visual C

Lista simplemente enlazada

Publicado por julio leonel (6 intervenciones) el 01/05/2020 23:08:22
Gracias por tu pronta respuesta, creo entender a que te referis ya qe vi algunos tutoriales de como hacerlo, pero como el punto dice "utilizando las funciones creadas en los puntos anteriores imagino que habra que usar las variables mayor y menor como minimo. que opinas? gracias!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Rodrigo
Val: 350
Bronce
Ha mantenido su posición en C/Visual C (en relación al último mes)
Gráfica de C/Visual C

Lista simplemente enlazada

Publicado por Rodrigo (119 intervenciones) el 02/05/2020 01:24:37
Usalas para obtener el valor que quieres eliminar.
No veo que otro uso podrias darles.

Otra opcion que no aporta mayor diferencia es que la funcion que retorna el mayor o menor no devuelvan el valor, sino un puntero a la estructura que tiene el valor.

Otra opcion es que en tu lista cada nodo no tenga solo 1 puntero hacia adelante, sino que tenga otro hacia atras, y la funcion que devuelve el mayor o menor al devolver un puntero, facilite el borrado.

Otra opcion aun, es teniendo un puntero al nodo a borrar, ponerse a copiar los datos de ahi en adelante hacia el nodo inmediatamente anterior y liberar el ultimo nodo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
sin imagen de perfil
Val: 10
Ha disminuido 1 puesto en C/Visual C (en relación al último mes)
Gráfica de C/Visual C

Lista simplemente enlazada

Publicado por julio leonel (6 intervenciones) el 10/05/2020 02:39:05
Bueno, para cerrar el tema pude dar con la solucion al codigo, seguramente a alguien le va a servir:

tiene las funciones: crear nodo, encolar, imprimir y eliminar. gracias por la colaboracion!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
#include <stdio.h>
#include <stdlib.h>
 
 
typedef struct nodo {
    int valor;
    struct nodo * sig;
} Nodo;
 
Nodo * newNodo(int);
void encolar(Nodo **, Nodo *);
void imprimir(Nodo *);
 
int MayorNodo (Nodo * );
int MenorNodo (Nodo * );
 
void eliminar(Nodo **, int);
 
int main() {
 
    Nodo * cabecera = NULL;
    int mayor = 0;
    int menor = 0;
 
    encolar(&cabecera, newNodo(-2));
    encolar(&cabecera, newNodo(4));
    encolar(&cabecera, newNodo(-6));
    encolar(&cabecera, newNodo(80));
    encolar(&cabecera, newNodo(-25));
    encolar(&cabecera, newNodo(-180));
 
    printf("Lista de nodos que componene la lista simplemente enlazada: \n");
    printf("-----------------------------------------------------------\n\n");
    imprimir(cabecera);
 
    printf("\n");
    printf("Maximo y Minimo elemento: \n");
    printf("--------------------------\n\n");
 
    mayor = MayorNodo (cabecera);
    printf("El nodo que contiene el dato mayor: %d\n", mayor);
 
    menor = MenorNodo (cabecera);
    printf("El nodo que contiene el dato menor: %d\n\n", menor);
 
    printf("Lista de nodos sin Maximo ni Minimo: \n");
    printf("-----------------------------------\n\n");
 
    eliminar(&cabecera, mayor);
    eliminar(&cabecera, menor);
    imprimir(cabecera);
}
 
Nodo * newNodo(int valor) {
 
    Nodo * aux = (Nodo *) malloc(sizeof(Nodo));
 
    if (aux == NULL) {
        printf("No hay memoria");
        exit(-1);
    }
 
    aux->valor = valor;
    aux->sig = NULL;
 
    return aux;
 
}
 
void encolar(Nodo ** cab, Nodo * nodo) {
 
    Nodo * aux = * cab;
 
    if ( *cab == NULL ) {
 
        *cab = nodo;
 
    } else {
 
        while( aux->sig != NULL ) {
 
            aux = aux->sig;
        }
        aux->sig = nodo;
    }
}
 
 
void imprimir(Nodo * cab) {
 
    while (cab != NULL ) {
 
        printf("Elemento: %d\n", *cab);
        cab = cab->sig;
 
    }
 
}
 
int MayorNodo (Nodo * cab)
{
 
    int mayor = cab->valor;
 
    while (cab != NULL)
    {
        if(cab->valor > mayor)
        {
            mayor = cab->valor;
        }
        cab = cab->sig;
    }
    return mayor;
}
 
int MenorNodo (Nodo * cab)
{
 
    int menor = cab->valor;
 
    while (cab != NULL)
    {
        if(cab->valor < menor)
        {
            menor = cab->valor;
        }
        cab = cab->sig;
    }
    return menor;
}
 
void eliminar(Nodo ** cab, int valor) {
 
    Nodo * ant = NULL;
    Nodo * act = NULL;
 
    if ( *cab == NULL ) {
 
        printf("La lista está vacia");
 
    } else {
 
        act = *cab;
        ant = *cab;
 
        while ( act != NULL && act->valor != valor ) {
 
            ant = act;
            act = act->sig;
 
        }
 
        if ( act == NULL ) {
 
            printf("El elemento no existe");
 
        } else if ( ant == act ) {
 
            *cab = act->sig;
            free(act);
 
        } else if ( act->valor == valor ) {
 
            ant->sig = act->sig;
            free(act);
 
        }
 
    }
 
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar