反向链接 反向代理

Reversing a Linked List is an interesting problem in data structure and algorithms. In this tutorial, we’ll be discussing the various algorithms to reverse a Linked List and then implement them using Java.

反向链接列表是数据结构和算法中一个有趣的问题。 在本教程中，我们将讨论各种算法来反向链接列表 ，然后使用Java实现它们。

反向链接列表 (Reverse a Linked List)

LinkedList is a data structure which stores the data in a linear way. Though not in a contiguous way.

LinkedList是一种数据结构，它以线性方式存储数据。 虽然不是连续的。

Every element of a LinkedList contains a data part and an address to the next element of the LinkedList.

LinkedList的每个元素都包含一个数据部分和LinkedList的下一个元素的地址。

LinkedList elements are popularly known as nodes.

LinkedList元素通常称为节点。

In order to reverse a LinkedList in place, we need to reverse the pointers such that the next element now points to the previous element.

为了使LinkedList反向，我们需要反向指针，以便下一个元素现在指向上一个元素。

Following is the input and output.

以下是输入和输出。

Input

输入项

Output

输出量

The head of the LinkedList is the first node. No other element has the address stored for this.

LinkedList的头是第一个节点。 没有其他元素为此存储地址。

The tail of the LinkedList is the last node. The next address stored in this node is null.

LinkedList的尾部是最后一个节点。 存储在此节点中的下一个地址为null 。

We can reverse a LinkedList such that the head and tail also get changed using:

我们可以反转LinkedList，使头部和尾部也可以使用以下方式更改：

• Iterative Approach迭代法
• Recursive Approach递归方法

反向链接列表的迭代方法 (Iterative Approach to Reverse a Linked List)

To reverse a LinkedList iteratively, we need to store the references of the next and previous elements, so that they don’t get lost when we swap the memory address pointers to the next element in the LinkedList.

要迭代地反转LinkedList，我们需要存储下一个和上一个元素的引用，以便在将内存地址指针交换到LinkedList中的下一个元素时，它们不会丢失。

Following illustration demonstrates how we will reverse our LinkedList by changing the references.

下图说明了如何通过更改引用来反转LinkedList。

Here is a very simple implementation of LinkedList. Note that this is not a production-ready implementation and we have kept it simple so that our focus remains on the algorithm to reverse the Linked List.

这是LinkedList的非常简单的实现。 请注意，这不是可用于生产的实现，因此我们将其保持简单，因此我们将重点放在反转链表的算法上。

package com.journaldev.linkedlist.reverse;public class MyLinkedList {public Node head;public static class Node {Node next;Object data;Node(Object data) {this.data = data;next = null;}}
}

The Java Program to reverse a Linked List iteratively and printing its elements is given below:

下面给出了Java程序以迭代方式反向链接列表并打印其元素的情况：

package com.journaldev.linkedlist.reverse;import com.journaldev.linkedlist.reverse.MyLinkedList.Node;public class ReverseLinkedList {public static void main(String[] args) {MyLinkedList myLinkedList = new MyLinkedList();myLinkedList.head = new Node(1);myLinkedList.head.next = new Node(2);myLinkedList.head.next.next = new Node(3);printLinkedList(myLinkedList);reverseLinkedList(myLinkedList);printLinkedList(myLinkedList);}public static void printLinkedList(MyLinkedList linkedList) {Node h = linkedList.head;while (linkedList.head != null) {System.out.print(linkedList.head.data + " ");linkedList.head = linkedList.head.next;}System.out.println();linkedList.head = h;}public static void reverseLinkedList(MyLinkedList linkedList) {Node previous = null;Node current = linkedList.head;Node next;while (current != null) {next = current.next;current.next = previous;previous = current;current = next;}linkedList.head = previous;}}

Output:

输出：

1 2 3
3 2 1

递归反向链接列表 (Reverse a Linked List Recursively)

To reverse a LinkedList recursively we need to divide the LinkedList into two parts: head and remaining.
Head points to the first element initially. Remaining points to the next element from the head.

要递归地反转LinkedList，我们需要将LinkedList分为两部分：头部分和剩余部分。
Head最初指向第一个元素。 其余部分指向头部的下一个元素。

Following is the illustration of the above procedure.

以下是上述过程的说明。

The Java program to reverse a LinkedList recursively is:

递归地反转LinkedList的Java程序是：

public static Node recursiveReverse(Node head) {Node first;if (head==null || head.next == null)return head;first = recursiveReverse(head.next);head.next.next = head;head.next = null;return first;
}

We just pass the head.next in the recursive call in order to go to the end of the LinkedList.

我们只需在递归调用中传递head.next即可到达LinkedList的末尾。

Once we reach the end, we set the second last element as the next of the last element and set the next pointer of second last element to NULL. The last element will be marked as the new head.

一旦到达末尾，就将倒数第二个元素设置为倒数第二个元素，并将倒数第二个元素的下一个指针设置为NULL。 最后一个元素将被标记为新头。

Use the following code to reverse the linked list using the recursive approach.

使用以下代码通过递归方法来反向链接列表。

myLinkedList.head = recursiveReverse(myLinkedList.head);

The output will remain as the previous iterative approach.

输出将保留为以前的迭代方法。

反向链接列表的时空复杂性 (Space Time Complexity of Reversing a Linked List)

翻译自: https://www.journaldev.com/23035/reverse-a-linked-list

反向链接 反向代理