Java版剑指offer编程题第15题--反转链表

跟learnjiawa一起每天一道算法编程题，既可以增强对常用API的熟悉能力，也能增强自己的编程能力和解决问题的能力。算法和数据结构，是基础中的基础，更是笔试的重中之重。

• 不积硅步，无以至千里；
• 不积小流，无以成江海。

题目描述

Java版剑指offer编程题第15题–反转链表： 输入一个链表，反转链表后，输出新链表的表头。

我的想法

• 一般反转问题首先可以想到的是用一个栈做中转站，因为栈先进后出，可以颠倒顺序。但是时间、空间花销都很大。这里不给出代码演示了。
• 链表反转一般标准解法是利用指针的移动，但是很多小伙伴看代码会看的晕乎乎的，所以我这里对着代码画了一张图，帮助小伙伴们理解，重点就是别将pre,head,next这三个指针和链表节点以及链表节点本身自带的next指针弄混了。
• 递归思想，先把头节点后面的部分反转，然后将头节点添加到末尾，这样不断递归下去。看了递归解法的代码，你可能会体会到递归解法的魅力，哈哈哈。

解题方法1

	//指针移动方法
    public static ListNode ReverseList1(ListNode head) {
		//head为指向当前节点的指针，如果当前节点为空的话，那就什么也不做，直接返回null；
        if(head==null)
            return null;
        //指向当前节点前一个节点的指针
        ListNode pre = null;
        //指向当前节点下一个节点的指针
        ListNode next = null;
		//循环部分的指针移动配合图片食用即可！
        while(head!=null){
            next = head.next;
            head.next = pre;
            pre = head;
            head = next;
        }
        //返回指向反转过后的链表首节点的指针
        return pre;
    }

指针跳转过程图示：

解题方法2

	//递归法
    public static ListNode ReverseList2(ListNode head) {
        //链表头节点为空或者只有一个节点，直接返回头节点
        if(head == null || head.next == null){
            return head;
        }
        //递归，先把头节点之后的链表部分反转
        ListNode reverseNode = ReverseList2(head.next);

        //将原头节点设置为后部分反转后链表的最后一个节点，
        //head.next.next 表示原链表的头节点的下一个节点的下一个节点
        //也就是反转后给反转部分的最后一个节点后面再加一个节点
        head.next.next = head;
        head.next = null;

        return reverseNode;
    }

代码测试

package com.learnjiawa.jzoffer;

import java.util.Stack;

/**
 * @author learnjiawa
 * 2019-12-14-9:38
 */
public class Solution15 {
    public static void main(String[] args) {
        ListNode listNode1 = new ListNode(1);
        ListNode listNode2 = new ListNode(2);
        ListNode listNode3 = new ListNode(3);
        ListNode listNode4 = new ListNode(4);
        ListNode listNode5 = new ListNode(5);

        listNode1.add(listNode2);
        listNode2.add(listNode3);
        listNode3.add(listNode4);
        listNode4.add(listNode5);
        ListNode temp = listNode1;
        System.out.println("创建链表如下：");
        while(temp != null){
            System.out.print(temp.val + " ");
            temp = temp.next;
        }
        System.out.println(" ");
        ListNode newHead = ReverseList1(listNode1);
        System.out.println("反转链表如下：");
        temp = newHead;
        while(temp != null){
            System.out.print(temp.val + " ");
            temp = temp.next;
        }
    }


    public static ListNode ReverseList1(ListNode head) {

        if(head==null)
            return null;
        //head为当前节点，如果当前节点为空的话，那就什么也不做，直接返回null；

        ListNode pre = null;
        ListNode next = null;

        while(head!=null){

            next = head.next;

            head.next = pre;

            pre = head;

            head = next;
        }

        return pre;
    }

    public static ListNode ReverseList2(ListNode head) {
        //链表头节点为空或者只有一个节点，直接返回头节点
        if(head == null || head.next == null){
            return head;
        }
        //递归，先把头节点之后的链表部分反转
        ListNode reverseNode = ReverseList2(head.next);

        //将原头节点设置为后部分反转后链表的最后一个节点，
        //head.next.next 表示原链表的头节点的下一个节点的下一个节点
        //也就是反转后给反转部分的最后一个节点后面再加一个节点
        head.next.next = head;
        head.next = null;

        return reverseNode;
    }
}
//节点类
class ListNode {
    int val;
    ListNode next = null;
    ListNode(int val) {
        this.val = val;
    }
}

代码测试控制台输出结果：

总结

反转链表，这里的两种解法我今天都收获很大哦，指针的跳转真的棒，递归思想真的秀，明天见啦！

参考文献

[1]程杰. 大话数据结构. 北京：清华大学出版社， 2011.

更多

对我的文章感兴趣，点个关注是对我最大的支持，持续更新中…
关注微信公众号LearnJava：