剑指offer-面试题6：从尾到头打印链表 解法

题目描述

输入一个链表，按链表从尾到头的顺序返回一个ArrayList

例如，有链表 2→4→5→8→3→null，将它从尾到头的顺序存入ArrayList：3，8，5，4，2

解法一（直接存入ArrayList）：

从头到尾遍历链表，并且每次将链表节点存储的数字添加到ArrayList的首位。这样就完成了链表的逆序，直接利用ArrayList的add(index,Integer)完成头插入操作

//方法一：简单的不断向ArrayList第一个元素位置插入数字
public ArrayList<Integer> printListFromTailToHead1(ListNode listNode)
{
    ArrayList<Integer> reversedPrint=new ArrayList<>(); //存储链表从尾到头的输出结果
    ListNode p=listNode; //用于从链表头结点开始遍历的指针
    while(p!=null)
    {
        reversedPrint.add(0,p.val);
        p=p.next;
    }
    return reversedPrint;
}

这种方法实现起来很简单，但有缺点：ArrayList的底层由数组实现，当向ArrayList的非尾部添加元素时，需要依次将所有插入位置后面的元素向后移动一步，而向头部添加元素时，原ArrayList所有的元素都要向后移动。不考虑数组溢出扩容的问题，也需要执行n(n+1)/2此移动操作，因此时间复杂度为O(n²)

解法二（利用栈实现逆序）：

栈的特性是数据的后进先出，可以将数据先依次入栈，在依次出栈，便得到了链表的逆序

import java.util.ArrayList;
import java.lang.Integer;
import java.util.Stack;

public class Solution {
    //使用栈实现顺序反转
    public ArrayList<Integer> printListFromTailToHead2(ListNode listNode)
    {
        ArrayList<Integer> reversedPrint=new ArrayList<>(); //存储链表从尾到头的输出结果
        Stack<Integer> stack=new Stack<>(); //用于实现顺序反转
        ListNode p=listNode; //用于从链表头结点开始遍历的指针
        while(p!=null) //数字入栈
        {
            stack.push(p.val);
            p=p.next;
        }
        while(!(stack.empty())) //数字出栈
        {
            reversedPrint.add(stack.pop());
        }
        return reversedPrint;
    }
}

时间复杂度：O(n)
由上题我们可以总结出一个经验：当需要得到逆序时，我们可以想到利用栈

解法三（递归实现逆序）：

既然想到了利用栈实现逆序，而递归本质上是由栈实现的，我们可以使用递归实现逆序：当递归访问到一个节点时，先递归进入它后面的节点，再将当前节点存入ArrayList

public class Solution {
    //使用递归完成顺序反转
    public ArrayList<Integer> printListFromTailToHead3(ListNode listNode)
    {
        ArrayList<Integer> reversedPrint=new ArrayList<>(); //存储链表从尾到头的输出结果
        if(listNode==null)
        {
            return reversedPrint;
        }
        this.recurFun(reversedPrint,listNode);
        return reversedPrint;
    }
    //被调用的递归方法
    public void recurFun(ArrayList<Integer> arrayList,ListNode p)
    {
        if(p.next!=null)
        {
            this.recurFun(arrayList,p.next);
        }
        arrayList.add(p.val);
    }
}

一般情况下，递归的代码会比相同功能的利用循环的代码简洁，但递归机制的消耗一般比循环大。在本题中，当链表很长时，会导致函数调用的层级很深，可能导致函数调用栈溢出

解法四（链表就地逆置）：

当允许改变给定链表的顺序结构时，我们可以使用链表的就地逆置

1. 检查链表长度，若链表节点数不大于1，可以直接返回链表
2. 若链表节点数大于等于2：定义三个指针p1、p2、p3，分别指向null、链表头结点和链表第二个节点
3. 让p2指向节点的next指向p1
4. p1指向p2，p2指向p3，p3指向p3当前指向节点的next
5. 若p3指向了null，将p2的next指向p1，结束程序;若p3指向的不是null，回到第3步循环

完成链表的就地逆置之后，将链表从头到尾遍历一遍，存入ArrayList

//使用链表就地逆置的方法
public ArrayList<Integer> printListFromTailToHead(ListNode listNode)
{
    ArrayList<Integer> reversedPrint=new ArrayList<>(); //存储链表从尾到头的输出结果
    //首先处理不适合就地逆置的两种情况：链表长度小于等于1
    if(listNode==null)
    {
        return reversedPrint;
    }
    else if(listNode.next==null)
    {
        reversedPrint.add(listNode.val);
        return reversedPrint;
    }
    ListNode p1=null,p2=listNode,p3=listNode.next;
    while(p3!=null)
    {
        p2.next=p1;
        p1=p2;
        p2=p3;
        p3=p3.next;
    }
    p2.next=p1;
    ListNode p=p2;
    while(p!=null)
    {
        reversedPrint.add(p.val);
        p=p.next;
    }
    return reversedPrint;
}