Leetcode算法—反转链表(迭代、递归、栈、双链表求解)

反转一个单链表

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

反转单链表这里用两种方式实现：递归和迭代
先了解一下递归和迭代的区别

第一、二种方式：迭代和递归

1、迭代和递归的区别

含义不同：
递归是重复调用函数自身实现循环。
迭代是函数内某段代码实现循环，循环代码中参与运算的变量同时是保存结果的变量，当前保存的结果作为下一次循环计算的初始值。

递归循环中，遇到满足终止条件的情况时逐层返回来结束。
迭代则使用计数器结束循环。

结构不同：
递归与迭代都是基于控制结构：迭代用重复结构，而递归用选择结构。
递归与迭代都涉及重复：迭代显式使用重复结构，而递归通过重复函数调用实现重复。
递归与迭代都涉及终止测试：迭代在循环条件失败时终止，递归在遇到基本情况时终止。迭代一直修改计数器，直到计数器值使循环条件失败；递归不断产生最初问题的简化副本，直到达到基本情况。

第一、二种方式：迭代和递归

从前往后遍历链表，将当前节点的next指向上一个节点，因此需要一个变量存储上一个节点prev，当前
节点处理完需要寻找下一个节点，因此需要一个变量保存当前节点curr，处理完后要将当前节点赋值给
prev，并将next指针赋值给curr，因此需要一个变量提前保存下一个节点的指针next

1. 将下一个节点指针保存到next变量 next = curr.next
2. 将下一个节点的指针指向prev，curr.next = prev
3. 准备处理下一个节点，将curr赋值给prev

第三种方式：栈

链表的反转是老生常谈的一个问题了，同时也是面试中常考的一道题。最简单的一种方式就是使用栈，因为栈是先进后出的。实现原理就是把链表节点一个个入栈，当全部入栈完之后再一个个出栈，出栈的时候在把出栈的结点串成一个新的链表。原理如下

第四种方式：双链表求解

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

package com.tuling.partone;

import java.util.Stack;

class ListNode {
    int val;
    ListNode next;

    ListNode(int val,ListNode node) {
        this.val = val;
        this.next=node;
    }
}
public class Test {

    //第一种方式：迭代
    public static ListNode ReverseList(ListNode head) {
        ListNode cur=head;
        ListNode prev=null;
        ListNode next;
        while(cur!=null){
            next=cur.next;
            cur.next=prev;
            prev=cur;
            cur=next;
        }
        return prev;
    }

    //第二种方式：递归
    public static ListNode recursion(ListNode head){
        if (head==null || head.next==null){
            return head;
        }
        ListNode resultNode = recursion(head.next);
        head.next.next=head;
        head.next=null;
        return resultNode;
    }

    //第三种方式：栈
    public static ListNode useStack(ListNode head){

        Stack stack=new Stack();
        //入栈  把链表节点全部放到栈中
        ListNode pushCur=head;
        while(pushCur!=null){
            stack.push(pushCur);
            pushCur=pushCur.next;
        }
        if (stack.isEmpty())
            return null;
        //出栈   栈中的结点全部出栈，然后重新连成一个新的链表
        ListNode tempNode= (ListNode) stack.pop();
        ListNode popCur = tempNode;
        while (stack.empty()!=true){
            popCur.next= (ListNode) stack.pop();
            popCur=popCur.next;
        }
        //最后一个结点就是反转前的头结点，一定要让他的next
        //等于空，否则会构成环
        popCur.next=null;
        return tempNode;
    }

    //第四种方式：双链表求解
    public static ListNode useTwoLinkedList(ListNode head){
        if (head==null){
            return null;
        }
        ListNode newHead=head;
        ListNode tmp=head.next;
        newHead.next=null;
        while(tmp!=null){
            //重新赋值，继续访问
            head=tmp;
            tmp=head.next;
            //每次访问的原链表节点都会成为新链表的头结点，
		        //其实就是把新链表挂到访问的原链表节点的
		        //后面就行了
            head.next=newHead;
            //更新新链表的头节点
            newHead=head;
        }
         //返回新链表
        return newHead;
    }

    public static void main(String[] args){
        ListNode node4=new ListNode(4,null);
        ListNode node3=new ListNode(3,node4);
        ListNode node2=new ListNode(2,node3);
        ListNode node1=new ListNode(1,node2);
        ListNode node=recursion(node1);
    }
}