首页 > 试题广场 > 从尾到头打印链表
[编程题]从尾到头打印链表
输入一个链表,按链表值从尾到头的顺序返回一个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 回复(63)
遍历链表中的每一个数,先取第一个: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)
# -*- 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=[]
        listNode1=listNode
        if listNode1 != None:
            while True:
                x=listNode.val
                a.append(x)
                listNode=listNode.next
                if listNode == None:
                    #return a.reverse()
                    break
        else:
            return []
        a.reverse()
        print(a)
        return a

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

class Solution:

# 返回从尾部到头部的列表值序列,例如[1,2,3]
def printListFromTailToHead(self, listNode):
    # write code here
    tempstack = []
    while (listNode is not None):
        tempstack.insert(0, listNode.val)
        listNode = listNode.next
    return tempstack
发表于 2019-06-10 16:10:36 回复(0)

Python版:

class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        ans = []
        while listNode != None:
            ans.append(listNode.val)
            listNode = listNode.next
        return ans[::-1]
发表于 2019-05-23 16:37:06 回复(0)
Python 实现:
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def __init__(self):
        self.l=[]
    def printListFromTailToHead(self, listNode):
        if listNode:
            self.printListFromTailToHead(listNode.next)
            self.l.append(listNode.val)
        else:
            pass
        return self.l
用递归,从最后一个节点开始往列表添加数据



发表于 2019-04-16 12:33:07 回复(0)
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def __init__(self):
        self.lists = [] # 返回的ArrayList
    def printListFromTailToHead(self, listNode):
        # write code here
        if listNode != None:
            self.printListFromTailToHead(listNode.next)
            self.lists.append(listNode.val)
        return self.lists

发表于 2019-03-24 01:59:50 回复(1)
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
        res=[]
        while listNode:
            res.append(listNode.val)
            listNode=listNode.next
        return res[::-1]

发表于 2019-03-21 22:42:45 回复(0)
从头至尾将队列节点的值拿出来,然后倒一下
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        arr = []
        while listNode:
            arr.append(listNode.val)
            listNode = listNode.next
        return arr[::-1]

发表于 2019-03-18 09:28:47 回复(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
        list = []
        while listNode != None:
            temp = listNode.val
            list.append(temp)
            listNode = listNode.next 
        list.reverse()
        return list
但是不知道下面这样写为什么通不过,,小白求大神指导
class Solution: # 返回从尾部到头部的列表值序列,例如[1,2,3]  def printListFromTailToHead(self, listNode): # write code here  list = []
        list_new = [] while listNode != None:
            temp = listNode.val
            list.append(temp)
            listNode = listNode.next for i in range(len(list)):
            list_new = list.pop() return list_new








发表于 2019-03-16 16:31:44 回复(0)

先逆转链表,再遍历

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

发表于 2019-03-12 14:40:53 回复(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
        return list[::-1]
发表于 2019-03-06 22:32:18 回复(0)
def printListFromTailToHead(self, listNode):
        p = listNode
        list = []
        while p:
            list.append(p.val)
            p = p.next
        list.reverse()
        return list
发表于 2019-02-28 16:21:07 回复(0)
Attention:
Consider the NULL case.


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

class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        if listNode:
            x = listNode
            array = [x.val]
            while x.next != None:
                x = x.next
                array += [x.val]
            return array[::-1]
        else:
            return []
发表于 2019-02-12 00:15:18 回复(0)
# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

#思路1
# 1.先遍历链表元素到栈
# 2.栈再弹出
 
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        lst,lst_bak = [],[]
        if not listNode:
            return lst
        while listNode:
            lst.append(listNode.val)
            listNode = listNode.next
        while lst:
            lst_bak.append(lst.pop())
        return lst_bak
    #运行时间:22ms
    #占用内存:5632k


#思路3 先遍历,再反转
#class Solution:
#    def printListFromTailToHead(self,listNode):
#        l = []
#        if not listNode:
#            return l
#        while listNode:
#            l.append(listNode.val)
#            listNode = listNode.next
#        return l[::-1]
    #运行时间:21ms
    #占用内存:5852k


#思路2  递归
#class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
#    def printListFromTailToHead(self, listNode):
        # write code here
#        if listNode is None:
#         return []
#        return self.printListFromTailToHead(listNode.next) + [listNode.val]
    #运行时间:34ms
    #占用内存:5728k


发表于 2019-01-18 21:10:47 回复(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
        list_n = []
        while listNode!=None:
            list_n.append(listNode.val)
            listNode = listNode.next
        list_n.reverse()
        return list_n
这里用的是python代码写的,正序遍历一遍链表,然后用了内置函数reverse()逆序输出
发表于 2018-12-09 19:07:42 回复(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):
        if  listNode is None:
            return []
        return self.printListFromTailToHead(ListNode.next)+[listNode.val]
栈:
class Solution:
    # 返回从尾部到头部的列表值序列,例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        lst,lst_bak = [],[]
        if not listNode:
            return lst
        while listNode:
            lst.append(listNode.val)
            listNode = listNode.next
        while lst:
            lst_bak.append(lst.pop())
        return lst_bak
发表于 2018-11-13 23:38:52 回复(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=[]
        ptr = listNode
        while ptr != None:
            list.append(ptr.val)
            ptr = ptr.next # 将ptr往下一个元素移
            
        return list[::-1]
发表于 2018-11-13 10:00:12 回复(0)