Java簡單類返回反向單鏈接列表

Question

我正在嘗試編寫一個簡單的類，以反轉單個鏈表並返回構造的鏈表 。 如果我公開所有我不想公開的內容，則下面的代碼有效。 有人有興趣解決我的問題嗎？ （我應該使用雙向鏈表嗎？還是可以使用單鏈表？）

我想要的是一個功能reverseList接收ListNode Object返回ListNode Object （以相反的順序）。 像這樣：

originalNumber=OriginalNumber.reverseList();

////我的代碼

public class ReverseLinkList {

    public static ListNode originalNumber=new ListNode();
    public static ListNode reversedNumber=new ListNode();

    public static void main(String[] args) {
        //create 1->2->3->null
        originalNumber.add(1);originalNumber.add(2);originalNumber.add(3);
        System.out.print(num1.toString()+"\n");

        //create 3->2->1->null
        reversedNumber=originalNumber.reverseList;

    }


}

class ListNode{ 
    private class Node{
        Object data;
        Node next;
        Node(int v){
            data=v;
            next=null;
        }
        public Object getData(){
            return data;
        }
        public void setData(int v){
            data=v;
        }
        public Node getNext(){
            return next;
        }
        public void setNext(Node nextValue){
            next=nextValue;
        }
    }

    private Node head;
    public void add(int data){
        if(head==null){
            head=new Node(data);
        }
        Node temp=new Node(data);
        Node current=head;
        if(current !=null){
            while(current.getNext()!=null){
                current=current.getNext();
            }
            current.setNext(temp);
        }
    }
    public String toString(){
        String output="";
        if(head!=null){
            Node current=head.getNext();
            while(current!=null){
                //System.out.println(output);
                output+=current.getData().toString();
                current=current.getNext();
            }
        }
        return output;      
    }
    public Node getHead(){
        return head;
    }

    public static Node reverse(Node node) {
        Node prev = null;
        Node current = node;
        Node next = null;
        while (current != null) {
            next = current.next;
            current.next = prev;
            prev = current;
            current = next;
        }
        node = prev;
        return node;
    }

}

---

我不想要的原始代碼和工作代碼

public class ReversedLinkedList {
    static Node head;
    static class Node {
        int data;
        Node next;
        Node(int d) {
            data = d;
            next = null;
        }
    }
    Node reverse(Node node) {
        Node prev = null;
        Node current = node;
        Node next = null;
        while (current != null) {
            next = current.next;
            current.next = prev;
            prev = current;
            current = next;
        }
        node = prev;
        return node;
    }
    void printList(Node node) {
        while (node != null) {
            System.out.print(node.data + "");
            node = node.next;
        }
    }

    public static void main(String[] args) {
        ReversedLinkedList list = new ReversedLinkedList();
        list.head = new Node(1);
        list.head.next = new Node(2);
        list.head.next.next = new Node(3);

        list.printList(head);
        head = list.reverse(head);
        System.out.println("");
        list.printList(head);

    }
}

Answer 1

您走在正確的軌道上。 您可以將成員變量設為私有，並使用適當的getter和setter：

public ListNode reverseList() {
    Node prev = null;
    Node current = this.getHead();
    Node next = null;
    while (current != null) {
        next = current.next;
        current.next = prev;
        prev = current;
        current = next;
    }
    head = prev;
    return this;
}

這使您可以打印反向列表：

System.out.println(originalNumber.reverseList());

請注意， originalNumber本身是操縱的。 因此，后續打印（ System.out.println(originalNumber); ）仍將打印反向列表。

如果您不希望修改原始數據，那么除了收集所有數據然后以相反的順序循環並將它們添加到新列表中之外，實際上別無其他方法：

public ListNode reverseList() {
    int size = 0;

    // Calculate size
    Node current = this.getHead();
    while (current != null) {
        size++;
        current = current.getNext();
    }
    int[] data = new int[size];

    // Collect all data
    current = this.getHead();
    int index = 0;
    while (current != null) {
        data[index++] = current.getData();
        current = current.getNext();
    }

    // Add to a new list in reverse order
    ListNode reversed = new ListNode();
    for (index = size - 1; index >= 0; index--)
        reversed.add(data[index]);
    return reversed;
}

如果在將元素添加到列表時跟蹤大小，或者只是切換到ArrayList而不是data數組，則可以跳過第一次獲取大小的掃描。

最后，還有一種優雅的遞歸方法，該方法還可以保持原始ListNode完整性：

public ListNode reverseRecursive() {
    return recursive(this.getHead());
}

private ListNode recursive(Node node) {
    if (node == null)
        return new ListNode();
    else {
        ListNode listNode = this.recursive(node.next);
        listNode.add(node.data);
        return listNode;
    }
}

打印：

System.out.println(originalNumber.reverseRecursive());

在這里，我們不需要跟蹤大小，您可以利用調用堆棧自然地跟蹤和彈出相反的節點。