链表的建立及反转

今天写了下链表，主要是反转，用的递归写，先贴上代码：

链表建立：

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

listNode* build(int arr[], size_t size)
{
    listNode *pHead, *pre;
    size_t i;
    for (i = 0; i < size; ++i)
    {
        listNode* newNode = (listNode*)malloc(sizeof(listNode));
        newNode->val = arr[i];
        newNode->next = NULL;
        if (i == 0)
        {
            pHead = newNode;
            pre = newNode;
        }
        else{
            pre->next = newNode;
            pre = pre->next;
        }
    }
    /*while(pHead)
    {
        printf("%d ", pHead->val);
        pHead = pHead->next;
    }
    printf("\n");*/
    return pHead;
}

反转：

listNode *nb;

void exchange(listNode *a, listNode *b)
{
    int tmp = a->val;
    a->val = b->val;
    b->val = tmp;
}

void list_reverse(listNode *la, listNode *lb, int pos, int mid, bool odd)
{
    if ((pos+1) == mid)
    {
        if (odd)//arraySize is odd
            lb = lb->next->next;
        else
            lb = lb->next;
        exchange(la, lb);
        nb = lb->next;
    }// size = 0 ? size = 1 ? 在进入函数前判断 size >= 2
    else{
        list_reverse(la->next, lb->next, pos+1, mid, odd);
        exchange(la, nb);
        nb = nb->next;
    }
}

注解：声明一个全局变量，用在递归里面，这样不需要节点的父指针，利用递归的堆栈保存变量（listNode *la），回溯的时候就能直接使用。

空间复杂度 O(1)

时间复杂度 O（n）

可能的bug: 如果链表节点有100w+，可能会栈溢出。 需要其他方法 !

方法2：

listNode* list_reverse(listNode *pHead)
{
    if (!pHead)
        return NULL;
    listNode *pPre = pHead, *pNext = pHead->next, *temp = NULL;
    pPre->next = NULL;
    while(pNext)
    {
        temp = pNext->next;
        pNext->next = pPre;
        pPre = pNext;
        pNext = temp;
    }
    return pPre;
}

这种写法不容易出错。在链表链接是不能断，而且必须保证到达最后一个节点。