力扣第206题-反转链表

反转链表的效果示意图

要改变链表结构时，通常加入一个创建的临时头结点会更容易操作

时间复杂度：遍历2遍，2n

空间复杂度：额外创建一个栈，n

(空间创建一个数组长度最大为5000，你说这个数组是栈也可以，只要光通过一端对它进行操作就可以了）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
    ListNode h;//临时头结点
    h.next = head;

    //利用栈
    stack<int>s;//创建栈
    for(ListNode*p=head;p!=NULL;p=p->next)//从头遍历
    {
        //入栈
       s.push(p->val);//将val值挨个放入栈 
    }
    for(ListNode*p=head;p!=NULL;p=p->next)
    {
        //出栈
        p->val=s.top();
        s.pop();//让s.top出栈
    }

    return h.next;
    
    }
};

利用单链表的头插法进行逆置，将所有结点从后往前重新头插一遍就好了

但比上面的算法要慢一点，因为修改一两个指针的指向也要花时间的

指针p指向图中位置，将head->next断开，赋值为空，

然后利用头插，将每一个结点再重新头插到这个头结点的单链表里面

先插一个1，再插一个2，因为是头插，所以这个2就在1的前面；同理，4,3,2,1

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode* head) {
    if(head==NULL||head->next==NULL)//只有0（无法反转）或1（转完还是自己）个点，
    //直接返回(反转要至少2个数据结点以上)
    return head;
    struct ListNode h;//临时头结点
    h.next=NULL;//头结点为空的单链表，等会用来头插
    //头插需要单独一个指针把后面标记起来，以免找不到数据了
    //struct ListNode*p=head->next;不用初始化,while里面有
    struct ListNode*p;//用p记录
    while(head!=NULL)//后面还有结点
    {
        //头插，先绑后面，再绑前面
        p=head->next;//初始化
        //把head头插到h中
        head->next=h.next;// head->next=NULL,右
        h.next=head;//左
        head=p;//结点往后走
    }

    return  h.next;
}

即双指针解法

一个指针current指向头结点head，正常正向链表head的next指向后（右）边下一个结点

现在要反转，就是说head的next要反过来指向前（左）边，即head成了最后一个结点指向空

则需要另一个指针pre,定义pre为cur指针结点的前一个位置的指针，方便让cur从指向后一位的方向改成指向前一位，所以pre定义在cur头结点的前面

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
    ListNode* temp; // 保存cur的下一个节点
        ListNode* cur = head;//初始化，cur指向头结点
        ListNode* pre = NULL;//初始化，
        //pre在cur的前一个，方便反转操作cur->next = pre;为空是cur第一次反转后就从头结点变成尾结点了
        while(cur)//cur!=NULL为循环终止条件 
        {
            temp = cur->next;  // 保存一下 cur的下一个节点，绑住后面，因为接下来要改变cur->next
            cur->next = pre; // 翻转操作
            // 更新pre 和 cur指针
            pre = cur;//pre先向后走移动，将2边连接住
            //同时，若先移动cur,即cur = temp;那么此时cur的值已经改变了，
            //就不能 pre = cur向后移动了,那么pre就不能移动到cur当初的位置了
            cur = temp;//cur再向后走
        }//出循环遍历则cur==NULL，此时pre指向反转完的新头结点，原尾结点
        return pre;//返回头结点
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
     ListNode* reverse(ListNode* pre,ListNode* cur)//反转链表函数
     {
        if(cur == NULL)//循环终止条件，这里是递归终止条件
        return pre;
        ListNode* temp = cur->next;//暂存后面
        cur->next = pre;//反转方向
        // 可以和双指针法的代码进行对比，如下递归的写法，其实就是做了这两步
        // pre = cur;
        // cur = temp;
        //向后移动在双指针里面是一层循环，在递归里面是进入下一层递归
        //下一层递归里面参数pre = cur;cur = temp;所以把(cur,temp)参数传进去
        return reverse(cur,temp);//reverse（pre，cur）的实参
    }
    ListNode* reverseList(ListNode* head)//力扣给的主函数，里面光调用反转函数就好了
    {
        // 和双指针法初始化是一样的逻辑
        // ListNode* cur = head;
        // ListNode* pre = NULL;
        return reverse(NULL, head);//reverse（pre，cur）的实参
    }
};

上面两第二个图片的运行结果是错的