【LeetCode刷题】Day03 链表基础Ⅰ

已于 2023-01-27 15:39:43 修改
阅读量157 收藏
点赞数
分类专栏： LeetCode题目总结 文章标签： 链表 leetcode 数据结构
于 2023-01-27 11:40:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Elinor_/article/details/128741902
版权

链表基础

1 链表分类

  • 单链表：链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。链表的入口节点称为链表的头结点也就是head。单链表

  • 双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。既可以向前查询也可以向后查询。双链表

  • 循环链表：链表首尾相连。即最后一个元素的指针指向第一个元素。（约瑟夫环问题）

2 存储方式

  • 链表在内存中可不是连续分布的，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。
  • 链表是通过指针域的指针链接在内存中各个节点。

3 链表定义

C++：

// 单链表
struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
};

//构造函数(初始化节点信息)使用
ListNode* head = new ListNode(5);
//等价于下面代码
ListNode* head = new ListNode();
head->val = 5;

Java：

public class ListNode {
    // 结点的值
    int val;

    // 下一个结点
    ListNode next;

    // 节点的构造函数(无参)
    public ListNode() {
    }

    // 节点的构造函数(有一个参数)
    public ListNode(int val) {
        this.val = val;
    }

    // 节点的构造函数(有两个参数)
    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

Python：

class ListNode:
    def __init__(self, val, next=None):
        self.val = val
        self.next = next

链表操作及性能分析

  • 删除节点：将删除节点的前一节点指针指向删除节点的下一个节点即可。(C++要释放内存)
  • 添加节点：将插入节点指针指向后一节点，再将插入节点前一节点的指针指向插入节点。
  • 查找结点：从头节点开始一个一个找。
  • 性能分析：性能分析

LeetCode203-移除链表元素

题目描述：给定一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回新的头节点。
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
题目链接：https://leetcode.cn/problems/remove-linked-list-elements/

解题思路

  • 直接对链表进行删除操作
  • 设置虚拟头节点后进行删除操作

1 直接删除

  • 需要对头节点进行单独处理
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 删除头结点
        while (head != NULL && head->val == val) { // 注意这里不是if
            ListNode* tmp = head;
            head = head->next;
            delete tmp;
        }

        // 删除非头结点
        ListNode* cur = head;
        while (cur != NULL && cur->next!= NULL) {
            if (cur->next->val == val) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } else {
                cur = cur->next;
            }
        }
        return head;
    }
};

2 设置虚拟头节点

  • 虚拟头节点的设置使得节点删除方式相同，注意返回的是虚拟头节点的next节点
# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        newHead = ListNode(next=head);
        p = newHead;
        q = newHead.next;
        while(q != None):
            if(q.val == val):
                p.next = q.next;
                q = q.next;
            else:
                q = q.next;
                p = p.next;
        return newHead.next;


# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: ListNode, val: int) -> ListNode:
        dummy_head = ListNode(next=head) #添加一个虚拟节点
        cur = dummy_head
        while(cur.next!=None):
            if(cur.next.val == val):
                cur.next = cur.next.next #删除cur.next节点
            else:
                cur = cur.next
        return dummy_head.next

3 心得体会

简单的链表删除题目，因为太久没有接触数据结构，还自己推导了一下怎么写，最开始的时候忘记else了，所以还浪费了挺长时间。虚拟头节点的设置使得代码简便，以后多用这种方法。

LeetCode707-设计链表

题目描述：设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。
在链表类中实现这些功能：
get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
题目链接：https://leetcode.cn/problems/design-linked-list/

解题思路

  • 链表的基本操作
  • 可以对原链表，也可以加一个虚拟头节点

虚拟头节点写法1

class Node():
    def __init__(self, val, next=None):
        self.val = val;
        self.next = next;

