用Java 写一个反转链表

可以的，以下是 Java 代码实现反转链表：

public ListNode reverseList(ListNode head) {
ListNode prev = null;
ListNode curr = head;
while (curr != null) {
ListNode nextTemp = curr.next;
curr.next = prev;
prev = curr;
curr = nextTemp;
}
return prev;
}

其中，ListNode 是链表节点的定义，包含一个 val 属性和一个 next 属性，表示当前节点的值和下一个节点的指针。

相关问题

写一个反转链表代码用java

下面是一个反转链表的Java代码实现：

public class ListNode {
    int val;
    ListNode next;
    ListNode(int x) {
        val = x;
    }
}

public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    ListNode curr = head;
    while (curr != null) {
        ListNode temp = curr.next;
        curr.next = prev;
        prev = curr;
        curr = temp;
    }
    return prev;
}

在这个代码中，我们定义了一个链表节点ListNode，包含了一个整数值val和一个指向下一个节点的指针next。然后我们定义了一个reverseList()方法，用于反转链表。

在方法中，我们使用了三个指针，分别指向当前节点（curr）、前一个节点（prev）和后一个节点（temp）。我们每次将当前节点的指针指向前一个节点，然后依次移动三个指针即可。最后返回反转后的头节点（即原来的尾节点）。

需要注意的是，在反转链表时，一定要先将当前节点的next指针保存到一个临时变量中，否则在修改指针时会造成链表的断裂。

用Java写一个Java反转双向链表

下面是Java实现反转双向链表的代码：

public class DoublyLinkedList {
    private Node head;

    private class Node {
        int data;
        Node prev;
        Node next;

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

    // 添加元素到双向链表的尾部
    public void add(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
            newNode.prev = current;
        }
    }

    // 反转双向链表
    public void reverse() {
        Node current = head;
        Node temp = null;
        while (current != null) {
            temp = current.prev;
            current.prev = current.next;
            current.next = temp;
            current = current.prev;
        }
        if (temp != null) {
            head = temp.prev;
        }
    }

    // 输出双向链表
    public void print() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        DoublyLinkedList list = new DoublyLinkedList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        System.out.print("Original List: ");
        list.print();

        list.reverse();

        System.out.print("Reversed List: ");
        list.print();
    }
}

在这个实现中，我们定义了一个内部类 `Node` 来表示双向链表节点。在 `add` 方法中，我们添加一个新节点到链表尾部。在 `reverse` 方法中，我们使用三个指针 `current`, `temp`, 和 `prev` 来反转链表。在 `print` 方法中，我们遍历链表并打印每个节点的值。

在 `main` 方法中，我们创建一个新的 `DoublyLinkedList` 对象，并添加一些元素。然后，我们打印原始链表，调用 `reverse` 方法反转链表，并再次打印反转后的链表。