Java面试题之单链表反转
引言
这是一道很经典的“单链表逆序”问题。我去面试曾经碰到过两次。有一个公司明确题目要求不能使用额外的节点存储空间，有一个没有明确说明，但是都需要写出来数据结构。那时候也都是死记硬背的网上的答案，现在回顾一下。
参考博文:
死记硬背（内容提取）
此项适合复习时间短，需要回报大的童鞋，如需理解，请继续全篇查看本文章。
public static void main(String[] args) {
Node a = new Node(1);
Node b = new Node(2);
Node c = new Node(3);
Node d = new Node(4);
Node e = new Node(5);
a.setNext(b);
b.setNext(c);
c.setNext(d);
d.setNext(e);
System.out.println(a);/*data=1-->data=2-->data=3-->data=4-->data=5-->null*/
Node reverse = reverse(a);/*递归方式反转*/
System.out.println(reverse);/*data=5-->data=4-->data=3-->data=2-->data=1-->null*/
}class Node{
private Node next;
private int data;
public Node(int data) {
this.data = data;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
@Override
public String toString() {
return "data=" + data + "-->"+next;
}
}private static Node reverse(Node head) {
/*如果是空链或者只是单个节点的链表 将直接返回*/
if(head == null || head.getNext() ==null) {
return head;
}
Node reverse = reverse(head.getNext());/*找到了最后一个 也就是5 当前head为4 reverse为5*/
head.getNext().setNext(head);/* 1-->2-->3-->4-->5 变为 5-->4 1-->2-->3-->4 此时4指向5 5 也指向4*/
head.setNext(null); /*4-->null 5-->4-->null 1-->2-->3-->4 */
return reverse; /*返回5-->4-->null*/
}什么是单链表
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 ——–百度百科
先手写一个单链表的数据结构
class Node{
private Node next;
private int data;
public Node(int data) {
this.data = data;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
@Override
public String toString() {
return "data=" + data + "-->"+next;
}
}面试题而已，就没写多复杂，想很全面的话可以参考LinkedList，其本身就是一个链表（JDK9中是一个双向链表），下面是他的节点类。
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}第一步:新建链表
先构造各个链表节点，再通过setNext将其链接起来
public static void main(String[] args) {
Node a = new Node(1);
Node b = new Node(2);
Node c = new Node(3);
Node d = new Node(4);
Node e = new Node(5);
a.setNext(b);
b.setNext(c);
c.setNext(d);
d.setNext(e);
System.out.println(a);/*data=1-->data=2-->data=3-->data=4-->data=5-->null*/
Node reverse = reverse(a);/*递归方式反转*/
System.out.println(reverse);/*data=5-->data=4-->data=3-->data=2-->data=1-->null*/
Node reverse2 = reverse2(reverse);/*非递归方式反转（将之前反转后的单链表反转回来）*/
System.out.println(reverse2);/*data=1-->data=2-->data=3-->data=4-->data=5-->null*/
}初始单链表如下图：
第二步:反转链表
方法一:递归
递归的思想非常简单，就是从头结点找到尾节点，然后从尾节点往回走，再将当节点的下一个节点的next设置为当前节点。
private static Node reverse(Node head) {
/*如果是空链或者只是单个节点的链表 将直接返回*/
if(head == null || head.getNext() ==null) {
return head;
}
Node reverse = reverse(head.getNext());/*找到了最后一个 也就是5 当前head为4 reverse为5*/
head.getNext().setNext(head);/* 1-->2-->3-->4-->5 变为 5-->4 1-->2-->3-->4 此时4指向5 5 也指向4*/
head.setNext(null); /*4-->null 5-->4-->null 1-->2-->3-->4 */
return reverse; /*返回5-->4-->null*/
}程序运行流程如下：
一直递归，递归到尾节点，返回Node reverse5–>null
当前head为4，head.getNext().setNext(head); 4，5循环
head.setNext(null);
然后返回Node reverse 5–>4–>null
//当前head为3 此时3的next为4 3–>4 变为 4–>3
//3–>null
//返回5–>4–>3–>null
//当前head为2 此时2的next为3 2–>3 变为 3–>2
// 2–>null
//返回5–>4–>3–>2–>null
//当前head为1 此时1的next为2 1–>2 变为 2–>1
//1–>null
//反转完成，返回5–>4–>3–>2–>1–>null
方法二:非递归（临时存储）
刚开始就将第二个节点的next置为第一个 通过临时值获取到旧的next 以此类推
public static Node reverse2(Node head) {
if (head == null)
return head;
Node pre = head;// 上一结点 data=5-->data=4-->data=3-->data=2-->data=1-->null
Node cur = head.getNext();// 当前结点 data=4-->data=3-->data=2-->data=1-->null
Node tmp;// 临时结点，用于保存当前结点的指针域（即下一结点）
while (cur != null) {// 当前结点为null，说明位于尾结点
tmp = cur.getNext(); //data=3-->data=2-->data=1-->null
cur.setNext(pre);// 反转指针域的指向 data=4-->data=3-->data=2-->data=1-->null data=4不再指向data3 data=4-->data=5 此时 5也指向4
pre = cur; //前节点为 data=4-->data=5
cur = tmp; //当前为data=3-->data=2-->data=1-->null
}
// 最后将原链表的头节点的指针域置为null，还回新链表的头结点，即原链表的尾结点 data=1-->data=2-->data=3-->data=4-->data=5-->null
head.setNext(null); //否则5还是指向4 导致循环
return pre;
}程序运行流程如下：
开始 pre data=5–>data=4–>data=3–>data=2–>data=1–>null
cur data=4–>data=3–>data=2–>data=1–>null
temp data=3–>data=2–>data=1–>null
cur.setNext(pre);
//tmp —- data=2–>data=1–>null
//data=3不再指向data2 data=3–>data=4–>data=5
//前节点为data=3–>data=4–>data=5
//当前节点为data=2–>data=1–>null
//tmp —- data=1–>null
//data=2不再指向data1 data=2–>data=3–>data=4–>data=5
//前节点为data=2–>data=3–>data=4–>data=5
//当前节点为data=1–>null
//tmp —- null
//data=1不再指向null data=1–>data=2–>data=3–>data=4–>data=5
//前节点为data=1–>data=2–>data=3–>data=4–>data=5
//当前节点为null
//跳出循环 head.setNext(null);
总结
递归方法如果层数过深可能会引起栈溢出，而非递归方法是使用了临时变量来存储数据。面试如果没有太多要求的话建议使用递归，可以节约内存的使用。
