Реверсирование связанного списка в Java, рекурсивно

Я уже некоторое время работает над Java-проектом для класса. Это реализация связанного списка (здесь называется AddressList, содержащий простые узлы, называемые ListNode). Уловка состоит в том, что все должно быть сделано с помощью рекурсивных алгоритмов. Я смог сделать все, что угодно, без одного метода: public AddressList reverse()

ListNode:

public class ListNode{
  public String data;
  public ListNode next;
}

Сейчас моя функция reverse просто вызывает вспомогательную функцию, которая принимает аргумент, чтобы разрешить рекурсию.

public AddressList reverse(){
  return new AddressList(this.reverse(this.head));
}

С моей вспомогательной функцией, имеющей подпись private ListNode reverse(ListNode current).

На данный момент я работаю итеративно, используя стек, но это не то, что требует спецификация. Я нашел алгоритм в C, который рекурсивно обратил вспять и преобразовал его в Java-код вручную, и он работал, но я не знал об этом.

Edit: Nevermind, я понял это тем временем.

private AddressList reverse(ListNode current, AddressList reversedList){
  if(current == null) 
      return reversedList;
  reversedList.addToFront(current.getData());
  return this.reverse(current.getNext(), reversedList);
}

Пока я здесь, кто-нибудь видит проблемы с этим маршрутом?

91
задан sdellysse 10 дек. '08 в 4:51
источник поделиться
32 ответов
  • 1
  • 2

Вот код в одном ответе, который говорит об этом, но вам может быть легче начать снизу вверх, задавая и отвечая на крошечные вопросы (это подход в Little Lisper):

  • Что такое обратный null (пустой список)? нуль.
  • Что такое обратный список элементов? элемент.
  • Что такое обратный список элементов n? обратная сторона второго элемента, за которым следует первый элемент.

public ListNode Reverse(ListNode list)
{
    if (list == null) return null; // first question

    if (list.next == null) return list; // second question

    // third question - in Lisp this is easy, but we don't have cons
    // so we grab the second element (which will be the last after we reverse it)

    ListNode secondElem = list.next;

    // bug fix - need to unlink list from the rest or you will get a cycle
    list.next = null;

    // then we reverse everything from the second element on
    ListNode reverseRest = Reverse(secondElem);

    // then we join the two lists
    secondElem.Next = list;

    return reverseRest;
}
297
ответ дан plinth 10 дек. '08 в 5:28
источник поделиться

Мне задали этот вопрос на собеседовании, и мне было очень неприятно, что я потрудился с ним, так как я немного нервничал.

Это должно обратить вспять односвязный список, называемый обратным (head, NULL); поэтому, если это ваш список:

1->2->3->4->5->null
it would become:
5->4->3->2->1->null

    //Takes as parameters a node in a linked list, and p, the previous node in that list
    //returns the head of the new list
    Node reverse(Node n,Node p){   
        if(n==null) return null;
        if(n.next==null){ //if this is the end of the list, then this is the new head
            n.next=p;
            return n;
        }
        Node r=reverse(n.next,n);  //call reverse for the next node, 
                                      //using yourself as the previous node
        n.next=p;                     //Set your next node to be the previous node 
        return r;                     //Return the head of the new list
    }
    

edit: ive сделано как 6 правки на этом, показывая, что это все еще немного сложно для меня lol

28
ответ дан Ari Ronen 10 дек. '08 в 5:08
источник поделиться

Я получил половину пути (до нуля и один node, как это было предложено плинтом), но потерял трек после рекурсивного вызова. Однако, прочитав сообщение по плинту, вот что я придумал:

Node reverse(Node head) {
  // if head is null or only one node, it reverse of itself.
  if ( (head==null) || (head.next == null) ) return head;

  // reverse the sub-list leaving the head node.
  Node reverse = reverse(head.next);

  // head.next still points to the last element of reversed sub-list.
  // so move the head to end.
  head.next.next = head;

  // point last node to nil, (get rid of cycles)
  head.next = null;
  return reverse;
}
20
ответ дан satyajit 09 авг. '09 в 19:52
источник поделиться

Здесь еще одно рекурсивное решение. Он имеет меньше кода в рекурсивной функции, чем некоторые другие, поэтому он может быть немного быстрее. Это С#, но я считаю, что Java будет очень похож.

class Node<T>
{
    Node<T> next;
    public T data;
}

class LinkedList<T>
{
    Node<T> head = null;

    public void Reverse()
    {
        if (head != null)
            head = RecursiveReverse(null, head);
    }

