面试算法:单链表反转

给定一个单链表 list,请将它反转后返回,示例:

原链表:

反转链表:

定义的单链表结点类结构如下:

/**
 * 单向链表结点
 */
public class ListNode {

    public Integer value;

    public ListNode next;

    public ListNode() {

    }

    public ListNode(int value) {
        this.value = value;
    }
}

我们先写两个方法,用于组装成链表和将链表打印到控制台,方便进行算法结果验证:

/**
 * 组装成链表
 */
public ListNode assemble(int[] items) {
    if (items == null || items.length == 0) {
        return null;
    }

    ListNode list = new ListNode(items[0]);
    ListNode node = list;
    for (int i = 1; i < items.length; i++) {
        node.next = new ListNode(items[i]);
        node = node.next;
    }
    return list;
}
/**
 * 将链表打印到控制台
 */
public void print(ListNode list) {
    if (list == null) {
        System.out.print("<空>");
    }
    while (list != null) {
        System.out.print(list.value + " -> ");
        list = list.next;
    }
    System.out.println("null");
}

1. “栈”反转

“栈”是一种先进后出 (FILO)的数据结构,我们可以利用它的这个特性来实现反转链表。

1)先将链表结点顺序入栈:

2)然后开始将结点出栈,并逐一反转指针指向:

为了能在最后返回反转链表,我们给栈顶结点使用一个top结点引用来指向它,通过top结点,能够在完成反转链表后,按顺序访问到完整的反转链表的所有结点;此外,为了在出栈的时候,能反转指针指向,另外定义多两个结点prevrear,初始prevtop指向同一个结点栈顶结点,即反转链表的首结点。

  • 先将栈顶的原链表尾结点(反转链表首结点)5出栈:
  • 将结点4出栈(rear结点),并反转指针指向4 -> 55 -> 4,此时结点4指向NULL,即不指向任何一个实结点:
  • prev结点往后顺移一个结点位置,此时指向结点4,并将结点3出栈(rear结点),然后反转指针指向3 -> 44 -> 3
  • prev结点往后顺移一个结点位置,此时指向结点3,并将结点2出栈(rear结点),然后反转指针指向2 -> 33 -> 2
  • prev结点往后顺移一个结点位置,此时指向结点2,并将结点1出栈(rear结点),然后反转指针指向1 -> 22 -> 1
  • Done.

3)代码实现:

public ListNode reverseByStack(ListNode list) {
    // 结点为空,或者只有单结点,不需要反转
    if (list == null || list.next == null) {
        return list;
    }

    // Deque 双端队列可以实现“栈”数据结构功能
    Deque stack = new LinkedList<>();
    while (list != null) {
        // 逐一入栈:stack.addFirst(list);
        stack.push(list);
        list = list.next;
    }

    // 出栈栈顶结点
    ListNode top = stack.pop();
    ListNode prev = top, rear;
    while (!stack.isEmpty()) {
        // 逐一出栈:rear = stack.removeFirst();
        rear = stack.pop();

        // 反转指针
        prev.next = rear;
        rear.next = null;

        // prev 结点指针往后顺移一个结点位置
        prev = rear;
    }
    return top;
}

4)结果验证:

int[] items = IntStream.generate(() -> 1 + (int) (Math.random() * 50)).limit(8).toArray();
ListNode list = assemble(items);
System.out.print("原始单链表:");
print(list);

ListNode rlist = reverseByStack(list);
System.out.print("反转单链表:");
print(rlist);
原始单链表:16 -> 24 -> 48 -> 43 -> 4 -> 9 -> 47 -> 42 -> null
反转单链表:42 -> 47 -> 9 -> 4 -> 43 -> 48 -> 24 -> 16 -> null

2. 递归法

将原链表的结点按顺序一直递归到最后一层,也就是原链表的尾结点,将尾结点引用透传返回至递归方法第一层,在每一层里,将结点指针指向逆转,然后方法返回。注意:当链表长度太长时,这种方式会抛出 java.lang.StackOverflowError

1)将原链表的结点按顺序一直递归到最后一层,将尾结点5返回:

2)尾结点5透传返回,并在每一层中,反转指针指向:

尾结点5使用rlist引用指向它,注意在反转指针指向的时候,不能使用rlist引用来操作,因为在每一层递归中,rlist都要保证是往上“透传”的,也就是说它永远是5结点。

  • 反转指针指向4 -> 55 -> 4,此时结点4指向NULL,即不指向任何一个实结点:
  • 反转指针指向3 -> 44 -> 3
  • 反转指针指向2 -> 33 -> 2
  • 反转指针指向1 -> 22 -> 1
  • Done.

3)代码实现:

public ListNode reverseRecursively(ListNode list) {
    // 结点为空,或者只有单结点,不需要反转
    // 注意:递归函数的最后一层也会在这里返回:list.next == null
    if (list == null || list.next == null) {
        return list;
    }

    // 递归函数透传返回最后一个结点的引用到上一层
    ListNode rlist = reverseRecursively(list.next);
    // 在递归函数的每一层,rlist 引用透传返回上一层之前,反转当前递归层次的两个结点的指针指向,即原 list -> list.next 的反转为 list.next -> list
    list.next.next = list;
    list.next = null;
    return rlist;
}

