反转链表的三种不同实现

1、利用栈，将链表一个个拆开，放到一个栈中，然后再从栈中一个个拿出来，组成新的链表，实现链表的反转。

public ListNode ReverseList(ListNode head) {
    1、创建一个栈
        Stack<ListNode> stack= new Stack<>();
    2、当头节点不为空时，拆分链表，将节点一个个放到栈中。
        //把链表节点全部摘掉放到栈中
        while (head != null) {
            stack.push(head);
            head = head.next;
        }
    3、判断，如果栈为空，说明是空链表，直接返回null
        if (stack.isEmpty())
            return null;
    4、先取出来一个节点作为头节点
        ListNode node = stack.pop();
        ListNode dummy = node;
    5、栈中的结点全部出栈，然后重新连成一个新的链表
        while (!stack.isEmpty()) {
            ListNode tempNode = stack.pop();
            node.next = tempNode;
            node = node.next;
        }
    6、最后一个结点就是反转前的头结点，一定要让他的next
        //等于空，否则会构成环
        node.next = null;
        return dummy;
    }

2、遍历链表，一个一个拆开，然后将新拆开的放在新链表的表头，以此类推。

public ListNode ReverseList(ListNode head) {
    1、先创建一个新链表的表头指针，它永远指向表头。
        ListNode newHead = null;
    2、创建一个临时节点，用于存放剩下的链表的头节点。
        ListNode temp = null;
        while (head != null){
            3、先保存剩下的节点
            temp = head.next;
            4、将旧的头节点的下一个节点指向新的链表的表头，将它们串起来
            head.next = newHead;
            5、head节点赋给新链表的表头
            newHead = head;
            6、head重新指向旧链表的表头
            head = temp;
        }
        return newHead;
    }

3、采用递归实现，首先每次递归之前都要保存当前节点的下一个节点然后递归找到最后一个节点，并将其作为头节点返回之后就以此将倒数第二、第三、第四的节点拼接到后面

public ListNode ReverseList(ListNode head) {
        //首先写出递归终止条件
        if (head == null || head.next == null){
            return head;
        }
        //当不符合终止条件时，先保存当前节点的下一个节点，再递归查找下一个
        ListNode temp = head.next;
        //递归查询
        ListNode reverse = ReverseList(temp);
        //当找到最后一个并返回时,将上一个节点拼接到该节点后面
        temp.next = head;
        //并将尾节点的指向置空
        head.next = null;
        //返回新的头节点
        return reverse;
    }