    private Node<T> RecursiveReverse(Node<T> prev, Node<T> curr)
    {
        Node<T> next = curr.next;
        curr.next = prev;
        return (next == null) ? curr : RecursiveReverse(curr, next);
    }
}
9
ответ дан PointZeroTwo 15 сент. '11 в 6:05
источник поделиться

Алго должно будет работать над следующей моделью,

  • следить за головой
  • Сессия до конца списка ссылок
  • Обратная связь

Состав:

Head    
|    
1-->2-->3-->4-->N-->null

null-->1-->2-->3-->4-->N<--null

null-->1-->2-->3-->4<--N<--null

null-->1-->2-->3<--4<--N<--null

null-->1-->2<--3<--4<--N<--null

null-->1<--2<--3<--4<--N<--null

null<--1<--2<--3<--4<--N
                       |
                       Head

код:

public ListNode reverse(ListNode toBeNextNode, ListNode currentNode)
{               
        ListNode currentHead = currentNode; // keep track of the head

        if ((currentNode==null ||currentNode.next==null )&& toBeNextNode ==null)return currentHead; // ignore for size 0 & 1

        if (currentNode.next!=null)currentHead = reverse(currentNode, currentNode.next); // travarse till end recursively

        currentNode.next = toBeNextNode; // reverse link

        return currentHead;
}

Вывод:

head-->12345

head-->54321
8
ответ дан Devesh Rao 10 дек. '08 в 16:40
источник поделиться

Я знаю, что это старый пост, но большинство ответов не являются хвостовыми рекурсивными, т.е. они выполняют некоторые операции после возвращения из рекурсивного вызова и, следовательно, не являются наиболее эффективными.

Вот хвостовая рекурсивная версия:

public Node reverse(Node previous, Node current) {
    if(previous == null)
        return null;
    if(previous.equals(head))
        previous.setNext(null);
    if(current == null) {    // end of list
        head = previous;
        return head;
    } else {
                    Node temp = current.getNext();
        current.setNext(previous);
        reverse(current, temp);
    }
    return null;    //should never reach here.
} 

Позвонить с помощью:

Node newHead = reverse(head, head.getNext());
7
ответ дан Tushar M 20 июня '10 в 18:19
источник поделиться

Я думаю, что это более чистое решение, которое напоминает LISP

// Example:
// reverse0(1->2->3, null) => 
//      reverse0(2->3, 1) => 
//          reverse0(3, 2->1) => reverse0(null, 3->2->1)
// once the first argument is null, return the second arg
// which is nothing but the reveresed list.

Link reverse0(Link f, Link n) {
    if (f != null) {
        Link t = new Link(f.data1, f.data2); 
        t.nextLink = n;                      
        f = f.nextLink;             // assuming first had n elements before, 
                                    // now it has (n-1) elements
        reverse0(f, t);
    }
    return n;
}
7
ответ дан Swapneel Patil 04 марта '10 в 5:26
источник поделиться
public Node reverseListRecursive(Node curr)
{
    if(curr == null){//Base case
        return head;
    }
    else{
        (reverseListRecursive(curr.next)).next = (curr);
    }
    return curr;
}
4
ответ дан KNA 10 июля '11 в 19:39
источник поделиться
void reverse(node1,node2){
if(node1.next!=null)
      reverse(node1.next,node1);
   node1.next=node2;
}
call this method as reverse(start,null);
3
ответ дан Gaurav 16 сент. '09 в 11:49
источник поделиться
public void reverse() {
    head = reverseNodes(null, head);
}

private Node reverseNodes(Node prevNode, Node currentNode) {
    if (currentNode == null)
        return prevNode;
    Node nextNode = currentNode.next;
    currentNode.next = prevNode;
    return reverseNodes(currentNode, nextNode);
}
3
ответ дан Austin Nwachukwu 29 дек. '13 в 10:08
источник поделиться

Обратный рекурсивный алгоритм.

public ListNode reverse(ListNode head) {
    if (head == null || head.next == null) return head;    
    ListNode rHead = reverse(head.next);
    rHead.next = head;
    head = null;
    return rHead;
}

Итерационным

public ListNode reverse(ListNode head) {
    if (head == null || head.next == null) return head;    
    ListNode prev = null;
    ListNode cur = head
    ListNode next = head.next;
    while (next != null) {
        cur.next = prev;
        prev = cur;
        cur = next;
        next = next.next;
    }
    return cur;
}
2
ответ дан Fredton Doan 09 окт. '13 в 21:24
источник поделиться
public static ListNode recRev(ListNode curr){

    if(curr.next == null){
        return curr;
    }
    ListNode head = recRev(curr.next);
    curr.next.next = curr;
    curr.next = null;

    // propogate the head value
    return head;

}
2
ответ дан akshayd 28 февр. '13 в 20:52
источник поделиться