4)结果验证:

int[] items = IntStream.generate(() -> 1 + (int) (Math.random() * 50)).limit(8).toArray();
ListNode list = assemble(items);
System.out.print("原始单链表:");
print(list);

ListNode rlist = reverseRecursively(list);
System.out.print("反转单链表:");
print(rlist);
原始单链表:44 -> 28 -> 3 -> 11 -> 49 -> 3 -> 20 -> 13 -> null
反转单链表:13 -> 20 -> 3 -> 49 -> 11 -> 3 -> 28 -> 44 -> null

3. 就地逆置(单指针法)

这种方法比较好理解,就是将链表的所有结点按顺序迭代,并且在每一次迭代时,调整指针指向。需要增加两个指针引用prevrear,分别用于定位当前链表结点的前一个结点和后一个结点,以方便进行指针指向调整操作。

1)定义prevrear结点引用,按顺序迭代链表结点:

  • 初始化prev指向NULLrear未指向任何结点:
  • rear指向2结点(当前结点list的下一结点),调整指针指向1 -> 21 -> NULL,并将prevlist往后顺移一个结点位置(此时prev指向1list指向2):
  • rear指向3结点(当前结点list的下一结点),调整指针指向2 -> 32 -> 1,并将prevlist往后顺移一个结点位置(此时prev指向2list指向3):
  • rear指向4结点(当前结点list的下一结点),调整指针指向3 -> 43 -> 2,并将prevlist往后顺移一个结点位置(此时prev指向3list指向4):
  • rear指向5结点(当前结点list的下一结点),调整指针指向4 -> 54 -> 3,并将prevlist往后顺移一个结点位置(此时prev指向4list指向5):
  • rear指向NULL结点(当前结点list的下一结点),调整指针指向5 -> NULL5 -> 4,并将prevlist往后顺移一个结点位置(此时prev指向5list指向NULL):
  • Done.

2)代码实现:

public ListNode reverseInSitu1(ListNode list) {
    // 结点为空,或者只有单结点,不需要反转
    if (list == null || list.next == null) {
        return list;
    }

    // list 为当前结点,prev 为 list 的前一个结点,rear 为 list 的后一个结点
    ListNode prev = null, rear;
    while (list != null) {
        // 1、暂存最后一步将要操作 list 结点指针往后顺移一个结点位置的 rear 结点引用(最后一步会赋值:list = rear;)
        rear = list.next;

        // 2、反转指针指向,即原 prev -> list 的反转为 list -> prev
        list.next = prev;

        // 3、prev 和 list 结点指针依次往后顺移一个结点位置
        prev = list;
        list = rear;
    }
    return prev;
}

3)结果验证:

int[] items = IntStream.generate(() -> 1 + (int) (Math.random() * 50)).limit(8).toArray();
ListNode list = assemble(items);
System.out.print("原始单链表:");
print(list);

ListNode rlist = reverseInSitu1(list);
System.out.print("反转单链表:");
print(rlist);
原始单链表:11 -> 12 -> 2 -> 15 -> 17 -> 38 -> 10 -> 1 -> null
反转单链表:1 -> 10 -> 38 -> 17 -> 15 -> 2 -> 12 -> 11 -> null

4. 就地逆置(双指针法)

这种方法跟上一种方法比较类似,不同的是,当前结点list在每一次迭代时,并不会往后顺移一个结点位置,而是指向rear结点(当前结点list的下下一结点),此方法比“单指针法”少一次迭代。需要增加两个指针引用prevrear,分别用于定位当前链表结点的前结点(初始等于当前结点)和后结点,以方便进行指针指向调整操作。

1)定义prevrear结点引用,按顺序迭代链表结点:

  • 初始化prev指向1(和list指向同一个结点),rear未指向任何结点:
  • rear指向3结点(当前结点list的下下一结点),调整指针指向2 -> 32 -> 1,将prev往后顺移一个结点位置(此时prev指向2),然后将list指针指向3(即1 -> 2调整为1 -> 3,打破上一个指针指向调整形成的1 -> 2 -> 1的“环”):
  • rear指向4结点(当前结点list的下下一结点),调整指针指向3 -> 43 -> 2,将prev往后顺移一个结点位置(此时prev指向3),然后将list指针指向4(即1 -> 3调整为1 -> 4,打破上一个指针指向调整形成的1 -> 3 -> 2 -> 1的“环”):
  • rear指向5结点(当前结点list的下下一结点),调整指针指向4 -> 54 -> 3,将prev往后顺移一个结点位置(此时prev指向4),然后将list指针指向5(即1 -> 4调整为1 -> 5,打破上一个指针指向调整形成的1 -> 4 -> 3 -> 2 -> 1的“环”):
  • rear指向NULL结点(当前结点list的下下一结点),调整指针指向5 -> NULL5 -> 4,将prev往后顺移一个结点位置(此时prev指向5),然后将list指针指向NULL(即1 -> 5调整为1 -> NULL,打破上一个指针指向调整形成的1 -> 5 -> 4 -> 3 -> 2 -> 1的“环”):
  • Done.

可以看到,“双指针法”的第一个指针用于反转指针指向,但这会形成一个“环”,而第二个指针就是为了打破这个环,同时指向下一个操作的结点(rear结点引用就是为了保存它,以便在每次迭代的最后一步中list可以找到并指向它)。

2)代码实现:

public ListNode reverseInSitu2(ListNode list) {
    // 结点为空,或者只有单结点,不需要反转
    if (list == null || list.next == null) {
        return list;
    }

    // list 为当前结点,prev 为 list 的前结点(初始等于当前结点),rear 为 list 的后结点
    ListNode prev = list, rear;
    while (list.next != null) {
        // 1、暂存最后一步将要操作 list -> rear 转向的 rear 结点引用(最后一步会赋值:list.next = rear;)
        rear = list.next.next;

        // 2、第 1 次调整指针指向(3 个结点之间的第 2 个指针),即原 list.next -> rear 的调整为 list.next -> prev,注意此步会形成“环”
        list.next.next = prev;

        // 3、prev 结点指针往后顺移一个结点位置,此时 prev 结点指针指向反转单链表的首结点
        prev = list.next;

        // 4、第 2 次调整指针指向(3 个结点之间的第 1 个指针),list 结点指针指向 rear 结点,即 list -> rear,此步用于打破第 2 步中形成的“环”
        list.next = rear;
    }
    return prev;
}

3)结果验证:

int[] items = IntStream.generate(() -> 1 + (int) (Math.random() * 50)).limit(8).toArray();
ListNode list = assemble(items);
System.out.print("原始单链表:");
print(list);

ListNode rlist = reverseInSitu2(list);
System.out.print("反转单链表:");
print(rlist);
原始单链表:25 -> 38 -> 50 -> 47 -> 16 -> 30 -> 27 -> 40 -> null
反转单链表:40 -> 27 -> 30 -> 16 -> 47 -> 50 -> 38 -> 25 -> null

5. 头插法

头插法是在每次插入新元素时,插入到一个被称为“头结点”的元素的后面的方法,在 JDK 7 的 java.util.HashMap 类中也有应用。

1)定义一个临时“头结点”tmpHeadrear结点引用,按顺序迭代链表结点,并将它们插入到tmpHead的后面:

  • 初始化临时头结点tmpHeadrear结点引用未指向任何结点:
  • rear指向2结点(当前结点list的下一结点),将结点1插入到tmpHead后面(结点NULL前面),将当前结点list往后顺移一个结点位置(此时list指向2):
  • rear指向3结点(当前结点list的下一结点),将结点2插入到tmpHead后面(结点1前面),将当前结点list往后顺移一个结点位置(此时list指向3):
head_2.png
  • rear指向4结点(当前结点list的下一结点),将结点3插入到tmpHead后面(结点2前面),将当前结点list往后顺移一个结点位置(此时list指向4):
  • rear指向5结点(当前结点list的下一结点),将结点4插入到tmpHead后面(结点3前面),将当前结点list往后顺移一个结点位置(此时list指向5):
  • rear指向NULL结点(当前结点list的下一结点),将结点5插入到tmpHead后面(结点4前面),将当前结点list往后顺移一个结点位置(此时list指向NULL):
  • Done.

2)代码实现:

public ListNode reverseByHeadInsertion(ListNode list) {
    // 结点为空,或者只有单结点,不需要反转
    if (list == null || list.next == null) {
        return list;
    }

    // list 为当前结点,tmpHead 为一个临时头结点,rear 为 list 的后一个结点
    ListNode tmpHead = new ListNode(), rear;
    while (list != null) {
        // 1、暂存最后一步将要操作 list 结点指针往后顺移一个结点位置的 rear 结点引用(最后一步会赋值:list = rear;)
        rear = list.next;

        // 2、向反转链表头部 tmpHead 后插入新结点(当前结点)
        list.next = tmpHead.next;
        tmpHead.next = list;

        // 3、当前结点 list 指针往后顺移一个结点位置
        list = rear;
    }
    return tmpHead.next;
}

3)结果验证:

int[] items = IntStream.generate(() -> 1 + (int) (Math.random() * 50)).limit(8).toArray();
ListNode list = assemble(items);
System.out.print("原始单链表:");
print(list);

ListNode rlist = reverseByHeadInsertion(list);
System.out.print("反转单链表:");
print(rlist);
原始单链表:6 -> 24 -> 39 -> 7 -> 27 -> 37 -> 22 -> 36 -> null
反转单链表:36 -> 22 -> 37 -> 27 -> 7 -> 39 -> 24 -> 6 -> null

你可能感兴趣的:(面试算法:单链表反转)