2020-8-03 每日刷题札记–反转链表Ⅰ

每日刷题札记–反转链表Ⅰ

2020年8月3日星期一,大一暑假过半,兴趣使然,自学数据结构,复现了一些基本操作,但是还是深感所见甚微,于是决定开始刷Leetcode,刷了几天的题(看了几天的答案),也看了很多相关的解题指导文章,但是还是觉得印象不够深刻,于是决定开始写刷题札记,集思广益,自己记述解题思路,希望学以致用,用有所得!

声明:文章参考网络解题指导文章,仅作加深巩固,学习交流之用,本人水平有限,若文中有错误之处请批评指正,非商业转载图片均已注明出处,若存在侵权行为,请私聊联系删除.

方法一:
双指针迭代法:初始化两个指针pre和cur,每次迭代让当前节点指针(cur)指向上一个节点(pre)
(记得需要提前保存好当前节点的下一个节点位置)
图片源链接
①C++实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
    
    
public:
    ListNode* reverseList(ListNode* head) {
    
    
        ListNode* pre = NULL;
        ListNode* cur = head;
        while(cur)
        {
    
    
            ListNode* temp = cur->next;// 提前保存好当前节点的下一节点
            cur->next = pre;           // 当前节点的指针指向前驱节点
            pre = cur;                 //更新前驱节点
            cur = temp;                //cur指向原来的下一节点
        }
        return pre;
    }
};

②Python实现

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        pre = None
        cur = head
        while cur:
            temp = cur.next   # 提前保存好当前节点的下一位
            cur.next = pre    # 当前节点的指针指向前驱节点
            pre = cur         #更新pre
            cur = temp        # cur指向原来的下一位
        return pre

Python另一种写法-多元赋值写法:利用其性质可以省去保存当前节点的下一个指针的步骤,挺巧妙的写法,感兴趣的可以看一看下面这一篇文章,这里不再赘述
Python多元赋值

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def reverseList(self, head:ListNode) -> ListNode:
        """
        :type head: ListNode
        :rtype: ListNode
        """
        pre = None
        cur = head
        while cur:
            cur.next,pre,cur= pre,cur,cur.next
        return pre

方法二:递归
递归调用函数，一直递归到链表的最后一个结点,该结点就是反转后的头结点(记作 ret) .
递归结束的条件:

if(head == NULL || head->next == NULL) 
    return head;

此后，每次函数在返回的过程中，让当前结点的下一个结点的 next 指针指向当前节点,同时让当前结点的 next 指针指向 NULL ,从而实现从链表尾部开始的局部反转 (1->2转换为1<-2的过程)
当递归函数全部出栈后，链表反转完成
图片源链接

①C++实现

ListNode* reverseList(ListNode* head) {
    
    
	//到链表尾节点结束,返回作为反转链表的头节点
    if(head == NULL || head->next == NULL) 
        return head;
	//递归调用直到满足结束条件,返回
    ListNode* ret = reverseList(head->next);  
    //注意我们的递归调用入口参数:head->next,也就是下面代码中的head
    //第几次调用,递归调用返回后 head就指向第几个节点
    //接下来:当前节点的下一个节点的后驱指针指向当前节点(有点别扭)
    //简单的说就是 1->2 我们需要实现1<-2, 
    //head指向的是1,那么head->next就是2,2的next指向1,就实现我们的目的啦
    head->next->next = head;
    head->next = NULL;
    return ret;
}

②Python实现,思路与上面是一致的,这里不再赘述

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        if not head or not head.next:
            return head
        ret = self.reverseList(head.next)
        head.next.next = head
        head.next = None
        return ret