Это решение демонстрирует отсутствие аргументов.

/**
 * Reverse the list
 * @return reference to the new list head
 */
public LinkNode reverse() {
    if (next == null) {
        return this; // Return the old tail of the list as the new head
    }
    LinkNode oldTail = next.reverse(); // Recurse to find the old tail
    next.next = this; // The old next node now points back to this node
    next = null; // Make sure old head has no next
    return oldTail; // Return the old tail all the way back to the top
}

Вот код поддержки, чтобы продемонстрировать, что это работает:

public class LinkNode {
    private char name;
    private LinkNode next;

    /**
     * Return a linked list of nodes, whose names are characters from the given string
     * @param str node names
     */
    public LinkNode(String str) {
        if ((str == null) || (str.length() == 0)) {
            throw new IllegalArgumentException("LinkNode constructor arg: " + str);
        }
        name = str.charAt(0);
        if (str.length() > 1) {
            next = new LinkNode(str.substring(1));
        }
    }

    public String toString() {
        return name + ((next == null) ? "" : next.toString());
    }

    public static void main(String[] args) {
        LinkNode head = new LinkNode("abc");
        System.out.println(head);
        System.out.println(head.reverse());
    }
}
2
ответ дан Gordon Hamachi 18 янв. '14 в 15:08
источник поделиться

Вот простой итеративный подход:

public static Node reverse(Node root) {
    if (root == null || root.next == null) {
        return root;
    }

    Node curr, prev, next;
    curr = root; prev = next = null;
    while (curr != null) {
        next = curr.next;
        curr.next = prev;

        prev = curr;
        curr = next;
    }
    return prev;
}

И вот рекурсивный подход:

public static Node reverseR(Node node) {
    if (node == null || node.next == null) {
        return node;
    }

    Node next = node.next;
    node.next = null;

    Node remaining = reverseR(next);
    next.next = node;
    return remaining;
}
2
ответ дан shreyas 09 июня '14 в 17:06
источник поделиться

Поскольку Java всегда имеет значение pass-by-value, чтобы рекурсивно изменить связанный список на Java, обязательно верните "новую голову" (голова node после реверсии) в конце рекурсии.

static ListNode reverseR(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }

    ListNode first = head;
    ListNode rest = head.next;

    // reverse the rest of the list recursively
    head = reverseR(rest);

    // fix the first node after recursion
    first.next.next = first;
    first.next = null;

    return head;
}
1
ответ дан jean.timex 10 окт. '14 в 8:43
источник поделиться

Другие ребята, в другом посте это игра с контентом, то, что я сделал, это игра связанного списка, она отменяет член LinkedList, а не отменяет значение членов.

Public LinkedList reverse(LinkedList List)
{
       if(List == null)
               return null;
       if(List.next() == null)
              return List;
       LinkedList temp = this.reverse( List.next() );
       return temp.setNext( List );
}
0
ответ дан Nima Ghaedsharafi 11 мая '13 в 19:35
источник поделиться
public class Singlelinkedlist {
  public static void main(String[] args) {
    Elem list  = new Elem();
    Reverse(list); //list is populate some  where or some how
  }

  //this  is the part you should be concerned with the function/Method has only 3 lines

  public static void Reverse(Elem e){
    if (e!=null)
      if(e.next !=null )
        Reverse(e.next);
    //System.out.println(e.data);
  }
}

class Elem {
  public Elem next;    // Link to next element in the list.
  public String data;  // Reference to the data.
}
0
ответ дан Michael 08 апр. '11 в 20:02
источник поделиться

PointZeroTwo имеет элегантный ответ и тот же в Java...

public void reverseList(){
    if(head!=null){
        head = reverseListNodes(null , head);
    }
}

private Node reverseListNodes(Node parent , Node child ){
    Node next = child.next;
    child.next = parent;
    return (next==null)?child:reverseListNodes(child, next);
}
0
ответ дан user2351329 05 мая '13 в 9:00
источник поделиться
//this function reverses the linked list
public Node reverseList(Node p) {
    if(head == null){
        return null;
    }
    //make the last node as head
    if(p.next == null){
        head.next = null;
        head = p;
        return p;
    }
    //traverse to the last node, then reverse the pointers by assigning the 2nd last node to last node and so on..
    return reverseList(p.next).next = p;
}
0
ответ дан Rahul Saraf 27 сент. '15 в 7:23
источник поделиться
public Node reverseRec(Node prev, Node curr) {
    if (curr == null) return null;  

    if (curr.next == null) {
        curr.next = prev;
        return curr;

    } else {
        Node temp = curr.next; 
        curr.next = prev;
        return reverseRec(curr, temp);
    }               
}

