首页 > 试题广场 > 从尾到头打印链表
[编程题]从尾到头打印链表
输入一个链表,按链表值从尾到头的顺序返回一个ArrayList。

50个回答

添加回答
推荐
方法一:链表从尾到头输出,利
   查看全部
编辑于 2015-06-18 16:53:34 回复(50)
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        res = []
        tmp = listNode
        while tmp:
            res.insert(0, tmp.val)
            tmp = tmp.next
        return res
我的垃圾代码,像坨💩
发表于 2018-10-14 20:39:01 回复(0)

Method 1:

# -*- 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 []
        resList = []
        ptr = listNode
        while ptr is not None:
            resList.append(ptr.val)
            ptr = ptr.next
        return resList[::-1]

Method 2:

# -*- 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 []
        # 先通过遍历计算链表长度
        length = 0
        ptr = listNode
        while ptr is not None:
            length += 1
            ptr = ptr.next
        resList = [0] * length
        # 再遍历,获取各个节点的值,反向存入resList中
        ptr = listNode
        count = 1
        while ptr is not None:
            resList[length-count] = ptr.val
            ptr = ptr.next
            count += 1
        return resList
编辑于 2018-10-11 15:00:54 回复(0)
请教一个问题:
为什么写
if listNode.val == None:
    return []
会报错

而这样写则正确:
if listNode is None:
    return []

发表于 2018-10-11 11:55:05 回复(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=[]
        temp = listNode
        while temp:
            list.append(temp.val)
            temp=temp.next
        list.reverse()
        return list


发表于 2018-10-08 13:45:03 回复(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):
        l = list()
        if not listNode:
            return l
        while listNode:
            l.append(listNode.val)
            listNode = listNode.next
        
        return l[::-1]
先存进一个list,再切片
发表于 2018-09-18 22:47:02 回复(0)
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        li=[]
        while listNode!=None:
            li.append(listNode.val)
            listNode=listNode.next
        return li[::-1]
感觉用python好赖皮,一堆自建函数可以用,哈哈

发表于 2018-09-11 21:23:50 回复(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 = []
        if listNode is None:
            return res
        while listNode is not None:
            res.append(listNode.val)
            listNode = listNode.next
        return res[::-1]
发表于 2018-09-02 10:26:50 回复(0)
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        if listNode is None:
            return []
        a=[]
        while(listNode is not None):
            a.append(listNode.val)
            listNode=listNode.next
        return a[-1::-1]

发表于 2018-08-27 18:35:50 回复(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 = []
        if listNode:
            while listNode != None:
                List.insert(0,listNode.val)
                listNode = listNode.next
                
            return List
        else:
            return List
发表于 2018-08-27 11:25:54 回复(0)
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        lst_back = []         #用来存储遍历的数值
        cur = listNode      #cur指向当前节点
        while cur != None :  #当cur指向的节点不为空
            lst_back.append(cur.val)  #牛客网默认是val变量成员,用其他错误
            cur = cur.next
        lst_back.reverse()
        return lst_back
发表于 2018-08-27 09:27:05 回复(0)
使用递归的方式遍历链表,到最后一个节点的时候把返回的节点值存到结果list中,因为这样第一个节点无法返回所以要先做一个哑结点指向头结点
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        self.stack = []
        def travel(head):
            if not head: return
            if not head.next: return head
            x = travel(head.next)
            self.stack.append(x.val)
            return head
        dimmy = ListNode(-1)
        dimmy.next = listNode
        travel(dimmy)
        return self.stack


发表于 2018-08-27 08:47:33 回复(0)
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
        a = []
        cur = listNode
        while cur is not None:
            a.append(cur.val)
            cur = cur.next
        a.reverse()
        return a

发表于 2018-08-23 15:39:47 回复(0)

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

发表于 2018-08-14 20:55:45 回复(0)

Python
把node依序加入,最后回传一个反转后的数组即可。

def printListFromTailToHead(self, listNode):
    reverse = []
    current = listNode
    while current:
        reverse.append(current.val)
        current = current.next
    return reverse[::-1]


Javascript
一样loop过每个node,差别在loop时就加入数组,使用unshift的方式重前面插入node的值。
function printListFromTailToHead(head) {
    let current = head, reversed = [];
    while(current){
        reversed.unshift(current.val);
        current = current.next;
    }
    return reversed;
}
编辑于 2018-07-11 10:19:21 回复(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):
        arrayList = []
        while listNode:
            arrayList.append(listNode.val)
            listNode = listNode.next
        return arrayList[::-1]
编辑于 2018-10-07 15:28:02 回复(0)
这样做不知道面试官给不给过
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        res = []
        while listNode:
            res.append(listNode.val)
            listNode = listNode.next
        return res[::-1]
发表于 2018-05-28 20:54: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
        lis = []
        if listNode is None:
            return []
        while listNode.next != None:
            lis.append(listNode.val)
            listNode = listNode.next
        lis.append(listNode.val)
        return lis[::-1]

发表于 2018-05-06 16:09:30 回复(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
        out=[]
        p=listNode
        if p==None:
            return out
        while p!=None:
            out.append(p.val)
            p=p.next
        out.reverse()  
        return out

发表于 2018-05-03 00:05:58 回复(0)
class Solution:
    def printListFromTailToHead(self, listNode):
        valis = []
        while listNode:
            valis.append(listNode.val)
            listNode = listNode.next
        valis.reverse()
        return valis

发表于 2018-04-19 13:42:12 回复(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
        result = []
        if listNode == None:
            return result
        else:
            result.append(listNode.val)
            while listNode.next != None:
                listNode = listNode.next
                result.append(listNode.val)
        return result[::-1]

栈的思想啊,不过我用的列表反转

编辑于 2018-04-03 11:43:34 回复(0)

问题信息

难度:
50条回答 240122浏览

热门推荐

通过挑战的用户

查看代码

扫一扫,把题目装进口袋

牛客网,程序员必备求职神器

扫描二维码,进入QQ群

扫描二维码,关注牛客网公众号