8 从尾到头打印链表--剑指offer--python实现

1. 题目描述

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

2. 题目解析

2.1 考察问题

  本题考察的是链表的遍历和倒序问题。
  由于要返回一个list，因此空间复杂度是$O(n)$，这个不必优化。

2.2 解决方法

1. 从头到尾add到list，reverse返回
     新建一个list，从头到尾遍历添加，然后执行list倒转，返回list。
     时间复杂度$O(n)$，空间复杂度$O(n)$
2. 递归打印
     从尾到头打印一个链表，等同于先打印head的next，然后在打印head。因此可以使用递归输出。
     时间复杂度$O(n)$，空间复杂度$O(n)$
3. 链表逆序，从头到尾添加到list
     先对链表进行逆序操作，然后从头到尾依次添加到list。
     时间复杂度$O(n)$，空间复杂度$O(n)$
4. 利用栈结构，先push 再pop到list
     时间复杂度$O(n)$，空间复杂度$O(n)$

2.3 优化分析

  所有操作的时间复杂度和空间复杂度量级上是一致的，最好的方式我理解是递归方法，其次是链表逆序。

3. 代码实现

3.1 从头到尾add到list，reverse返回

 -*- coding:utf-8 -*-
 class ListNode:
     def __init__(self, x):
         self.val = x
         self.next = None

class Solution:
    def printListFromTailToHead(self, listNode):
        # write code here
        if not listNode:## 为空则输出空
            return []
        list_result = []
        while listNode:
            list_result.append(listNode.val)
            listNode = listNode.next## 从头到尾添加
        list_result.reverse()## 逆序
        return list_result## 输出

3.2 递归方式

 -*- coding:utf-8 -*-
 class ListNode:
     def __init__(self, x):
         self.val = x
         self.next = None

class Solution:
    def __init__(self):
        self.list_r = []
    def printListFromTailToHead(self, listNode):
        # write code here
        if listNode:##
            if listNode.next:
                self.printListFromTailToHead(listNode.next)
            self.list_r.append(listNode.val)
        return self.list_r

3.3 链表逆序

class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def __init__(self):
        self.list_r = []
    def printListFromTailToHead(self, listNode):
        # write code here
        if not listNode:
            return self.list_r
        prev = None
        while listNode:### 逆序
            temp = listNode.next
            listNode.next = prev
            prev = listNode
            listNode = temp
        while prev:### 输出
            self.list_r.append(prev.val)
            prev = prev.next
        return self.list_r

4. 心得

  链表的操作和数组和字符串类似，都有很多固有的操作，比如单链表的逆序。我在练习过程中需要积累这些操作，然后固化下来，作为后续算法问题的根基。