单链表是一种线性数据结构，由当前节点数据和指向下个节点的指针组成，因为是单向的，所以称为单链表

单链表的反转：

例如：1—>2—>3—>4 反转成：4—>3—>2—>1

首先定义一个链表的节点：

public class Node {

private int data;

private Node next;

public Node(int data) {

this.data = data;

next = null;

}

//添加节点

public Node addNode(Node node) {

next = node;

return node;

}

public void setNext(Node next) {

this.next = next;

}

public Node getNext() {

return next;

}

@Override

public String toString() {

return "Node{" +

"data=" + data +

", next=" + next +

'}';

}

}

方式一：遍历节点，反转每个节点，也叫头插法，因为节点依次插入了新链表的头部

因为单链表只有指向下一个节点的指针，没有指向上个节点的指针。所以我们可以定义个指针指向上个节点，这样我们遍历链表，把每个指向下个节点的指针，指向上个节点，这样每个节点都指向了上个节点，实现了反转。如下图所示：

preNode 指向上个节点，curNode指向当前节点，让curNode的next指向preNode,然后移动preNode 和 curNode ，这样最终以preNode为头结点，实现了单链表的反转

代码：

public Node reverse() {

if (this == null || this.next == null) {

return this;

}

//上个节点

Node preNode = null;

//当前节点

Node curNode = this;

while (curNode != null) {

//当前节点的下个节点

Node next = curNode.getNext();

//修改当前节点的下个节点，让其指向上个节点

curNode.setNext(preNode);

//上个节点移动到当前节点

preNode = curNode;

//当前节点移动到下个节点

curNode = next;

}

return preNode;

}

测试：

public class Test {

public static void main(String[] args) {

Node head = new Node(1);

head.addNode(new Node(2)).addNode(new Node(3));

System.out.println("反转前：" + head);

Node reverse = head.reverse();

System.out.println("反转后：" + reverse);

}

}

结果：

反转前：Node{data=1, next=Node{data=2, next=Node{data=3, next=null}}}

反转后：Node{data=3, next=Node{data=2, next=Node{data=1, next=null}}}

方式二：借助栈的特性，先进后出，实现单链表的反转

public static Node reverse2(Node head) {

if (head == null || head.next == null) {

return head;

}

Stack stack = new Stack<>();

while (head != null) {

stack.push(head);

head = head.getNext();

}

head = stack.pop();

//当前节点的位置

Node cur = head;

while (!stack.isEmpty()) {

Node node = stack.pop();

node.next = null;

cur.next = node;

cur = node;

}

return head;

}

方式三：递归

递归的方式理解起来，感觉有点困难

public static Node reverse3(Node head) {

if (head == null || head.next == null) {

return head;

}

Node prev = reverse3(head.next);

head.next.next = head;

head.next = null;

return prev;

}

测试

public class Test {

public static void main(String[] args) {

Node head = new Node(1);

head.addNode(new Node(2)).addNode(new Node(3));

System.out.println("反转前：" + head);

Node reverse = Node.reverse3(head);

System.out.println("反转后：" + reverse);

}

}

结果：

反转前：Node{data=1, next=Node{data=2, next=Node{data=3, next=null}}}

反转后：Node{data=3, next=Node{data=2, next=Node{data=1, next=null}}}