Question

可能重复：
  Reverse a singly linked list
  reverse a linked list?

我一直试图弄清楚如何以相反的顺序显示数字链接列表的内容。我尝试改变节点，我无法弄明白。它是一个单独的链表。我想过实现一个堆栈。有更简单的方法吗？继承我的代码。我需要函数在头文件中，它将在main.cpp中实现。我今天和昨天都在努力工作几个小时，这真的是最后的选择。我有失败算法的页面。以及谷歌搜索页面，但似乎没有任何作用。如果它使用Microsoft Visual Studio 2010（不是我的第一选择）有所作为。我提出的代码没有我一直在尝试的，因为它都失败了，通常会产生错误。

#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

Answer 1

你可以这样做：

1）找到最后一个节点并打印出来。

2）遍历链接列表，找到上次打印节点作为下一个节点的节点，然后打印出来。

3）转到步骤2，直到没有要打印的节点。

Answer 2

递归解决方案应该

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;
    }
}

用法：

ReversedList = Reverse(head, NULL);

通常，您可以将Node类视为链接列表，不需要单独的类。

Answer 3

有两种通用方法可以反转单链表。

一种是更改指针，使尾节点成为头节点，反之亦然，而中间的所有指针都是另一种方式。每个数据项都保持与以前相同的节点。

另一种方法是保持节点的结构完整，但移动数据。

因为您将函数命名为reverseListContents，我怀疑您正在尝试执行后者。这很难做到。

可以通过简单的循环来反转列表的结构（第一种方法）。

你有没有见过有人翻过一堆重叠的扑克牌，放在桌子上，翻过最后一张？这与指针改变方向的方式类似。

非常仔细地观看此YouTube视频，并在C ++中实现相同的功能：

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

不要忘记更新交换节点的head和tail指针。

Answer 4

我不会为您编写详细代码，但会给出伪代码：

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);
}

请注意，这使用递归，这对大型链表不利。如果你有一个很大的链表并希望使用循环，那么你可以使用堆栈来存储节点，然后再打印它们。

如何反转链表C ++

4 个答案: