[NewCode 5] 从尾到头打印链表

题目描述

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

题目比较水，一遍就 AC 了，来看代码：

/**

*  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> ret;

        printListFromTailToHead_help(head, ret);

        return ret;

	}

    

private:

    void printListFromTailToHead_help(struct ListNode *head, vector<int> &ret) {

        if (head == NULL) {

            return;

        }

        

        printListFromTailToHead_help(head->next, ret);

        ret.push_back(head->val);

    }

};

使用递归写起来就是简单，但是当链表非常长的时候，就会导致函数调用的层级较深，有可能会导致栈溢出，如下版本为非递归形式：

/**

*  struct ListNode {

*	    int val;

*	    struct ListNode *next;

*	    ListNode(int x) :

*			  val(x), next(NULL) {

*	    }

*  };

*/

class Solution {

public:

	vector<int> printListFromTailToHead(ListNode* head) {

		stack<ListNode *> stkNodes;

        while (head) {

            stkNodes.push(head);

            head = head->next;

        }

        

        vector<int> ret;

        while (!stkNodes.empty()) {

            ret.push_back(stkNodes.top()->val);

            stkNodes.pop();

        }

        

        return ret;

	}

};

其实，还有更无耻的方法也可以AC，就是按顺序压入vector中，最后使用迭代器反转一下，但是不建议使用这种方法：

/**

*  struct ListNode {

*	    int val;

*	    struct ListNode *next;

*	    ListNode(int x) :

*			  val(x), next(NULL) {

*	    }

*  };

*/

class Solution {

public:

	vector<int> printListFromTailToHead(ListNode* head) {

		vector<int> ret;

        while (head) {

            ret.push_back(head->val);

            head = head->next;

        }

        

        reverse(ret.begin(), ret.end());

        return ret;

	}

};