Cómo invertir la lista enlazada C ++ [duplicado]

Posible duplicado:
Invertir una lista enlazada individualmente
invertir una lista enlazada?

He estado tratando de descubrir cómo mostrar el contenido de una lista vinculada de números en orden inverso. Intenté cambiar los nodos y no puedo resolverlo. es una lista enlazada individualmente. Pensé en implementar una pila. ¿Hay una manera más sencilla? aquí está mi código. Necesito que la función esté en el archivo de encabezado y se implementará en main.cpp. Lo he estado intentando durante horas hoy y ayer y este es realmente un último recurso. Tengo páginas de notas de algoritmos fallidos. así como páginas de búsquedas de Google, pero nada parece funcionar. si marca la diferencia, estoy usando Microsoft Visual Studio 2010 (no es mi primera opción). el código que presenté no tiene lo que he estado intentando, ya que todo falló horriblemente y generalmente produjo errores.

#ifndef _LINKEDLIST_H
#define _LINKEDLIST_H
#include <iostream>
#include <string>
#include <stack>

#include "Node.h"

using namespace std;
using namespace bruno;

namespace bruno
{
template< typename T>
class LinkedList
{
    private:        Node<T>  * head;
                    Node<T>  * tail;
                    int numberOfNodes;

    public:         LinkedList();
                    ~LinkedList();

                    int length(); 

                    Node<T>  * getHead() { return head; };
                    Node<T>  * getTail() { return tail; };

                    void insertInFront(T d);
                    void insertInBack(T d);

                    static void listContents( Node<T> * head);  

                    static T  sum( Node<T>  * head);    //     assume head is not NULL at call

                    static void  increment( Node<T>  * head, T val); 
                    static void reverseListContents( Node<T> * head, Node<T> * tail, int n );
};


   template< typename T >
   LinkedList<T>::LinkedList()
   {
       head = tail = NULL;
       numberOfNodes = 0;
   }


   template< typename T >
   LinkedList<T>::~LinkedList()
   {
   }



   template< typename T >
   int LinkedList<T>::length()
   { 
       return numberOfNodes; 
   }



   template< typename T >
   void LinkedList<T>::insertInFront(T d)
   {
        Node<T> * p =  new Node<T>;
        p->data  =  d;
        p->next  = head;
        head = p;
        if ( tail == NULL )
            tail = p;
        numberOfNodes++;
   }




   template< typename T >
   void LinkedList<T>::insertInBack(T d)
   {
        if ( tail == NULL )
            insertInFront(d);
        else {
                tail->next = new Node<T>;
                tail = tail->next;
                tail -> data = d;
                tail -> next = NULL;
        }
        numberOfNodes++;

   }


   template< typename T >                       
   void LinkedList<T>::listContents(Node<T> * head)
   {
        if (head == NULL)  return;
        else
        {      cout <<  head->data  << "  ->  ";
               listContents( head -> next );
        }
   }




   template< typename T >                       
   T LinkedList<T>::sum(Node<T> * head)
   {
        if ( (head->next) == NULL )  return  head->data;
        else
             return  ( head->data    +   sum( head->next ) );
   }




   template< typename T >                       
   void LinkedList<T>::increment(Node<T> * head, T  val)
   {
        if ( head == NULL )  return;
        else
        {
            head->data += val;                    // add val to current data value
            increment( head->next, val );
        }

   }

   template< typename T >
   void LinkedList<T>::reverseListContents (Node<T> * head, Node<T> * tail, int n)
   {
       //clueless!


   }



}

#endif 

preguntado el 10 de marzo de 12 a las 05:03

no necesitas una pila. puedes hacerlo en el lugar. intente buscar en Google "lista de enlaces individuales inversos en su lugar" -

Si esto es tarea, agregue el homework etiqueta. Sin el homework etiqueta, obtendrá un montón de respuestas irrelevantes. -

Bienvenido a StackOverflow. Utilice la búsqueda (o google) antes de publicar nuevas preguntas; muchos ya han sido preguntados y respondidos. -

Si esto no es deberes, no escribas tu propia estructura de datos de lista. Usar std:list. -

^^^ "No hagas eso, usa std::xxx" son las respuestas que normalmente obtiene cuando se olvida de incluir el homework etiqueta. :-)-

4 Respuestas

Puedes hacerlo de esta manera:

1) Encuentra el último nodo e imprímelo.

2) Recorra la lista enlazada para encontrar el nodo que tiene el último nodo que imprimió como su próximo nodo e imprímalo.

3) Vaya al paso 2 hasta que no haya más nodos para imprimir.

respondido 10 mar '12, 06:03

gran algoritmo! gracias por eso. mucha más ayuda que las personas que publican código y no explican, o código que en realidad no hace lo que quiero. - user1260607

La solución recursiva debería hacer

Node * Reverse( Node * ptr , Node * previous)
{
    Node * temp;
    if(ptr->next == NULL) {
        ptr->next = previous;
        return ptr;
    } else {
        temp = Reverse(ptr->next, ptr);
        ptr->next = previous;
        return temp;
    }
}

uso:

ReversedList = Reverse(head, NULL);

Por lo general, puede tratar su clase de nodo como una lista vinculada, no necesita una clase separada.

respondido 10 mar '12, 05:03

Hay dos formas generales de revertir una lista enlazada individualmente.

Una es cambiar los punteros para que el nodo de cola se convierta en el nodo de cabeza y viceversa, y todos los punteros intermedios vayan en la otra dirección. Cada elemento de datos permanece en el mismo nodo que antes.

El otro enfoque es mantener intacta la estructura de los nodos, pero mover los datos.

Porque nombraste tu función reverseListContents, sospecho que estás tratando de hacer lo último. Esto es más difícil de hacer.

La inversión de la estructura de la lista (primer enfoque) se puede hacer con un bucle simple.

¿Alguna vez has visto a alguien voltear una cadena de naipes superpuestos, colocados sobre una mesa, volteando el último? Eso es similar a cómo los punteros cambian de dirección.

Mire este video de YouTube con mucho cuidado e implemente lo mismo en C++:

http://www.youtube.com/watch?v=yW1Ch7eo4g4

No olvides actualizar tu head y tail punteros, que intercambian nodos.

respondido 10 mar '12, 05:03

ese primer método funcionaría, si no fuera una lista enlazada individualmente... - user1260607

No escribiré un código detallado para usted, pero le daré un pseudocódigo:

void printLinkedListReverseOrder(NodeType * ptr)
{
    // Be defensive, Don't assume proper input. Validate it first
    if(NULL == ptr) return;

    // If this node is not the last, print it's next node first
    if(NULL != ptr->next) printLinkedListReverseOrder(ptr->next);

    // When all nodes after it is printed, then print the node itself
    print(ptr);
}

Tenga en cuenta que esto usa recursividad, lo cual no es bueno para una gran lista enlazada. Si tiene una gran lista enlazada y desea usar un bucle, puede usar una pila para almacenar los nodos antes de imprimirlos.

respondido 10 mar '12, 06:03

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.