链表处理-单链表反转

链表结构和构建

#include <iostream>
#include <stack>
#include <vector>
#include <string.h>
#include <stdlib.h>
#include <string>
struct ListNode {
    int val;
     ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};
//初始化链表，add为每次的累加的数字，num为累加次数
ListNode* InitLink(int add, int num)
{
    if(num < 1)
        return NULL;
    ListNode *stLink ;
    int i = 1;
    ListNode *tempNode = ( ListNode *)malloc(sizeof( ListNode));
    tempNode->val = i*add+i;
    tempNode->next = NULL;
    stLink = tempNode;

    for(i = 2; i < num+1; ++i)
    {
        ListNode *newNode;
        newNode = ( ListNode *)malloc(sizeof( ListNode));
        newNode->val = i*add + i;
        tempNode->next = newNode;
        tempNode = tempNode->next;
    }
    tempNode->next = NULL;
    return stLink;
}

反转的两种常见方法：

1. 在另一个链表上进行操作

思路是：遍历链表，把遍历的每个节点依次插入到新链表上，最后形成新的链表即为原链表的反转。

代码如下

ListNode * LinkReverse(ListNode *pHead)
{
    if(NULL == pHead|| NULL == pHead->next)
        return pHead;
    ListNode *pRes = NULL;
    ListNode *pTemp;
    ListNode *pCur = pHead;

    while(pCur != NULL)
    {
        pTemp = pCur;
        pCur = pCur->next;//先让pCur指针指向下一个位置，再做插入，不然会出错
        pTemp->next = pRes;
        pRes = pTemp;
    }
    return pRes;
}

2. 在原链表上进行操作
思路是：每次操作，把下一个节点插到第一个节点的前面，然后把第一个节点指向插入节点的下一个节点

ListNode* LinkReverse(ListNode *pHead)
{
    if(NULL == pHead|| NULL == pHead->next)
        return pHead;
    ListNode *pCur = pHead;
    ListNode *pTemp;
    while(pCur != NULL)
    {
        //往下试探，指针是通过链表的位置变化而移动的
        if(pCur->next != NULL)
        {
            pTemp = pCur->next;
            pCur->next = pCur->next->next;
            pTemp->next = pHead;
            pHead = pTemp;
        }
        else
        {
            break;
        }

        //pCur = pCur->next;
    }
    return pHead;

}

3. 测试函数

void testLinkReverse()
{
    ListNode *pHead = InitLink(2,10);
    PrintLink(pHead,10);
}