数据结构Python版---设计链表(Day8)

1.1 ⭐算法原理：

设计链表原理：
1）链表当前节点指向那个节点，
2）循环几次

1.2 🐺设计链表

题意：
get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

示例 1：
MyL inkedList linkedList = new MyLinkedList();
linkedList. addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2); //链表变为1-> 2-> 3
linkedList. get(1); //返回2
linkedList.deleteAtIndex(1); //现在链表是 1-> 3
linkedList.get(1); //返回3

2.1 定义链表

定义了一个链表节点类ListNode
val表示节点中存储的数据值，next表示指向下一个节点的指针。

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

2.2 初始化空链表

与类同名函数是构造函数，调用构造函数初始化一个空列表

class MyLinkedList:
    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.head = ListNode()
        self.size = 0

2.3 遍历链表

当前节点指向下一个节点
i = 0 , for i in range(0) 不循环。当前节点 = 头节点下一个, 即第一个节点
i = 1 , for i in range(1) 循环一次

def get(self, index: int) -> int:	# >int数据类型是整型，-> int是返回类型
    """
    Get the value of the index-th node in the linked list. If the index is invalid, return -1.
    """
    if index < 0 or index >= self.size:
        return -1        
    curr_node = self.head.next    # 当前节点 = 头节点下一个
    for i in range(index):   
        curr_node = curr_node.next
    return curr_node.val

2.4 在头节点添加新节点

找到头节点（直接获取），让新节点指向头节点下一个节点，头节点指向新节点

def addAtHead(self, val: int) -> None:
    """
    Add a node of value val before the first element of the linked list.
    """
    new_node = ListNode(val)          # 创建一个新节点，值为val
    new_node.next = self.head.next    # 让新节点指向头节点下一个
    self.head.next = new_node         # 让头节点指向新节点
    self.size += 1  # 链表长度加1

2.5 在尾节点添加新节点

找到最后一个节点，然后让它指向新节点

def addAtTail(self, val: int) -> None:
    """
    Append a node of value val to the last element of the linked list.
    """
    curr_node = self.head # 头节点作为当前节点
    # 遍历所有节点
    while curr_node.next is not None: # 只要当前节点不为空
        curr_node = curr_node.next    # 下一个节点 = 当前节点下一个
    curr_node.next = ListNode(val)    # 下一个节点的下一个指向新节点。ListNode(val)是创建一个新节点，值为val
    self.size += 1

2.6 指定位置添加新节点

通过循环找到指定节点，将新节点指向当前节点的下一个节点，当前将节点指向新节点

def addAtIndex(self, index: int, val: int) -> None:
    if index > self.size:
        return
    if index < 0:
        index = 0
    curr_node = self.head
    for i in range(index):
        curr_node = curr_node.next
    new_node = ListNode(val)             # 创建一个新节点
    new_node.next = curr_node.next       # 将新节点的下一个节点设置为当前节点的下一个节点
    curr_node.next = new_node            # 将当前节点的下一个节点设置为新节点，完成插入
    self.size += 1

2.7 指定位置删除新节点

通过循环找到指定节点，让当前节点指向当前节点下下节点（跳过一个节点）

def deleteAtIndex(self, index: int) -> None:
    """
    Delete the index-th node in the linked list, if the index is valid.
    """
    if index < 0 or index >= self.size:
        return
    curr_node = self.head
    for i in range(index):
        curr_node = curr_node.next
    curr_node.next = curr_node.next.next
    self.size -= 1

⭐⭐⭐ 嘟嘟崽 ⭐⭐⭐ ⭐⭐⭐ 点赞 + 收藏 ≠ 关注 ⭐⭐⭐