class MyLinkedList(object):

    def __init__(self):
        self.dummyhead = Node(val=0);

    def get(self, index):
        """
        :type index: int
        :rtype: int
        """
        p = self.dummyhead;
        count = -1;
        while(p != None):
            if (count == index):
                return p.val;
            p = p.next;
            count += 1;
        return -1;

    def addAtHead(self, val):
        """
        :type val: int
        :rtype: None
        """
        p = Node(val=val,next=self.dummyhead.next);
        self.dummyhead.next = p;

    def addAtTail(self, val):
        """
        :type val: int
        :rtype: None
        """
        q = Node(val=val);
        p = self.dummyhead;
        while(p.next != None):
            p = p.next;
        p.next = q;


    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: None
        """
        p = self.dummyhead;
        count = -1;
        q = Node(val=val);
        if(index <= 0):
            self.addAtHead(val);
            return;
        while(p != None):
            if(index > 0 and count == index -1):
                q.next = p.next;
                p.next = q;
            count += 1;
            p = p.next;


    def deleteAtIndex(self, index):
        """
        :type index: int
        :rtype: None
        """
        p = self.dummyhead;
        count = -1;
        while(p != None):
            if(count == index - 1 and p.next != None):
                p.next = p.next.next;
            p = p.next;
            count += 1;



# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)

虚拟头节点写法2

# 单链表
class Node(object):
    def __init__(self, x=0):
        self.val = x
        self.next = None

class MyLinkedList(object):

    def __init__(self):
        self.head = Node()
        self.size = 0 # 设置一个链表长度的属性，便于后续操作，注意每次增和删的时候都要更新

    def get(self, index):
        """
        :type index: int
        :rtype: int
        """
        if index < 0 or index >= self.size:
            return -1
        cur = self.head.next
        while(index):
            cur = cur.next
            index -= 1
        return cur.val

    def addAtHead(self, val):
        """
        :type val: int
        :rtype: None
        """
        new_node = Node(val)
        new_node.next = self.head.next
        self.head.next = new_node
        self.size += 1

    def addAtTail(self, val):
        """
        :type val: int
        :rtype: None
        """
        new_node = Node(val)
        cur = self.head
        while(cur.next):
            cur = cur.next
        cur.next = new_node
        self.size += 1

    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: None
        """
        if index < 0:
            self.addAtHead(val)
            return
        elif index == self.size:
            self.addAtTail(val)
            return
        elif index > self.size:
            return

        node = Node(val)
        pre = self.head
        while(index):
            pre = pre.next
            index -= 1
        node.next = pre.next
        pre.next = node
        self.size += 1
        
    def deleteAtIndex(self, index):
        """
        :type index: int
        :rtype: None
        """
        if index < 0 or index >= self.size:
            return
        pre = self.head
        while(index):
            pre = pre.next
            index -= 1
        pre.next = pre.next.next
        self.size -= 1
	
# 双链表
# 相对于单链表, Node新增了prev属性
class Node:
    
    def __init__(self, val):
        self.val = val
        self.prev = None
        self.next = None


class MyLinkedList:

    def __init__(self):
        self._head, self._tail = Node(0), Node(0)  # 虚拟节点
        self._head.next, self._tail.prev = self._tail, self._head
        self._count = 0  # 添加的节点数

    def _get_node(self, index: int) -> Node:
        # 当index小于_count//2时, 使用_head查找更快, 反之_tail更快
        if index >= self._count // 2:
            # 使用prev往前找
            node = self._tail
            for _ in range(self._count - index):
                node = node.prev
        else:
            # 使用next往后找
            node = self._head   
            for _ in range(index + 1):
                node = node.next
        return node

    def get(self, index: int) -> int:
        """
        Get the value of the index-th node in the linked list. If the index is invalid, return -1.
        """
        if 0 <= index < self._count:
            node = self._get_node(index)
            return node.val
        else:
            return -1

    def addAtHead(self, val: int) -> None:
        """
        Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
        """
        self._update(self._head, self._head.next, val)

    def addAtTail(self, val: int) -> None:
        """
        Append a node of value val to the last element of the linked list.
        """
        self._update(self._tail.prev, self._tail, val)

    def addAtIndex(self, index: int, val: int) -> None:
        """
        Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted.
        """
        if index < 0:
            index = 0
        elif index > self._count:
            return
        node = self._get_node(index)
        self._update(node.prev, node, val)

    def _update(self, prev: Node, next: Node, val: int) -> None:
        """
            更新节点
            :param prev: 相对于更新的前一个节点
            :param next: 相对于更新的后一个节点
            :param val:  要添加的节点值
        """
        # 计数累加
        self._count += 1
        node = Node(val)
        prev.next, next.prev = node, node
        node.prev, node.next = prev, next

    def deleteAtIndex(self, index: int) -> None:
        """
        Delete the index-th node in the linked list, if the index is valid.
        """
        if 0 <= index < self._count:
            node = self._get_node(index)
            # 计数-1
            self._count -= 1
            node.prev.next, node.next.prev = node.next, node.prev

注意：

  • 注意节点的定义方式
  • 注意链表类中属性要有链表长度size，方便后续操作
  • 注意对边界条件(index的数值，是否有空指针等)的检查

心得体会

很久没有写过链表的基本操作了，大体上知道怎么写，但是避免不了一些边界条件检查忘记了，还有对属性定义不规范等问题。要多温习，形成一套写代码的规范，避免以后再次需要调试代码才能写正确，每次写的代码还都不太一样那种现象。

LeetCode206-反转链表

题目描述：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
题目链接：https://leetcode.cn/problems/reverse-linked-list/

解题思路

  • 双指针法
  • 递归法
  • 头插法

1 双指针法

  • 定义两个指针，将后指针next赋给前指针即可
  • 要加一个临时变量记录cur->next原来的指向，cur才能正常向后移动
  • 注意终止条件
#双指针
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        cur = head   
        pre = None
        while(cur!=None):
            temp = cur.next # 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur.next = pre #反转
            #更新pre、cur指针
            pre = cur
            cur = temp
        return pre

2 递归法

  • 按照双指针法的思路来对照写
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        
        def reverse(pre,cur):
            if not cur: # if cur is None
                return pre
                
            tmp = cur.next
            cur.next = pre

            return reverse(cur,tmp)
        
        return reverse(None,head)


//C++从前向后递归写法
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;
        return reverse(cur,temp);
    }
    ListNode* reverseList(ListNode* head) {
        // 和双指针法初始化是一样的逻辑
        // ListNode* cur = head;
        // ListNode* pre = NULL;
        return reverse(NULL, head);
    }

};
//c++从后向前递归写法(调试画图看懂，自己也不会写)
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // 边缘条件判断
        if(head == NULL) return NULL;
        if (head->next == NULL) return head;
        
        // 递归调用，翻转第二个节点开始往后的链表
        ListNode *last = reverseList(head->next);
        // 翻转头节点与第二个节点的指向
        head->next->next = head;
        // 此时的 head 节点为尾节点，next 需要指向 NULL
        head->next = NULL;
        return last;
    }
};

3 头插法

  • 学数据结构时反转链表老师讲的头插法
  • 定义虚拟头节点，将头节点后的节点依次插入头节点前即可反转链表
# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        dummyhead = ListNode(next=head);
        if (dummyhead.next == None):
            return head;
        while(head.next != None):
            p = dummyhead;
            while(p != head.next):
                p = p.next;
            head.next = head.next.next;
            p.next = dummyhead.next;
            dummyhead.next = p;
        return dummyhead.next;

4 心得体会

看到题目一开始想用双指针，但是没有想到用临时变量存储cur->next就可以让cur往后走了，这点没想到不应该，太久没定义临时变量了，以后要多想去定义临时变量。后来想到用头插法，一开始先讲尾节点插入头节点前面，那是不对的，出来还是正序，注意应该是头节点后一个节点依次插入头节点前。
对于题解中的递归方法，理解不到位，二刷可以再体会一下。

总结