вызов с использованием: head = reverseRec (null, head);

0
ответ дан Murali Mohan 01 мая '13 в 17:14
источник поделиться
package com.mypackage;
class list{

    node first;    
    node last;

    list(){
    first=null;
    last=null;
}

/*returns true if first is null*/
public boolean isEmpty(){
    return first==null;
}
/*Method for insertion*/

public void insert(int value){

    if(isEmpty()){
        first=last=new node(value);
        last.next=null;
    }
    else{
        node temp=new node(value);
        last.next=temp;
        last=temp;
        last.next=null;
    }

}
/*simple traversal from beginning*/
public void traverse(){
    node t=first;
    while(!isEmpty() && t!=null){
        t.printval();
        t= t.next;
    }
}
/*static method for creating a reversed linked list*/
public static void reverse(node n,list l1){

    if(n.next!=null)
        reverse(n.next,l1);/*will traverse to the very end*/
    l1.insert(n.value);/*every stack frame will do insertion now*/

}
/*private inner class node*/
private class node{
    int value;
    node next;
    node(int value){
        this.value=value;
    }
    void printval(){
        System.out.print(value+" ");
    }
}

 }
0
ответ дан Arijit Pal 12 июля '13 в 0:47
источник поделиться
private Node ReverseList(Node current, Node previous)
    {
        if (current == null) return null;
        Node originalNext = current.next;
        current.next = previous;
        if (originalNext == null) return current;
        return ReverseList(originalNext, current);
    }
0
ответ дан pat 29 авг. '14 в 16:23
источник поделиться
public void reverseLinkedList(Node node){
    if(node==null){
        return;
    }

    reverseLinkedList(node.next);
    Node temp = node.next;
    node.next=node.prev;
    node.prev=temp;
    return;
}
0
ответ дан M Sach 26 мая '17 в 9:02
источник поделиться

Решение:

package basic;

import custom.ds.nodes.Node;

public class RevLinkedList {

private static Node<Integer> first = null;

public static void main(String[] args) {
    Node<Integer> f = new Node<Integer>();
    Node<Integer> s = new Node<Integer>();
    Node<Integer> t = new Node<Integer>();
    Node<Integer> fo = new Node<Integer>();
    f.setNext(s);
    s.setNext(t);
    t.setNext(fo);
    fo.setNext(null);

    f.setItem(1);
    s.setItem(2);
    t.setItem(3);
    fo.setItem(4);
    Node<Integer> curr = f;
    display(curr);
    revLL(null, f);
    display(first);
}

public static void display(Node<Integer> curr) {
    while (curr.getNext() != null) {
        System.out.println(curr.getItem());
        System.out.println(curr.getNext());
        curr = curr.getNext();
    }
}

public static void revLL(Node<Integer> pn, Node<Integer> cn) {
    while (cn.getNext() != null) {
        revLL(cn, cn.getNext());
        break;
    }
    if (cn.getNext() == null) {
        first = cn;
    }
    cn.setNext(pn);
}

}

0
ответ дан javasolsz 13 июля '14 в 17:13
источник поделиться
static void reverseList(){

if(head!=null||head.next!=null){
ListNode tail=head;//head points to tail


ListNode Second=head.next;
ListNode Third=Second.next;
tail.next=null;//tail previous head is poiniting null
Second.next=tail;
ListNode current=Third;
ListNode prev=Second;
if(Third.next!=null){



    while(current!=null){
    ListNode    next=current.next;
        current.next=prev;
        prev=current;
        current=next;
    }
    }
head=prev;//new head
}
}
class ListNode{
    public int data;
    public ListNode next;
    public int getData() {
        return data;
    }

    public ListNode(int data) {
        super();
        this.data = data;
        this.next=null;
    }

    public ListNode(int data, ListNode next) {
        super();
        this.data = data;
        this.next = next;
    }

    public void setData(int data) {
        this.data = data;
    }
    public ListNode getNext() {
        return next;
    }
    public void setNext(ListNode next) {
        this.next = next;
    }





}
0
ответ дан Rohit 25 авг. '14 в 15:32
источник поделиться

