利用迭代实现链表反转Java

用迭代实现链表反转的Java代码示例如下：

public class LinkedListReverser {
    public static Node reverse(Node head) {
        Node prev = null;
        Node curr = head;
        while (curr != null) {
            Node nextTemp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = nextTemp;
        }
        return prev;
    }
}

其中，Node类表示链表中的每个节点，包含一个值域和一个next指针。在上面的代码中，我们使用三个指针prev、curr和nextTemp，分别指向前一个节点、当前节点和下一个节点。我们在循环中更新这三个指针的值，并在每次迭代中将当前节点的next指针指向前一个节点，从而实现链表的反转。

相关问题

java 实现链表反转

要实现链表的反转，可以使用迭代或递归的方法。下面是使用迭代方法实现链表反转的 Java 代码示例：

public class ListNode {
    int val;
    ListNode next;

    ListNode(int val) {
        this.val = val;
    }
}

public class LinkedListReverse {
    public ListNode reverse(ListNode head) {
        ListNode prev = null;
        ListNode current = head;
        ListNode next = null;

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

        return prev;
    }
}

使用示例：

public static void main(String[] args) {
    LinkedListReverse reverser = new LinkedListReverse();

    // 创建链表 1 -> 2 -> 3 -> 4 -> 5
    ListNode head = new ListNode(1);
    head.next = new ListNode(2);
    head.next.next = new ListNode(3);
    head.next.next.next = new ListNode(4);
    head.next.next.next.next = new ListNode(5);

    // 反转链表
    head = reverser.reverse(head);

    // 打印反转后的链表
    while (head != null) {
        System.out.print(head.val + " ");
        head = head.next;
    }
}

以上代码会输出：`5 4 3 2 1`，表示链表已经成功反转。

java 双向链表反转

### 回答1：
以下是 Java 实现双向链表反转的代码示例：

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

    Node(int data) {
        this.data = data;
        this.prev = null;
        this.next = null;
    }
}

class DoublyLinkedList {
    Node head;

    DoublyLinkedList() {
        this.head = null;
    }

    void insertAtEnd(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            return;
        }
        Node temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = newNode;
        newNode.prev = temp;
    }

    void reverse() {
        if (head == null || head.next == null) {
            return;
        }
        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;
        }
    }

    void display() {
        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + " ");
            temp = temp.next;
        }
        System.out.println();
    }
}

public class Main {
    public static void main(String[] args) {
        DoublyLinkedList dll = new DoublyLinkedList();
        dll.insertAtEnd(10);
        dll.insertAtEnd(20);
        dll.insertAtEnd(30);
        dll.insertAtEnd(40);
        System.out.print("Original list: ");
        dll.display();
        dll.reverse();
        System.out.print("Reversed list: ");
        dll.display();
    }
}

在上述代码中，我们首先定义了一个 `Node` 类来表示双向链表的节点，每个节点包含一个 `data` 值、一个指向前一个节点的 `prev` 指针和一个指向后一个节点的 `next` 指针。

接下来，我们定义了一个 `DoublyLinkedList` 类来表示双向链表。该类包含一个指向链表头部的 `head` 指针以及一些用于操作链表的方法。

其中，`insertAtEnd` 方法用于在链表末尾插入一个新的节点，`reverse` 方法用于反转链表，`display` 方法用于打印链表中所有节点的值。

在 `reverse` 方法中，我们使用了三个指针 `current`、`prev` 和 `temp`，其中 `current` 指向当前节点，`prev` 指向当前节点的前一个节点，`temp` 则用于保存下一个节点的位置。我们不断地遍历链表，将当前节点的 `prev` 和 `next` 指针交换，并将 `current` 指向下一个节点，直到遍历完整个链表。最后，如果链表非空，则将 `head` 指针指向反转后链表的新头部。

### 回答2：
双向链表是一种链表结构，其中每个节点除了存储数据值之外，还包含指向前一个节点和后一个节点的指针。反转双向链表意味着将原本的链表顺序完全颠倒过来。

要实现双向链表的反转，可以遵循以下步骤：

1. 首先，创建一个指针变量current，并将其指向原始链表的头节点。
2. 创建另外两个指针变量prev和next，分别用于记录当前节点的前一个节点和后一个节点。
3. 开始遍历链表，直到current指针为空为止。在每次迭代时，执行以下操作：
- 将current的next指针指向prev节点。
- 更新prev指针，使其指向当前节点。
- 将current指针向后移动到下一个节点。

这样，反转操作就完成了。
4. 最后，将原始链表的头节点指向原始链表的尾节点，并将原始链表的尾节点指向原始链表的头节点，以便使链表正常运作。

下面是一个Java代码示例来实现双向链表的反转：

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

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

class DoubleLinkedList {
    Node head;

    public void reverse() {
        Node current = head;
        Node prev = null;
        
        while (current != null) {
            Node next = current.next;
            
            current.next = prev;
            current.prev = next;
            
            prev = current;
            current = next;
        }
        
        head = prev;
        head.prev = null;
    }
}

通过调用`reverse`方法，即可反转双向链表。需要注意的是，该方法只能适用于非空链表。如果链表为空，则需要先进行非空判断进行处理。

### 回答3：
双向链表是一种链表的数据结构，其中每个节点除了存储数据的值外还存储了指向前一个节点和后一个节点的指针。反转双向链表就是将原本指向前一个节点的指针变为指向后一个节点，指向后一个节点的指针变为指向前一个节点。

要实现双向链表的反转，需要以下几个步骤：

1. 创建一个辅助节点，初始化为null，用于存储反转后的链表的头节点。
2. 遍历原始链表，对每个节点进行以下操作：
- 将当前节点的next指针指向前一个节点，将当前节点的prev指针指向后一个节点。（交换指针的指向）
- 更新前一个节点为当前节点，当前节点为下一个节点。
3. 最后，将原始链表的头节点指向辅助节点。

以下是一个Java实现的示例代码：

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

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

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

    Node current = head;
    Node previous = null;

    while (current != null) {
      // 交换 next 和 prev 指针的指向
      Node next = current.next;
      current.next = previous;
      current.prev = next;

      // 更新 previous 和 current 节点
      previous = current;
      current = next;
    }

    // 更新原始链表的头节点
    head = previous;

    return head;
  }

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

    System.out.println("原始链表：");
    printLinkedList(head);

    Node reversedHead = reverse(head);

    System.out.println("反转后的链表：");
    printLinkedList(reversedHead);
  }

  public static void printLinkedList(Node head) {
    Node current = head;
    while (current != null) {
      System.out.print(current.data + " ");
      current = current.next;
    }
    System.out.println();
  }
}

以上代码中，我们首先创建了一个双向链表，并初始化了它的节点和指针。然后定义了一个`reverse`方法来实现链表的反转。在`main`方法中，我们先打印出原始链表的内容，再调用`reverse`方法对链表进行反转，并打印出反转后的链表内容。

运行以上代码，输出结果如下：

原始链表：
1 2 3 
反转后的链表：
3 2 1 

这样，我们就成功地实现了Java中双向链表的反转。