Rekursiv eine verknüpfte Liste in Java umkehren

101

Ich arbeite jetzt schon eine Weile an einem Java-Projekt für eine Klasse. Es ist eine Implementierung einer verknüpften Liste (hier genannt AddressList, die einfache Knoten enthält ListNode). Der Haken ist, dass alles mit rekursiven Algorithmen gemacht werden müsste. Ich konnte alles gut machen ohne eine Methode:public AddressList reverse()

ListNode:

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

Im Moment reverseruft meine Funktion nur eine Hilfsfunktion auf, die ein Argument verwendet, um eine Rekursion zu ermöglichen.

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

Mit meiner Hilfsfunktion mit der Signatur von private ListNode reverse(ListNode current).

Im Moment funktioniert es iterativ mit einem Stapel, aber dies ist nicht das, was die Spezifikation erfordert. Ich hatte in C einen Algorithmus gefunden, der ihn rekursiv umkehrte und von Hand in Java-Code konvertierte, und er funktionierte, aber ich hatte kein Verständnis dafür.

Edit: Nevermind, ich habe es in der Zwischenzeit herausgefunden.

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

Hat jemand Probleme mit dieser Route, während ich hier bin?

sdellysse
quelle
2
Nein, es gibt kein Problem mit Ihrer Lösung. Im Gegenteil, es ist sogar "besser" als die bevorzugte "Little Lisper" -Lösung, da die ursprüngliche Liste intakt bleibt. Dies wäre besonders in einer Mehrkernumgebung nützlich, in der unveränderliche Werte stark bevorzugt werden.
Ingo

Antworten:

317

In einer Antwort ist Code enthalten, der es ausdrückt, aber es ist möglicherweise einfacher, von unten nach oben zu beginnen, indem Sie winzige Fragen stellen und beantworten (dies ist der Ansatz in The Little Lisper):

  1. Was ist die Umkehrung von null (die leere Liste)? Null.
  2. Was ist die Umkehrung einer Ein-Element-Liste? das Element.
  3. Was ist die Umkehrung einer Liste mit n Elementen? die Umkehrung des Restes der Liste, gefolgt vom ersten Element.

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;
}
Sockel
quelle
30
Wow, ich mag diese ganze Sache mit den drei Fragen.
Sdellysse
4
Vielen Dank. Die kleine Frage soll die Grundlage für das Erlernen von Lisp sein. Es ist auch eine Möglichkeit, die Induktion vor Neulingen zu verbergen, was im Wesentlichen das ist, was dieses Muster ist. Ich empfehle, den Little Lisper zu lesen, wenn Sie diese Art von Problem wirklich lösen möchten.
Sockel
44
Ausnahmen für außergewöhnliche Umstände. Warum einen Verschluss für einen bekannten Zustand verwenden, der durch ein Wenn überprüft werden kann?
Luke Schafer
4
Ich glaube, Sie müssen die Variable nicht erstellen: secondElem, da list.next immer noch secondElem ist. Nach "ListNode reverseRest = Reverse (secondElem);" können Sie zuerst "list.next.next = list" und dann "list.next = null" ausführen. Und das ist es.
ChuanRocks
3
Können Sie erklären, warum list.next = null ist? Ich habe versucht, den Zyklus zu verstehen, habe ihn aber nicht verstanden.
Rohit
29

Diese Frage wurde mir bei einem Interview gestellt und ich war verärgert, dass ich damit herumgefummelt habe, da ich etwas nervös war.

Dies sollte eine einfach verknüpfte Liste umkehren, die mit reverse (head, NULL) aufgerufen wird. Also, wenn dies Ihre Liste wäre:

1-> 2-> 3-> 4-> 5-> null
es würde werden:
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: Ich habe 6 Änderungen daran vorgenommen, was zeigt, dass es für mich immer noch etwas schwierig ist, lol

Ari Ronen
quelle
2
Ich wäre ein bisschen verärgert über die Anforderung "muss rekursiv sein" in einem Interview, um ehrlich zu sein, wenn Java angegeben ist. Sonst würde ich mit p = null gehen; while (n.next! = null) {n2 = n.next; n.next = p; p = n; n = n2;} n.next = p; return n;. O (N) Stapel ist für die Vögel.
Steve Jessop
Oh ja, auch ein Null-Check auf dem Kopf, das ist Java.
Steve Jessop
23

