Dev - C++ - Eliminar Ultimo Ingresado en Cola Dimaica en C

 
Vista:
sin imagen de perfil
Val: 89
Ha mantenido su posición en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Eliminar Ultimo Ingresado en Cola Dimaica en C

Publicado por Patricio (25 intervenciones) el 10/04/2019 19:45:19
Buenas!. Tengo el siguiente problema con el codigo.
Estoy tratando de crear una nueva funcion llamada extraer_ultimo() que funciona similar a extraer, el cual extrae el primer digito ingresado a la cola dinamica, pues el primero en entrar es el ultimo en salir.
Mi pregunta es como puedo arreglar el extraer_ultimo de tal forma que el ultimo en ser ingresado sea extraido.
Intente hacerlo, pero ando perdido en como hacerlo.

Como modificar el codigo para remover el ultimo dato ingresado a la cola dinamica, en este caso el numero 300.
De lo que he entendido es que necesito un nodo *anterior y hacer los punteros para hacer nuevo->anterior=X o algo.
NOTA: EL programa funciona perfectamente a excepcion de extraer_ultimo()

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
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
 
struct nodo {
    int info;
    struct nodo *sig;
    //struct nodo *anterior; tengo entendido que debo hacer esto tambien.
};
 
struct nodo *raiz=NULL;
struct nodo *ultimo=NULL;
//En solemne se entregan el nodo y punteros y van a preguntar por funciones y main, con case posiblemente
// struct nodo *primero=NULL, *nuevo=NULL, agregado del ejemplo pizarra
int vacia()
{
    if (raiz == NULL)
        return 1;
    else
        return 0;
}
 
void insertar(int x)
{
	struct nodo *nuevo;
    nuevo=(struct nodo*)malloc(sizeof(struct nodo)); // nuevo tiene la direccion de los datos
    //lo que recibe el puntero es la direccion.
	printf(" \n\t\t\t La direccion del nuevo nodo es %i --> ", nuevo); //si colocamos *nuevo es para ver el valor que contiene, pero solo si contiene 1 dato
	//de lo contrario se debe imprimir como puntero apuntando a 
    nuevo->info=x; // el puntero esta apuntando a la estructura, info es un elemento numerico y lo estoy asignando a la estructura. 
    //nuevo apunta a info le asigna un valor X q recibi como parametro
	// la funcion pide x, y x es la parte de info=x.
    nuevo->sig=NULL; //nuevo no apunta a ninguno
    if (vacia()) //va a ver si raiz = null. al retornar 1 estamos diciendo verdadero
    {
        raiz = nuevo; //a raiz le damos el valor denuevo y ultimo tb vale nuevo pues el primero y el ultimo son el mismo si hay solo 1 persona en cola
        ultimo = nuevo;
    }
    else //la lista no esta vacia.
    {
        ultimo->sig = nuevo; //ultimo siempre se actualiza a la "nuevo"  direccion, ultimo apunta a siguiente pa enlazar. 
		//Siguiente contiene la "Direccion" de nuevo
        ultimo = nuevo; // ahora ultimo es la direccion nuevo.
    }
}
//Para extraer el ultimo necesitamos un puntero auxuliar.
 
int extraer() //al extraer la cola esta empieza a desaparecer
{
    if (!vacia()) //retorna un cero, Falso en informatica
    {
        int informacion = raiz->info; //declaro una variable informacion, raiz es el primero y vamos a decir que 
        struct nodo *primero = raiz; //declaramos un puntero llamado primero y es igual a raiz. Toy dejando la direccion de raiz en primero
 
		// el primero que entra es el primero que sale, por eso es primero
        if (raiz == ultimo) //cuando solo hay 1 persona o elemento
        {
            raiz = NULL; // la cosa es extraer, saque al ultimo que quedaba, por eso raiz = null
            ultimo = NULL; //ultimo tb es null por lo mismo
        }
        else
        {
        	primero = raiz; //se pierde el valor de raiz, auxuliar para no perder raiz
            raiz = raiz->sig; //estamos dejando en raiz la direccion del siguiente nodo debido que raiz pasa a ser la sgte persona
        }
        free(primero); //liberando el primer nodo y desaparece, el que se guardo con malloc, el que iva al frente de la fila se va
        return informacion;
    }
    else
        return -1;//muestra en pantalla -1
}
//Para extraer el ultimo tengo entendido que necesito un puntero auxuliar y otro final.
int extraer_ultimo()
{
    if (!vacia())
    {
        int informacion2 = ultimo->info;
        struct nodo2 *final = ultimo;
 
        if (raiz == ultimo) //cuando solo hay 1 persona o elemento
        {
            raiz = NULL;
            ultimo = NULL;
        }
        else
        {
        	final = ultimo;
            ultimo = ultimo->anterior//MI IDEA ES CREAR UN PUNTERO LLAMADO ANTERIOR o algo asi para hacerlo
        }
        free(final); //liberando final en vez de primero al compararlo con extraer solo.
        return informacion;
    }
    else
        return -1;
}
void imprimir()
{
    struct nodo *recorre = raiz; //declarar puntero recorreo o Aux con la direccion de raiz
    // NO estamos eliminando memoria, la lista queda igual
    printf("\n\t Listado de todos los elementos que restan en la cola. DATO: %i\n", raiz);//imprimo la direccion de raiz
    while (recorre != NULL) //
    {
        printf("\n\t %i  ", recorre->info); //se imprime el valor, ojo, es %i pq es un entero
        recorre = recorre->sig;
    }
    printf("\n");
}
 
int main()
{
	printf ("\n\t Lista tipo cola en Memoria Dinamica "); // estan en cualquier parte de la memoria, no son contiguos 
	printf ("\n\t  Insertar los siguientes valores:  5,10,50,70,120,300 ");
    insertar(5);
    insertar(10);
    insertar(50);
    insertar(70);
    insertar(120);
    insertar(300);
    imprimir();
    printf("\n\t Extraemos uno de la cola  --> %i, (se desplaza una posicion )"); // 5 fue extraido por lo tanto no sera mostrado
    printf ("\n\n      Se imprime el dato del primer nodo de la cola --> %i : \n", extraer());
    imprimir();
	printf ("\n\n      Removiendo Ultimo dato de nodo de la cola --> %i : \n", extraer_ultimo());
	imprimir();// el numero 300 debio ser removido
    getch();
 
    return 0;
}
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
1
Responder
sin imagen de perfil
Val: 89
Ha mantenido su posición en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Eliminar Ultimo Ingresado en Cola Dimaica en C

Publicado por Patricio (25 intervenciones) el 11/04/2019 01:02:13
1
2
3
4
5
6
7
8
9
10
11
12
13
void elim_ultimo(){
	struct nodo *recorre = raiz;
	struct nodo *aux;
    while (recorre != NULL)
    {
    	aux = recorre->sig;
    	if(aux->sig == NULL){
    		recorre->sig = NULL;
    		free(aux);
		}
        recorre = recorre->sig;
    }
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
2
Comentar