（力扣） 00-從尾到頭打印鏈表

輸入一個鏈表的頭節點，從尾到頭反過來返回每個節點的值（用數組返回）。

重點：

局部變量在函數結束時會自動刪除，不能作爲返回值，需要使用malloc 或者 static 才能在函數返回時不被刪除

說到逆序 首先想到的就是遞歸，但是苦於作爲函數的局部變量在函數結束時會自動刪除，沒有想到解決辦法
看了別人的答案發現可以使用malloc 或者 static 解決

// 
int* reversePrint(struct ListNode* head, int* returnSize){
    if( head == NULL )
    {
        *returnSize = 0;
        return malloc(10000*sizeof(int));
    }
    int * res = reversePrint(head->next,returnSize);
    res[ (*returnSize)++] = head->val;
    return res;
}

基本步驟：

• 1、動態建立數組 用於作爲返回值；
• 2、讀取到數組
• 3、數組逆序

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


/**
 * Note: The returned array must be malloced, assume caller calls free().
 //返回值爲局部變量指針如果使用數組將永遠不存在
 */
int* reversePrint(struct ListNode* head, int* returnSize){
    struct ListNode* cur = head;
    int arr[10000];
    int *arr2 = (int *)malloc(10000*sizeof(int));
    int i = 0;
    while(cur != NULL)
    {
        arr[i] = cur->val;
        cur = cur -> next;
        i++;
    }
    *returnSize = i;
    for(int j =i-1 ,k = 0;j >= 0 ; j--,k++)
    {
        arr2[k] = arr[j];
    }
    return arr2;
}

int* reversePrint(struct ListNode* head, int* returnSize){
    struct ListNode* cur = head;
    int *arr = (int *)malloc(10000*sizeof(int));
    int i = 0;
    while(cur != NULL)
    {
        arr[i] = cur->val;
        cur = cur -> next;
        i++;
    }
    *returnSize = i;
    for(int j = 0 ; j< (*returnSize )/2;j++)
    {
        arr[j] = ( arr[i-1-j] + arr[j] ) - (arr[i-1-j] = arr[j]) ;
    }
    return arr;
}

------後面是一些廢話

一開始調整數組交換方式發現時間消耗差的有點多，後來連續提交同一個代碼才發現，每次運行時間會有差別，這就有點不太靠譜了

int* reversePrint(struct ListNode* head, int* returnSize){
    struct ListNode* cur = head;
    int *arr = (int *)malloc(10000*sizeof(int));
    int i = 0;
    while(cur != NULL)
    {
        arr[i] = cur->val;
        cur = cur -> next;
        i++;
    }
    *returnSize = i;
    for(int j = 0 ; j< (*returnSize )/2;j++)
    {
       // arr[j] = ( arr[i-1-j] + arr[j] ) - (arr[i-1-j] = arr[j]) ;
       int temp;
       temp = arr[j];
       arr[j] = arr[i-1-j];
       arr[i-1-j] = temp;
    }
    return arr;
}

修改了交換數組的方式 發現

連續兩次提交運行時間不同，這就有點難受了。