elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado:


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Eliminar ultimo elemento de la lista enlazada C++
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Eliminar ultimo elemento de la lista enlazada C++  (Leído 578 veces)
nurnain

Desconectado Desconectado

Mensajes: 1


Ver Perfil
Eliminar ultimo elemento de la lista enlazada C++
« en: 24 Enero 2020, 13:53 »

//Hola!! Necesito ayuda con este enunciado pues la verdad no se como lograr eliminar el ultimo elemento de la lista espero que me puedan ayudar :(, si me pueden decir que debo hacer o me podrían elaborar el código seria genial.

//Borrar ultimo elemento de la Lista enlazada en c++



#include <stdlib.h>
#include <stdio.h>
#define nuevo_nodo (struct nodo *)malloc(sizeof(struct nodo))
struct nodo {
   int info; struct nodo *sig;
} *c, *p, *q;
int mostrar_nodo(struct nodo *s) {
   printf("%d",s->info); return 0;
}
int mostrar_lista(struct nodo *r){
   printf("{ "); mostrar_nodo(r);
   while (r->sig!=NULL){
   printf(", "); mostrar_nodo(r->p); r=r ->sig;
   }
   
   printf(" }"); return 0;
}
int main() {         c = nuevo_nodo;
   c->info=36;      p=nuevo_nodo;   c->sig=p;
   p->info=18;      q=nuevo_nodo;   p->sig=q;
   q->info=45;      p=nuevo_nodo;   q->sig=p;
   p->info=123;   q=nuevo_nodo;   p->sig=q;
   q->info=9;      p=nuevo_nodo;   q->sig=p;
   p->info=54;                  p->sig=NULL;
   
   printf("\n\n   "); mostrar_lista(c);



system ("pause");

}


En línea

NEBIRE


Desconectado Desconectado

Mensajes: 2.339


Ver Perfil
Re: Eliminar ultimo elemento de la lista enlazada C++
« Respuesta #1 en: 25 Enero 2020, 17:22 »

La eliminación del último nodo, suele ser la eliminación más sencilla (detrás de eliminar el último cuando además es el único).

Piensa en forma manual e imagina que fuera una cadena (si, con eslabones metálicos), cada vez que quieras quitar un eslabón piensa cuantas manos necesitas para agarrar la parte que interesa... considera todos los pasos que hay que hacer y el orden correcto de los mismos.

Para eliminar un nodo en cualquier posición, debes posicionarte en la posición previa, para establecer su nodo siguiente a nulo... si además está intermedio (antes establecer la referencia siguiente de él a nulo), se requiere tener acceso al siguiente a eliminar... para luego poder volver a conectar la 'cadena rota' (ha quedado rota por culpa de él) por el nodo eliminado...

En la lista enlazada, hay que pensar además si está doble o simplemente enlazada. El caso más sencillo es empezar con listas simplemente enlazadas, que e slo que se asume mirando tu código...

* Nota: Aquí se supone a Raiz como un nodo oculto, que no contabiliza en la lista, cuando no conviene que sea el caso, puede considerarse como nulo y entenderse raiz.siguiente como el nodo raiz.
* Nota: Que si no se mantiene una cuenta de los nodos que existen en la lista, cambia ligeramente, pués no hay forma de saber a priori si un nodo es el último, salvo llegando a él desde la raíz, o un 'nodo actual', es decir un sobrecoste en eficiencia a causa del recorrido, que siempre deberá hacerse y que por tanto es desconocido.
Código:
funcion EliminarNodo(x)
    Si numNodos = 0 salir   // la lista está vacía...

    Si (x = numNodos) //equivale a eliminar el último
        Si (x = 0)  // además es el único
               raiz.Siguiente = nulo
        sino
            p = raiz
            n = p.siguiente
            Hacer  mientras (n.siguiente <> Nulo)
                p = n
                n = n.siguiente      
            repetir
            n = nulo
            p.siguiente = nulo
        fin si
    Sino   // en estos casos, al eliminar uno exige conectar los que vienen detrás con el previo.
        Si (x = 0) // elimina el primero, pero hay más detrás
            Si numNodos = 1
                raiz.siguiente = nulo  // lista vacía
            SiNo
                n = raiz.siguiente
                raiz.siguiente = n.siguiente  // el nodo en raíz será el que antes era el 2º.
                n.siguiente = nulo // eliminar la referencia a la que apunta el que se pretende eliminar
                n = nulo   // se elimina el que antes era el 1º
            fin si    
        sino
            y = 0
            n = raiz.siguiente
            hacer mientras (y < x)
                 y +=1
                 p = n   // mantener el previo (agarrar con una 'mano' el eslabón previo al que se desea eliminar)
                 n = n.siguiente
            siguiente
            //(a estas alturas) sabemos que no es el último, por eso esto no
