剑指Offer - 从尾到头打印链表 （C/C++， Java， Python 2.x 实现）

 

题目描述

输入一个链表，从尾到头打印链表每个节点的值。

 

注意：此题目没有头结点，就是head指针指向的节点是第一个保存val值得节点。

 

思路：按顺序遍历即可，注意是逆序存储

这里有个考点是：链表逆序，参见C++解法二。

C/C++    运行时间：3ms    占用内存：364k

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution
{
public:
    vector<int> printListFromTailToHead(ListNode* head)
    {
        vector<int> mid;
        ListNode* p = head;
        while(p != NULL)
        {
            //mid.push_back(p->next->val);    //此为 在动态数组尾部 插入数据
            mid.insert(mid.begin(), p->val);  //此为 在头部插入数据
            p = p->next;
        }
        return mid;
    }
};

C++解法二：链表逆序

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> res;
        if(head==NULL) return res;  //空链表直接返回空vector
        
        ListNode *p = head, *q = NULL, *r = NULL;
        if(p)  // p指针用来改变指向：由指向后面的改为指向前面的
            q = p->next;
        if(q)  // q指针为暂存上面p指针指向的元素，不暂存会断链
            r = q->next;
        while(q)
        {
            q->next = p;  //改变指向
            p = q;  // p指针后移
            q = r;  // q指针后移
            if(r) r = r->next;  // 若r能后移，再后移
        }

        head->next = NULL;  // 转置之后head为尾结点，指针置空，且p节点为转置后的头结点
        while(p)  // 按转置后的顺序遍历一遍即可
        {
            res.push_back(p->val);
            p = p->next;
        }
        return res;
    }
};

C++ 解法三：递归

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution
{
public:
    vector<int> mid;
    vector<int> printListFromTailToHead(ListNode* head)
    {
        if(head != NULL)
        {
            printListFromTailToHead(head->next);
            mid.push_back(head->val);
        }
        return mid;
    }
};

Java

 

递归实现：    运行时间：22ms    占用内存：9400k

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
public class Solution
{
    ArrayList<Integer> a = new ArrayList<Integer>();    //注意：需要把数组定义在外面
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode)
    {
        if(listNode != null)
        {
            printListFromTailToHead(listNode.next);    //递归
            a.add(listNode.val);
        }  
        return a;
    }
}

非递归实现（需要import java.util.Collections; 调用其reverse()方法逆序）：    运行时间：30ms    占用内存：9528k

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
import java.util.Collections;    //注意：需要import这个类
public class Solution
{
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode)
    {
        ArrayList<Integer> mid = new ArrayList();
        while(listNode != null)
        {
            mid.add(listNode.val);
            listNode = listNode.next;
        }
        Collections.reverse(mid);
        return mid;
    }
}

Python 2.x    运行时间：27ms    占用内存：5732k

# -*- 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 != None:
            res.append(listNode.val)
            listNode = listNode.next
        res.reverse()    #逆序！ 注意：此处不能直接 return res.reverse()，因为reverse()方法是有返回值的
        return res