day3的到今天才写完，还是比较基础，这段时间不太舒服，一直不想学习(也可能是单纯的找理由摆烂，已经落下很多天了。计划还是每天写一个，按自己进度来吧，但是不能再落下了。

Elinor_
关注
专栏目录
Java笔记之Deque与Stack
来自蒟蒻LebronGod的博客
03-17 6038
使用Deque 允许两头都进，两头都出，这种队列叫双端队列（Double Ended Queue），简称Deque。 Java集合提供了接口Deque来实现一个双端队列，它的功能： ①既可以添加到队尾，也可以添加到队首； ②既可以从队首获取，又可以从队尾获取。 在原来的queue的方法名上加了表示在队首还是队尾操作的表示（Last或First）。 Deque接口实际上扩展自Queue： publ...
反转链表LeetCode题解
weixin_45295612的博客
05-11 406
反转链表 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 示例 1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] 示例 2： 输入：head = [1,2] 输出：[2,1] 示例 3： 输入：head = [] 输出：[] 提示： 链表中节点的数目范围是 [0, 5000] -5000 <= Node.val <= 5000 进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？ 解题思路： 首先定义一个cur指针，指向头结
LeetCode刷题day4——链表part2
nosnef的博客
06-21 1063
我突然想到：可能有的人觉得最快应该是慢指针走到环入口的时候，快指针刚好已经提前走到环入口处了，那注意此时n不可能是0，如果是0，y=0，则x = x，相当于环入口那一刻相遇，但是x那一段线段路程，他两是不可能相遇的，所以n至少是1在里面转了一圈刚好到环入口才有可能相遇。图示，当慢指针（绿色）进入环的时候，快指针（红色）可以在环上的任意位置，最坏的情况就是快指针在慢指针前面一个结点，而按照相对运动来说，假设环有n个结点，则快指针相对慢指针运动n-1个单位时间即可追上。所以+n(y+z)；
LeetCode刷题day3——链表part1
nosnef的博客
06-21 460
问题：1.不知道初始化什么对象，以及里面要定义哪些值。2.index非法情况怎么具体在代码中体现。3.边界处理不到位，比如=size =0这些我还自己分开讨论，其实可以写在一起。所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！注意卡哥说的在C++里面，要自己定义，leetcode里面默认的是可以直接赋值的。这个题是二刷了一开始这个思路就是利用虚拟头结点，但是中间很多小细节都考虑不到，例如初始化一个新的链表，循环条件的写法等。考虑用双指针法，但自己想的时候还是串联不起来思路。
LeetCode刷题|day4 链表
saufmoi的博客
03-07 93
LeetCode刷题
leetcode刷题 day6 | 链表：移除元素
qq_42272783的博客
10-21 148
链表
求职 leetcode 刷题 day4 --- 链表
qq_44486787的博客
05-26 566
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。给定一个链表的头节点 head ，返回链表开始入环的第一个节点。如果链表无环，则返回 null。给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
leetcode刷题 day7 | 链表：反转+交换
qq_42272783的博客
10-21 149
链表
leetcode刷题day3：链表题目集合
weixin_59518581的博客
11-16 116
day1 任务以及具体安排：第一章 数组part01day 2 任务以及具体安排：第一章 数组part02题目链接/文章讲解/视频讲解：：代码随想录如何移除元素：第一步是找到他的上一个元素，然后将这个元素的next属性变成current.next.next，也就是跳过我们要删除的元素。这里用到一个技巧，即虚拟头结点。这样就可以用 某某.next表示所有元素，包括第一个元素。返回的时候注意去掉虚拟头即可 def removeElements(head, val): fix_head = Lis
最低加油次数leetcode-LeetCode:LeetCode刷题笔记
06-30
LeetCode刷题笔记 Day1 1. 两数之和 知识点：哈希表，键为元素值，值为索引。边遍历边判断差值是否存在于哈希表 2. 两数相加 知识点：链表遍历 53. 最大子序和 知识点：动态规划或者贪心算法 983. 最低票价 知识点：...
Leetcode扑克-LeetCodeJava:leetcode刷题java
06-30
Day03 合并K个排序链表 Day04 验证二叉搜索树 Day05 二叉树中的最大路径和 Day06 二叉树展开为链表 Day07 动态规划：打家劫舍 Day08 前 K 个高频元素 Day09 有效的数独 Day10 查找字符串中的所有回文子串 Day11 摆动...
LeetCode刷题Day10
rookie123222的博客
11-10 722
一：方法总结 二：题目 79.单词搜索 给定一个m x n二维字符网格board和一个字符串单词word。如果word存在于网格中，返回true；否则，返回false。 思路：先遍历board，找到一个能匹配的字符，确定入口，同时创建新的 vis 数组保存已经走过的路径。 public boolean exist(char[][] board, String word) { boolean[][] vis = new boolean[m][n];//保存已经...
Python世界：力扣29题两数相除算法实践
来知晓的博客
09-13 416
除法运算本质是减法，从理解原理到真正实现还是有距离，建议初步理解后，不参考任何代码，完全自己复现一遍，体会更深。注意提示：目的就是提醒越界问题：-2^31/-1=2&31，超过了整数表达范围。本问题来自于力扣29题，在做完大数相乘后，顺带也看下两数相除。将两数相除，要求不使用乘法、除法和 mod 运算符。给定两个整数，被除数。
【Hot100】LeetCode—64. 最小路径和
weixin_44382896的博客
09-12 495
64. 最小路径和。
【JavaScript】LeetCode：707设计链表
weixin_45980065的博客
09-14 641
【代码】【JavaScript】LeetCode：707设计链表。
LeetCode 692.前K个高频单词
m0_63816268的博客
09-13 351
首先用map存储该字典，然后放进vector进行排序，注意sort的排序规则与我们想要的规则不一致，所以我们需要写一个伪函数来判断second(value值)，由于该题要求了稳定性，所以我们在伪函数还需要继续判断相等情况的顺序。排完序后用vector将前k个单词存储起来返回。
Leetcode Hot 100刷题记录 -Day16（旋转图像）
weixin_45864705的博客
09-14 244
你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。请你将图像顺时针旋转 90 度。
Golang | Leetcode Golang题解之第409题最长回文串
最新发布
weixin_66442839的博客
09-16 390
Golang | Leetcode Golang题解之第409题最长回文串
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值