dará error
            n = n.siguiente  // agarrar con 'otra mano' al eslabón siguiente al que se quiere eliminar
            p.siguiente.siguiente = nulo  // eliminar el enlace del eliminado al siguiente
            p.siguiente = nulo // eliminar el deseado
            p.siguiente = n  // atar la cadena por los dos eslabones sueltos
        fin si
    fin si

    numNodos -= 1 //la cuenta hay que actualizarla adecuadamente siempre que se eliminen o añadan nodos.
fin funcion

* Nota: Que se puede optimizar, pero es más sencillo entender cuando no hay 'abreviaciones y omisiones por optimización', cuando el código es canónico, es más fácil seguir los pasos dados...

* Nota: Que aunque la función elimina por índicie, si se precisa puede ocultarse (dicha función, haciéndola privada) y crearse exprofeso funciones para eliminar el último nodo, etc...
Código:
// Como se ve, simplemente se llama al último, por el índice que tiene.
funcion EliminarUltimo
    EliminarNodo(numNodos-1)
Fin Funcion

Funcion EliminarPrimero
    EliminarNodo(0)
Fin Funcion

...

* Nota: También como la simple adicción a la lista de un valor que mantenga la 'cantidad' total de nodos (aquí llamada numNodos), simplifica bastante las cosas y mantener actualizado dicho valor no es complicado.
Cuando:
--- Se crea la lista: numNodos = 0
--- Se añade un nodo: numNodos += 1
--- Se elimina un nodo: numNodos -= 1
--- Se vacía/elimina toda la lista: numNodos = 0
Igualmente resulta útil por tanto proveer una propiedad de lectura de la cantidad de nodos...

