剑指offer 06：从尾到头打印单链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：

输入：head = [1,3,2] 输出：[2,3,1]

单链表结构如下：

struct ListNode 
{
     int val;
     struct ListNode *next;
 };

解法一：时间复杂度和空间复杂度都为O(n)。
不用修改链表的结构。
先计算出链表中的结点个数，然后开辟一个和链表节点个数相同的数组空间，将链表中每个结点的数据域的值放到数组中然后再将数组的地址返回即可。

C语言代码如下：

int* reversePrint(struct ListNode* head, int* returnSize){
    struct ListNode*p=head;
    int count=0;
    int i;
    while(p)
    {
        count+=1;
        p=p->next;
    }
    int *arr=(int *)malloc(sizeof(int)*count);
    for(i=0;i<count;i++)
    {
        arr[i]=0;
    }
    i-=1;
    p=head;
    while(p)
    {
        arr[i]=p->val;
        i--;
        p=p->next;
    }
    *returnSize=count;
    return arr;
}

c++代码如下：

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {

        vector<int> nums;

        ListNode* p = head;

        while(p )
        {
            nums.push_back(p->val);

            p = p->next;
        }
        reverse(nums.begin(), nums.end());
        return nums;
    }
};

解法二：时间复杂度和空间复杂度都为O(n).
这种方法需要将单链表逆置修改了单链表原来的结构。

如果在面试中我们需要向面试官询问清楚是否允许我们修改原来的链表结构，根据要求选择合适的解题方法。

调用将单链表逆置的函数，然后将新的链表从头到尾打印其数据域的值即可。

struct ListNode* reverse(struct ListNode* head)
 {
     if(head==NULL||head->next==NULL) return head;
     struct ListNode* q=NULL;
     struct ListNode* p=head;
     while(p)
     {
         struct ListNode* tmp=p->next;
         p->next=q;
         q=p;
         p=tmp;
     }
     return q;
 }
int* reversePrint(struct ListNode* head, int* returnSize){
    struct ListNode* p=head;
    int count=0;
    int i;
    while(p)
    {
        count+=1;
        p=p->next;
    }
    *returnSize=count;
    int *arr=(int *)malloc(sizeof(int)*count);
    for(i=0;i<count;i++)
    {
        arr[i]=0;
    }
    i=0;
    p=reverse(head);
    while(p)
    {
        arr[i]=p->val;
        p=p->next;
        i++;
    }
    return arr;
}

解法三：还可以使用STL中的栈（利用其先进后出的特点）来解决，但和上面两种方法一样都时间和空间复杂度都为O(n)。

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> res;
        stack<int> st;
        while(head)
        {
            st.push(head->val);
            head=head->next;
        }
        while(!st.empty())
        {
            res.push_back(st.top());
            st.pop();
        }
        return res;
    }
};

解法四：递归

class Solution {
public:
vector<int> res;
    vector<int> reversePrint(ListNode* head) {
        if(head == nullptr)
            return res;
        reversePrint(head->next);
        res.push_back(head->val);
        return res;
    }
};

void reversePrint(ListNode* head)
{
	if(head!=nullptr)
	{
		if(head->next!=nullptr)
		{
			reversePrint(head->next);
		}
		cout<<head->val<<" ";
	}
}