Ich bin auf halbem Weg durchgekommen (bis null und ein Knoten, wie vom Sockel vorgeschlagen), habe aber nach einem rekursiven Aufruf den Überblick verloren. Nachdem ich den Beitrag auf dem Sockel gelesen habe, habe ich mir Folgendes ausgedacht:

Node reverse(Node head) {
  // if head is null or only one node, it's 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;
}

quelle
sehr schön. genau wie Nachteile :)
Karthikeyan D
9

Hier ist noch eine andere rekursive Lösung. Die rekursive Funktion enthält weniger Code als einige der anderen, daher ist sie möglicherweise etwas schneller. Dies ist C #, aber ich glaube, Java wäre sehr ähnlich.

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);
    }
}
PointZeroTwo
quelle
8

Das Algo muss am folgenden Modell arbeiten:

  • Behalte den Kopf im Auge
  • Rekurs bis zum Ende der Linkliste
  • Rückwärtsverbindung

Struktur:

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

Code:

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

Ausgabe:

head-->12345

head-->54321
Devesh Rao
quelle
7

Ich denke, dies ist eine sauberere Lösung, die LISP ähnelt

// 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;
}
Swapneel Patil
quelle
7

Ich weiß, dass dies ein alter Beitrag ist, aber die meisten Antworten sind nicht rekursiv, dh sie führen einige Operationen nach der Rückkehr vom rekursiven Aufruf aus und sind daher nicht die effizientesten.

Hier ist eine rekursive Schwanzversion:

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

Rufen Sie an mit:

Node newHead = reverse(head, head.getNext());
Readdear
quelle
9
Sie verweisen in Ihrer Methode auf eine Variable namens "head", die jedoch nirgendwo deklariert wird.
Marathon
Es ist wahrscheinlich eine Methode für die List-Klasse, die das Node-Head-Attribut enthält
ChrisMcJava
4
void reverse (Knoten1, Knoten2) {
if (node1.next! = null)
      umgekehrt (node1.next, node1);
   node1.next = node2;
}}
Rufen Sie diese Methode als umgekehrt auf (start, null).

quelle
4
public Node reverseListRecursive(Node curr)
{
    if(curr == null){//Base case
        return head;
    }
    else{
        (reverseListRecursive(curr.next)).next = (curr);
    }
    return curr;
}
KNA
quelle
3
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);
}
Austin Nwachukwu
quelle
Ich denke, dies ist die beste Lösung ... einfach, Tail-Rekursion optimierbar und nur eine Nullprüfung.
Sdanzig
2
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;

}
Akshayd
quelle
Dies ist die beste Lösung, aber nicht die beste Antwort, da keine Erklärung gegeben wird :). Ich habe zunächst eine ähnliche Lösung abgeleitet, aber die Kopfreferenz verloren. Diese Lösung löst das.
OpenUserX03
2

Umkehrung durch rekursives Algo.

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

Durch iterative

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;
}
Fredton Doan
quelle
Leider ist Ihre rekursive Umkehrung falsch !!
Sree Aurovindh
@SreeAurovindh - Warum?
Rayryeng
2

Diese Lösung zeigt, dass keine Argumente erforderlich sind.

