剑指 Offer 24. 反转链表 （Java）---张麻花

剑指 Offer 24. 反转链表
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

限制：0 <= 节点个数 <= 5000
思路一：
一看是翻转我首先想到了栈，虽然比较麻烦，但还是能做出来。
思路很简单，想把链表元素压入栈，再从栈中取出，构成链表，最后表尾指向null就可以。
注意
**每次出栈时一定要判断栈是否为空！**由于我一开始没判断，怎么测试都不通过，浪费了好长时间。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
 public ListNode reverseList(ListNode head) {
      //if (head == null) return head; 可以用这个测试，链表要是不为空，那栈肯定不为空
        Stack<ListNode> stack = new Stack<>();
        while(head!=null){
            stack.push(head);
            head=head.next;
        }
        if(stack.empty()){
            return null;
        }//还可以后来测试，如果栈为空的话，就没有下面的出栈操作了
        ListNode f=stack.pop();
        ListNode s=f;
        while(!stack.empty()){
            ListNode t=stack.pop();
            s.next=t;
            s=s.next;
        }
        s.next=null;
        return f;
    }
}

思路二：利用指针，非常巧妙（未打）~

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null, cur = head, next = null;
        while(cur != null) {
            next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
}

思路三：利用递归的思想（未打）

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }
        ListNode node = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return node;
    }
}