分享一个笔试常考的算法题，链表翻转（图文推导，快速理解）

题目描述

输入一个链表，反转链表后，输出新链表表头

核心考点

链表操作，思维缜密程度

方法 1： 双指针

1. 因为链表结尾是 null，所以让 pre 的值是 null, head 就表示我们的头部

   

2. 因为 head 的 next 成员马上就要指向 pre, 如果不保存 head 的下一个节点就会使其丢失，所以通过临时变量 t 保存它

   

3. 让 head 的 next 成员指向 pre

   

4. pre 移动到 head 的位置，head 移动到 t 的位置，此时我们就回到了第一步中的情况

   

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) {
           ListNode pre = null;
           while(head != null){ // 判断链表是否已经到结尾
                 ListNode t = head.next; // 保留下一个即将翻转的表头
                 head.next = pre;// 将现在要翻转的节点的后继指向前一个节点
                 pre = head;   // 现在的head成为下一个前继节点
                 head = t;   // head 成为下一个要翻转的节点
           }
           return pre;
    }
}

方法 2：利用栈的先进后出

把链表节点一个个入栈，当全部入栈完之后再一个个出栈，出栈的时候在把出栈的结点串成一个新的链表

import java.util.*;

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

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 over = node; // 保存新的表头 下面会将表头指向下一个元素 以防丢失表头
          while(!stack.isEmpty()){
            ListNode temp = stack.pop();
            node.next = temp;
            node = node.next;
          }
          //最后一个结点就是反转前的头结点，让他的next等于空，以免构成环
          node.next = null;
          return over;
    }
}