Question

我正在尝试实现自己的reverse实现的LinkedList函数。使用我的LinkedList实现：

public class LinkedList<T> {
    public Node head;

    public LinkedList(){
        // Add HEAD
        head = new Node(null);
    }

    public void add(T data){
        getLastNode().next = new Node(data);
    }

    public void insert(int index, T data){
        if(index == 0){
            throw new Error(); // TODO: What is the Error Type?
        }

        Node current = head;

        for (int i = 0; i != index - 1 ; i ++) {
            current = current.next;
            if (current == null){
                throw new IndexOutOfBoundsException();
            }
        }

        Node next = current.next;
        Node newNode = new Node(data);
        current.next = newNode;
        newNode.next = next;
    }

    public T get(int index){
        return getNode(index).data;
    }

    public void delete(int index){
        if (index == 0){
            throw new IndexOutOfBoundsException("Cannot delete HEAD node");
        }

        Node prev = getNode(index - 1);
        Node next = prev.next.next;
        prev.next = null;

        prev.next = next;
    }

    public void reverse(){ // TODO: Last node links to a null node
        Node prev = null;
        Node current = head;
        Node next = null;

        while(current != null){
            next = current.next;
            current.next = prev;
            prev = current;
            current = next;
        }

        head = new Node(null);
        head.next = prev;
    }

    public void display(){
        Node current = head;

        String diagram = String.format("head->");
        while(current.next != null){
            current = current.next;
            diagram += String.format("%s->", current.data);
        }
        System.out.println(diagram);
    }

    private Node getNode(int index){
        Node node = head;

        for(int i = 0; i != index; i++){
            node = node.next;
            if(node == null){
                throw new IndexOutOfBoundsException();
            }
        }

        return node;
    }

    private Node getLastNode(){
        Node current = head;

        while(current.next != null){
            current = current.next;
        }

        return current;
    }

    public class Node {
        private Node next;
        private T data;

        public Node(T data){
            this.data = data;
        }

        public Node getNext(){
            return this.next;
        }
    }
}

这个main函数：

    LinkedList list = new LinkedList();
    list.add("e1");
    list.add("e2");
    list.add("e3");
    list.add("e4");

    list.display();
    list.reverse();
    list.display();

显示的结果是：

head->e1->e2->e3->e4->
head->e4->e3->e2->e1->null->

这是因为e1仍然连接到头部。如果我在网上使用反向实现：

    Node prev = null;
    Node current = head;
    Node next = null;

    while(current != null){
        next = current.next;
        current.next = prev;
        prev = current;
        current = next;
    }

    head = prev;

然后结果将放弃e4：head->e3->e2->e1->null->

我在这做什么？为什么我的实现与其他人不同？

另外：为什么每个人都使用reverse函数head作为参数，如果开发人员进入另一个节点可能会有问题？

Answer 1

您正在使用第一个节点作为列表的头部。反向功能的解决方案是：

    head.next = prev;

您必须保留“head”节点，但更改其“next”字段。

该功能的其余部分根本不会改变：

public void reverse(){ // TODO: Last node links to a null node
    Node prev = null;
    Node current = head.next;
    Node next = null;

    while(current != null){
        next = current.next;
        current.next = prev;
        prev = current;
        current = next;
    }

    head.next = prev;  // *** The only change ***
}

在你的构造函数中，你有：

public LinkedList(){
    // Add HEAD
    head = new Node(null);
}

然后，'head'是一个最初指向任何东西的节点。

在反向功能中，'head'节点不会改变，你不需要再创建另一个节点。但它必须指向正确的第一个节点。

如果列表为空，则此“head”指向null。如果列表只有一个Node，那么这个'head'指向它。如果列表中有多个节点，则此“head”必须指向最后一个节点。

因此，您需要更改其“下一个”字段。

Java：LinkedList Reverse

1 个答案: