链表思路记录2.JZ24 反转链表

2.JZ24 反转链表

题目：
给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。

数据范围： 0≤n≤1000
要求：空间复杂度 O(1) ，时间复杂度 O(n) 。

如当输入链表{1,2,3}时，
经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。
以上转换过程如下图所示：

递归

我的思路：递归，哈哈哈，我好爱用递归，我这个小菜鸡
也就是题目里面范围不大才能用，还是得学一下别的方法。

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param head ListNode类
     * @return ListNode类
     */
    public ListNode ReverseList (ListNode head) {
        // write code here
        if (head != null && head.next != null) {
            ListNode next = head.next;
            head.next = null;
            return getHead(next, head);
        } else {
            return head;
        }
    }

    private ListNode getHead(ListNode head, ListNode beforeNode) {
        if (head != null && head.next != null) {
            ListNode next = head.next;
            head.next = beforeNode;
            return getHead(next, head);
        } else {
            head.next = beforeNode;
            return head;
        }
    }
}

下面介绍看的其他人的解法

栈

最简单的一种方式就是使用栈，因为栈是先进后出的。实现原理就是把链表节点一个个入栈，当全部入栈完之后再一个个出栈，出栈的时候在把出栈的结点串成一个新的链表。原理如下

import java.util.Stack;
public class Solution {
	public ListNode ReverseList(ListNode head) {
	    Stack<ListNode> stack= new Stack<>();
	    //把链表节点全部摘掉放到栈中
	    while (head != null) {
	        stack.push(head);
	        head = head.next;
	    }
	    if (stack.isEmpty())
	        return null;
	    ListNode node = stack.pop();
	    ListNode dummy = node;
	    //栈中的结点全部出栈，然后重新连成一个新的链表
	    while (!stack.isEmpty()) {
	        ListNode tempNode = stack.pop();
	        node.next = tempNode;
	        node = node.next;
	    }
	    //最后一个结点就是反转前的头结点，一定要让他的next
	    //等于空，否则会构成环
	    node.next = null;
	    return dummy;
	}
}

看完这个思路之后我写的代码：

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param head ListNode类
     * @return ListNode类
     */
    public ListNode ReverseList (ListNode head) {
        // write code here
        Stack<ListNode> stack = new Stack<>();
        while(head != null){
            //突然发现我居然用的是add，但在牛客通过了 stack.add(head);
            stack.push(head);
            head = head.next;
        }
        if(stack.isEmpty()){
            return null;
        }
        ListNode node = stack.pop();
        ListNode result = node;
        while(!stack.isEmpty()){
            ListNode next = stack.pop();
            node.next = next;
            node = next;
        }
        node.next = null;
        return result;
    }
}

双链表求解

双链表求解是把原链表的结点一个个摘掉，每次摘掉的链表都让他成为新的链表的头结点，然后更新新链表。下面以链表1→2→3→4为例画个图来看下。

public ListNode ReverseList(ListNode head) {
    //新链表
    ListNode newHead = null;
    while (head != null) {
        //先保存访问的节点的下一个节点，保存起来
        //留着下一步访问的
        ListNode temp = head.next;
        //每次访问的原链表节点都会成为新链表的头结点，
        //其实就是把新链表挂到访问的原链表节点的
        //后面就行了
        head.next = newHead;
        //更新新链表
        newHead = head;
        //重新赋值，继续访问
        head = temp;
    }
    //返回新链表
    return newHead;
}

看完别人的代码之后我写的：

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param head ListNode类
     * @return ListNode类
     */
    public ListNode ReverseList (ListNode head) {
        // write code here
        ListNode newList = null;
        while(head!=null){
            ListNode tmp = head;
            head = head.next;
            tmp.next = newList;
            newList = tmp;
        }
        return newList;
    }
}

双链表求解给我的感觉是看起来最整洁的，但是占用空间比前两种要大，在牛客跑出来的结果里面占用空间最少的居然是递归，对这里还没太想明白，我印象里递归会占用大量空间来着，难道是我记错了？递归会占用大量时间？
去瞅了眼记录，还真是，递归占用时间最多，双链表最快