/**
 * 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
}

Hier ist der unterstützende Code, um zu demonstrieren, dass dies funktioniert:

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());
    }
}
Gordon Hamachi
quelle
2

Hier ist ein einfacher iterativer Ansatz:

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

Und hier ist ein rekursiver Ansatz:

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;
}
Shreyas
quelle
1

Da Java immer als Wert übergeben wird, müssen Sie zum rekursiven Umkehren einer verknüpften Liste in Java am Ende der Rekursion den "neuen Kopf" (den Kopfknoten nach der Umkehrung) zurückgeben.

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;
}
jeantimex
quelle
1

PointZeroTwo hat eine elegante Antwort und das gleiche in 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);
}
user2351329
quelle
Dies ist perfekt, weil Sie nicht immer wollen, dass diese Listenmethode Liste als Argumente verwendet, sondern sich mit ihren eigenen Kindern umkehrt, danke
Manu
0
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.
}
Michael
quelle
0
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);
    }               
}

Aufruf mit: head = reverseRec (null, head);

Murali Mohan
quelle
0

Was andere Leute getan haben, in einem anderen Beitrag ist ein Spiel mit Inhalten, was ich getan habe, ist ein Spiel mit verknüpfter Liste, es kehrt das Mitglied der LinkedList um, nicht umgekehrt einen Wert von Mitgliedern.

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 );
}
Nima Ghaedsharafi
quelle
sry ich habe vergessen, dass Sie auch eine Hilfsmethode benötigen, um den nächsten Schwanz mit dem Nullwert zu setzen
Nima Ghaedsharafi
0
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+" ");
    }
}

 }
Arijit Pal
quelle
0

Die Lösung ist:

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

}}

javasolsz
quelle
0
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;
    }





}
Rohit
quelle
0
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);
    }
klopfen
quelle
Beginnen Sie mit ReverseList (Kopf, Null)
Pat
0
//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;
}
Rahul Saraf
quelle
0
//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;
}
vsn harish rayasam
quelle
0

Inspiriert von einem Artikel über unveränderliche Implementierungen rekursiver Datenstrukturen habe ich mit Swift eine alternative Lösung zusammengestellt.

Die führende Lösung für Antwortdokumente mit Hervorhebung der folgenden Themen:

  1. Was ist die Umkehrung von Null (die leere Liste)?
    • Das spielt hier keine Rolle, denn wir haben in Swift keinen Schutz.
  2. Was ist die Umkehrung einer Ein-Element-Liste?
    • Das Element selbst
  3. Was ist die Umkehrung einer Liste mit n Elementen?
    • Die Umkehrung des zweiten Elements gefolgt vom ersten Element.

Ich habe diese gegebenenfalls in der folgenden Lösung genannt.

/**
 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)
}
banDedo
quelle
0

Umkehren der verknüpften Liste mithilfe der Rekursion. Die Idee ist, die Links durch Umkehren der Links anzupassen.

  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
    }
Gurubelli
quelle
1
Könnten Sie bitte Ihre Antwort näher erläutern und etwas mehr Beschreibung der von Ihnen bereitgestellten Lösung hinzufügen?
Abarisone
1
Ich habe Kommentare hinzugefügt. Vielen Dank
Gurubelli
0
public void reverseLinkedList(Node node){
    if(node==null){
        return;
    }

    reverseLinkedList(node.next);
    Node temp = node.next;
    node.next=node.prev;
    node.prev=temp;
    return;
}
M Sach
quelle
-1
public void reverse(){
    if(isEmpty()){
    return;
     }
     Node<T> revHead = new Node<T>();
     this.reverse(head.next, revHead);
     this.head = revHead;
}

private Node<T> reverse(Node<T> node, Node<T> revHead){
    if(node.next == null){
       revHead.next = node;
       return node;
     }
     Node<T> reverse = this.reverse(node.next, revHead);
     reverse.next = node;
     node.next = null;
     return node;
}
Vara
quelle
-1

Hier ist eine Referenz, wenn jemand nach einer Scala-Implementierung sucht:

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)
Venkat Sudheer Reddy Aedama
quelle
Ich würde mehr als glücklich sein, meine Antwort zu verbessern, wenn die herabgestimmte Person mir eine Erklärung für ihre Handlung gibt. Wie auch immer, es funktioniert immer noch für mich in Scala :)
Venkat Sudheer Reddy Aedama
Nur damit der Downvoter weiß, ist dies eine rekursive (in der Tat eine rekursive Schwanzlösung).
Venkat Sudheer Reddy Aedama
Scala ist kein Java, auch wenn beide auf der JVM ausgeführt werden.
Bill Lynch
@sharth Wow, gut das zu wissen. Haben Sie sich die Mühe gemacht, die erste Zeile meiner Antwort zu lesen?
Venkat Sudheer Reddy Aedama
@VenkatSudheerReddyAedama Sie wurden abgelehnt, weil die ursprüngliche Frage nach einer Implementierung in Java fragte. Obwohl Scala in der JVM ausgeführt wird, hilft dies nicht bei der Beantwortung der Frage ... obwohl es ziemlich elegant ist. FWIW, ich habe dich nicht abgelehnt.
Rayryeng