方法一：运用栈：

根据栈的特点是后进先出，即最后压入栈的元素最先得到，考虑到栈的这一特点，使用栈将链表的元素顺序倒置。从链表头节点开始，依次将每个节点压入栈内，然后依次弹出栈内的元素并存储到数组中。

  • 创建一个栈，用于存储链表的节点
  • 创建一个指针，初始时指向链表的头节点
  • 当指针指向的元素非空时，重复下列操作：
    • 将指针指向的节点压入栈内
    • 将指针移到当前节点的下一个节点
  • 获得栈的大小 size，创建一个数组 print，其大小为 size
  • 创建下标并初始化 index = 0
  • 重复 size 次下列操作：
    • 从栈内弹出一个节点，将该节点的值存到 print[index]
    • 将 index 的值加 1

 

 

 

方法二。链表反转


 2  * Definition for singly-linked list.
 3  * struct ListNode {
 4  *     int val;
 5  *     struct ListNode *next;
 6  * };
 7  */
 8 
 9 
10 /**
11  * Note: The returned array must be malloced, assume caller calls free().
12  */
13 int* reversePrint(struct ListNode* head, int* returnSize){
14     if(head==NULL)
15     {
16         *returnSize=0;
17         return 0;
18     }
19     int n=0,i;
20     struct ListNode *p=head;             //创建一个指针初始时指向链表的头节点
21     while(p!=NULL)
22     {
23         n++;
24         p=p->next;
25     }
26     int *a=(int*)calloc(n,sizeof(int));  //创建一个数组，大小为n
27     for(i=0;i<n;i++)
28     {
29         a[n-1-i]=head->val;
30         head=head->next;
31     }
32     *returnSize=n;
33     return a;
34 }

方法二：递归

关于递归的方法是看见一位大佬写的，觉得很厉害。给大家分享一下。

 1 int* reversePrint(struct ListNode* head, int* returnSize){
 2     if(head == NULL){
 3         *returnSize = 0;
 4         return malloc(sizeof(int) * 10000);
 5     }
 6     int *ans = reversePrint(head->next, returnSize);
 7     ans[(*returnSize)++] = head->val;
 8     return ans;
 9 }
10 
11 作者：ning-junzhi
12 链接：https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/solution/c-jian-dan-yi-dong-de-jie-fa-by-ning-junzhi/
13 来源：力扣（LeetCode）
14 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。