* Nota: Por último que también suele ser muy útil disponer de un nodo 'Actual' (comporta nodo e índice 'NodoActual' e 'IndiceActual'), que facilita el acceso, así si el que se quiere eliminar está antes del actual se accede desde raíz, si está después del actual, a través del actual... lo mismo al añadir cuando puede elegirse una posición arbitraria. Actual es aún más útil cuando la lista es doblemente enlazada, pues ya hay 4 puntos entre los que elegir iniciar el acceso (desde el primero --->, desde el actual <---, desde el actual --->, desde el último <---- ). Por lo mismo, que la 'cantidad' de nodos, se hace publico como propiedad de lectura, en tal caso también interesa tener público 'Actual', que en este caso puede además ser también de escritura. Así el acceso a un nodo de la lista es más eficiente (casi siempre) al coste de añadir código extra para mantener con vigencia el nodo actual y su índice (dicho índice puede variar según la posición que tenga cuando se añadan o eliminen nodos anteriores a dicha posición. El coste más caro de eliminar o añadir es cuando se elimina precisamente el actual, pero se contrarresta con el coste de acceso al mismo, que es tal caso es 0, por ser conocido...

Para pasarlo a código, te tocará leerlo y entenderlo... algo de esfuerzo por tu parte tendrás que poner, ¿no?.


« Última modificación: 25 Enero 2020, 17:32 por NEBIRE » En línea

dijsktra

Desconectado Desconectado

Mensajes: 100


Mr Edsger Dijsktra (Tribute to)


Ver Perfil
Re: Eliminar ultimo elemento de la lista enlazada C++
« Respuesta #2 en: 21 Marzo 2020, 01:48 »

Brevemente, amigo.
Las estructuras de datos, en tu caso una lista simplemente enlazda, solo exiten para emular algun tipo asbtracto de datos (pilas, colas, dobles colas ... e incluso listas como tipo abstracto, no como estructura de datos en si).


EDIT: No se hacer en C++. Te proporcion en C


Para tu caso he elegio la emulación parcial de una doble cola. Faltan unas operaciones, como push_front, pop_front , que por espacio omito. practica tu.

TE podra serviar para lo que quieres.


La operacion por la que estas interesado es

Código
  1. typedef struct _node
  2. {
  3.  int info;
  4.  struct _node *next;
  5. } *node;
  6.  
  7. typedef struct _deque
  8. {
  9.  node first;
  10.  node last;
  11. }deque;
  12.  
  13.  
  14. void pop_back(deque *dq)
  15. {
  16.  assert(dq->last != NULL);
  17.  node prev,act;
  18.  for(prev=NULL,act=dq->first;act!=dq->last;act=act->next)
  19.    prev=act;
  20.  dq->last = prev;
  21.  if (prev) prev->next=NULL;
  22.  else dq->first=dq->last=NULL;
  23.  free(act);
  24. }
  25.  
  26.  

Y aqui una exhibicion del programa ejecutable


 
Código
  1.  
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <assert.h>
  5.  
  6. typedef struct _node
  7. {
  8.  int info;
  9.  struct _node *next;
  10. } *node;
  11.  
  12. typedef struct _deque
  13. {
  14.  node first;
  15.  node last;
  16. }deque;
  17.  
  18.  
  19. int print(const deque *dq){
  20.  printf("[ ");
  21.  node p;
  22.  for(p=dq->first;p!=NULL ; p=p->next)
  23.    printf("%d ",p->info);
  24.  printf(" ]");
  25.  printf("\n");
  26.  return 0;
  27. }
  28.  
  29. void create(deque *dq)
  30. {
  31.  dq->first = dq->last = NULL ;
  32.  return;
  33. }
  34.  
  35. void push_back(deque *dq,int info)
  36. {
  37.  node n;
  38.  if ((n = (node)malloc(sizeof(struct _node)))==NULL)
  39.    {
  40.      perror("malloc");
  41.      exit(-1);
  42.    }
  43.  n->info = info;
  44.  n->next = NULL;
  45.  node prev;
  46.  
  47.  if (dq->last) dq->last->next = n ;
  48.  dq->last= n;
  49.  if (!dq->first) dq->first=dq->last;
  50.  return;
  51. }
  52.  
  53.  
  54.  
  55. int top(const deque *dq)
  56. {
  57.  assert(dq->last != NULL);
  58.  return dq->last->info;
  59. }
  60.  
  61. void pop_back(deque *dq)
  62. {
  63.  assert(dq->last != NULL);
  64.  node prev,act;
  65.  for(prev=NULL,act=dq->first;act!=dq->last;act=act->next)
  66.    prev=act;
  67.  dq->last = prev;
  68.  if (prev) prev->next=NULL;
  69.  else dq->first=dq->last=NULL;
  70.  free(act);
  71. }
  72.  
  73.  
  74. int empty(const deque *dq)
  75. {
  76.  return dq->first == NULL;
  77. }
  78.  
  79. void destroy(deque *dq)
  80. {
  81.  node p,aux;
  82.  for(p=dq->first ;p;p=aux)
  83.    {
  84.      aux=p->next;
  85.      free(p);
  86.    }
  87.  return ;
  88. }
  89.  
  90. int main(int argc, char *args[] )
  91. {
  92.  int N=10;
  93.  deque dq;
  94.  create(&dq);
  95.  for(int n=0;n<N;n++)
  96.    push_back(&dq,n);
  97.  for( ; !empty(&dq); pop_back(&dq)) print(&dq);
  98.  print(&dq);
  99.  destroy(&dq);
  100.  return 0;
  101.  
  102. }
  103.  
  104.  

Y una preuba de ejecucion

Código:
[ 0 1 2 3 4 5 6 7 8 9  ]
[ 0 1 2 3 4 5 6 7 8  ]
[ 0 1 2 3 4 5 6 7  ]
[ 0 1 2 3 4 5 6  ]
[ 0 1 2 3 4 5  ]
[ 0 1 2 3 4  ]
[ 0 1 2 3  ]
[ 0 1 2  ]
[ 0 1  ]
[ 0  ]
[  ]
« Última modificación: 21 Marzo 2020, 08:31 por dijsktra » En línea

Si la depuración es el proceso de eliminar fallos en el software, entonces programar debe ser el proceso de ponerlos dentro. (Edsger Dijsktra)
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines