首页 > 试题广场 > 从尾到头打印链表
[编程题]从尾到头打印链表
输入一个链表,按链表从尾到头的顺序返回一个ArrayList。
推荐
方法一:链表从尾到头输出,利用递归实现,不使用库函数直接printf输出的时候用递归比较好
/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(struct ListNode* head) {
        vector<int> value;
        if(head != NULL)
        {
            value.insert(value.begin(),head->val);
            if(head->next != NULL)
            {
                vector<int> tempVec = printListFromTailToHead(head->next);
                if(tempVec.size()>0)
                value.insert(value.begin(),tempVec.begin(),tempVec.end());  
            }         
            
        }
        return value;
    }
};
方法二:用库函数,每次扫描一个节点,将该结点数据存入vector中,如果该节点有下一节点,将下一节点数据直接插入vector最前面,直至遍历完,或者直接加在最后,最后调用reverse
/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(struct ListNode* head) {
        vector<int> value;
        if(head != NULL)
        {
            value.insert(value.begin(),head->val);
            while(head->next != NULL)
            {
                value.insert(value.begin(),head->next->val);
                head = head->next;
            }         
            
        }
        return value;
    }
};

编辑于 2015-06-18 16:53:34 回复(67)
分享两种方法,最简单的就是存到一个list里然后用栈的思想翻转list。这边再多加一个翻转链表的练习,只需要用一个list的空间完成。注释掉的是简单方法。
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self,listNode):
        # write code here
        '''
        re=[]
        while listNode!=None:
            re.append(listNode.val)
            listNode=listNode.next
        re1=[0 for _ in range(len(re))]
        for i in range(len(re)):
            re1[i]=re[len(re)-1-i]
        '''
        if listNode == None:
            return []
        p1 = listNode
        p2 = listNode.next
        p3 = None
        while (p2 != None):
            p3 = p2.next
            p2.next = p1
            p1 = p2
            p2 = p3
        p3=listNode
        listNode=p1
        p3.next=None
        re1 = []
        while listNode != None:
            re1.append(listNode.val)
            listNode = listNode.next
        return re1


发表于 2019-10-29 14:49:01 回复(0)
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        if not listNode:
            return []
        p=listNode
        res=[]
        while p:
            res.append(p.val)
            p=p.next
        return res[::-1]

发表于 2019-10-21 17:18:16 回复(0)
# -*- coding:utf-8 -*-
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        res=[]
        p=listNode
        while p:
            res.append(p.val)
            p=p.next
        res.reverse()
        return res

发表于 2019-10-12 13:52:56 回复(0)
用pytho的时候要注意其没有++和--的方法,只有x+=y形式。另外针对这种先进后出的形式多考虑是栈
发表于 2019-10-08 20:18:33 回复(0)

学习了python的链表表示。
Python有自带的链表逆转方法。

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

class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        if listNode == None:
            return []
        l = []
        while listNode != None:
            l.append(listNode.val)
            listNode = listNode.next
        return l[::-1]
发表于 2019-09-29 16:18:23 回复(0)
从尾到头,即最后的值要放在最前面,所以在遍历链表时要将数值放在开始的位置,
发表于 2019-09-29 10:59:01 回复(0)
# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        list_ =[]
        while listNode != None:
            list_.append(listNode.val)
            listNode = listNode.next
        list_.reverse()
        return list_

先创建一个空列表
while 循环判断链表是否为None
不是None则将当前链表的值添加到列表中
然后将当前链表修改为链表的下一个
循环结束后调用列表内置函数reverse()反转列表
结果就将链表反转完成了
发表于 2019-09-05 08:43:16 回复(0)
基本想法就是,把它的数据直接从头到尾取出来,最后按倒序索引返回一个结果列表,即要求的结果。
发表于 2019-09-03 20:59:18 回复(0)
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        res = []
        p = listNode
        while p:
            res.append(p.val)
            p = p.next
        return res[::-1]

都有题目解法
发表于 2019-08-25 21:32:19 回复(0)
python, 递归版本
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        if not listNode:
            return []
        res = []
        def ds(node):
            if node.next:
                ds(node.next)
            res.append(node.val)
        ds(listNode)
        return res


发表于 2019-08-18 17:49:33 回复(0)
    递归大法,最简单的方法了吧。
# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        if listNode is None:
            return []
        BB=self.printListFromTailToHead(listNode.next)
        BB.append(listNode.val)
        return BB

发表于 2019-08-17 14:01:18 回复(0)
借助一个列表,把链表中的值全部存进列表中,再倒序输出
# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        ArrayList = []
        ArrayList_new = []
        while listNode != None:
            ArrayList_new.append(listNode.val)
            listNode = listNode.next
        ArrayList = ArrayList_new[: : -1]
        return ArrayList


编辑于 2019-08-10 16:38:39 回复(0)

运行时间:29ms

占用内存:5860k

python版本:
res=[]
 while listNode:
        res.append(listNode.val)
        listNode=listNode.next
return res[::-1]
发表于 2019-08-08 17:04:59 回复(0)
# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        if listNode is None:
            return []
        return self.printListFromTailToHead(listNode.next) + [listNode.val]

发表于 2019-08-03 13:31:08 回复(0)
    def printListFromTailToHead(self, listNode):
        # write code here
        res = []
        while listNode:
            res.append(listNode.val)
            listNode = listNode.next
        res.reverse()
        return res
发表于 2019-08-02 13:32:43 回复(0)
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    s = []    
    def printListFromTailToHead(self, listNode):
        # write code here
       # if !listNode:
        #    return listNode
        if listNode:
            self.printListFromTailToHead(listNode.next)
            self.s.append(listNode.val)
        return self.s
用Python实现的递归,求大佬查看什么问题,通过率是百分之十几,感觉是会把上次结果也保存下来???

发表于 2019-07-31 21:08:44 回复(0)
遍历链表中的每一个数,先取第一个:p = listNode ,该结点具有2个属性,一个可以取值:
p.val,一个指向下一个结点:p.next。取到第一个数后,把该结点的值插入到列表的开始位置:
result_list.insert(0,p.val),然后找下一个结点:p = p.next,再把该结点的值插入
到 result_list 中,如此重复,链表越往后的值在列表中越靠前,可以实现从尾到头的顺序
返回一个ArrayList。
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        # 先确定是否为空
        if not listNode:
            return []
        else:
            result_list = []
            p = listNode
            while p:
                result_list.insert(0,p.val)
                p = p.next
            return result_list

发表于 2019-07-12 15:13:36 回复(0)
# -*- coding:utf-8 -*-

class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        result = []
        while listNode:
            result.append(listNode.val)
            listNode = listNode.next
        return result[::-1]
            
        '''
        result = []
        while listNode is not None:
            result.insert(0, listNode.val)
            listNode = listNode.next
        return result
        '''
发表于 2019-07-07 10:52:59 回复(0)
思路1
class Solution:     # 返回从尾部到头部的列表值序列,例如[1,2,3]     def printListFromTailToHead(self, listNode):         # write code here         # 思路:从头打印到尾部 很容易 定个游标 一直移动就好 怎么反过来打印呢?list的头部添加 用insert         s = []         cur = listNode         while cur != None:             s.append(cur.val)             cur = cur.next         return s[::-1]
思路2:
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        # 思路:从头打印到尾部 很容易 定个游标 一直移动就好 怎么反过来打印呢?list的头部添加 用insert
        s = []
        cur = listNode
        while cur != None:
            s.insert(0, cur.val)
            cur = cur.next
        return s

发表于 2019-07-03 19:50:23 回复(0)
python思路:
相信也只有老司机才能想出🤔🤔
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        if not listNode:
            return []
        return self.printListFromTailToHead(listNode.next) + [listNode.val]

发表于 2019-06-23 20:52:52 回复(0)