Так мы будем делать это в Opal - чистом функциональном языке программирования. И, ИМХО - делая это рекурсивно, имеет смысл только в этом контексте.

List Reverse(List l)
{
    if (IsEmpty(l) || Size(l) == 1) return l;
    return reverse(rest(l))::first(l);
}

rest (l) возвращает список, который является исходным списком, без него сначала node. first (l) возвращает первый элемент. :: является оператором конкатенации.

0
ответ дан Mohit Datta 28 сент. '15 в 10:13
источник поделиться

Реверсирование связанного списка с помощью рекурсии. Идея заключается в настройке ссылок путем изменения ссылок.

  public ListNode reverseR(ListNode p) {

       //Base condition, Once you reach the last node,return p                                           
        if (p == null || p.next == null) { 
            return p;
        }
       //Go on making the recursive call till reach the last node,now head points to the last node

        ListNode head  = reverseR(p.next);  //Head points to the last node

       //Here, p points to the last but one node(previous node),  q points to the last   node. Then next next step is to adjust the links
        ListNode q = p.next; 

       //Last node link points to the P (last but one node)
        q.next = p; 
       //Set the last but node (previous node) next to null
        p.next = null; 
        return head; //Head points to the last node
    }
0
ответ дан gurubelli 08 июня '16 в 9:08
источник поделиться
//Recursive solution
class SLL
{
   int data;
   SLL next;
}

SLL reverse(SLL head)
{
  //base case - 0 or 1 elements
  if(head == null || head.next == null) return head;

  SLL temp = reverse(head.next);
  head.next.next = head;
  head.next = null;
  return temp;
}
0
ответ дан vsn harish rayasam 25 окт. '15 в 17:51
источник поделиться

Вдохновленный статья, в которой обсуждаются непреложные реализации рекурсивных структур данных, я добавляю альтернативное решение вместе с помощью Swift.

Решение для ведущих документов для ответов, выделив следующие темы:

  • Что такое обратный ниль (пустой список)?
    • Здесь неважно, потому что у нас нет ни одной защиты в Swift.
  • Что такое обратный список элементов?
    • Сам элемент
  • Что такое обратный список элементов n?
    • Обратная сторона второго элемента, за которым следует первый элемент.

Я назвал их там, где это применимо в нижеприведенном решении.

/**
 Node is a class that stores an arbitrary value of generic type T 
 and a pointer to another Node of the same time.  This is a recursive 
 data structure representative of a member of a unidirectional linked
 list.
 */
public class Node<T> {
    public let value: T
    public let next: Node<T>?

    public init(value: T, next: Node<T>?) {
        self.value = value
        self.next = next
    }

    public func reversedList() -> Node<T> {
        if let next = self.next {
            // 3. The reverse of the second element on followed by the first element.
            return next.reversedList() + value
        } else {
            // 2. Reverse of a one element list is itself
            return self
        }
    }
}

/**
 @return Returns a newly created Node consisting of the lhs list appended with rhs value.
 */
public func +<T>(lhs: Node<T>, rhs: T) -> Node<T> {
    let tail: Node<T>?
    if let next = lhs.next {
        // The new tail is created recursively, as long as there is a next node.
        tail = next + rhs
    } else {
        // If there is not a next node, create a new tail node to append
        tail = Node<T>(value: rhs, next: nil)
    }
    // Return a newly created Node consisting of the lhs list appended with rhs value.
    return Node<T>(value: lhs.value, next: tail)
}
0
ответ дан banDedo 21 февр. '16 в 6:00
источник поделиться

Вот ссылка, если кто-то ищет реализацию Scala:

scala> import scala.collection.mutable.LinkedList
import scala.collection.mutable.LinkedList

scala> def reverseLinkedList[A](ll: LinkedList[A]): LinkedList[A] =
         ll.foldLeft(LinkedList.empty[A])((accumulator, nextElement) => nextElement +: accumulator)
reverseLinkedList: [A](ll: scala.collection.mutable.LinkedList[A])scala.collection.mutable.LinkedList[A]

scala> reverseLinkedList(LinkedList("a", "b", "c"))
res0: scala.collection.mutable.LinkedList[java.lang.String] = LinkedList(c, b, a)

scala> reverseLinkedList(LinkedList("1", "2", "3"))
res1: scala.collection.mutable.LinkedList[java.lang.String] = LinkedList(3, 2, 1)
-1
ответ дан Venkat Sudheer Reddy Aedama 09 янв. '14 в 6:20
источник поделиться
  • 1
  • 2

Другие вопросы по меткам