代码随想录算法训练营Day3|LeetCode

Linked List链表

Q203 删除链表元素 (单链表)

[Q203]

def removeElements(self, head:ListNode, val: int) -> ListNode:
    dummy_head = ListNode(next=head) # 创建dummy_head指向head
    cur = dummy_head # 当作指针
    while cur.next != None:
        if cur.next.val == val:
            cur.next = cur.next.nect
        else:
            cur = cur.next
    return dummy_head.next

var removeElements = function(head, val) {
    const ret = ListNode(0, head);
    let cur = ret;
    while (cur.next){
        if(cur.next.val === val){
            cur.next = cur.next.next;
            continue;
        }
        cur = cur.next;
    }
     return ret.next;
}

Q707

单链表

# 单链表
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

Q206 反转链表

双指针法

def reverseList(self, head: ListNode) -> ListNode:
  cur = head
  pre = None
  while (cur != None):
    temp = cur.next # 保存cur的下一个节点，因为接下来要改变cur->next
    cur.next = pre # reverse
    # update pre, cur指针
    pre = cur
    cur = temp
  return pre

递归法

def reverseList(self, head: ListNode) -> ListNode:
  
  def reverse(pre, cur):
    if not cur:
      return pre
    temp = cur.next
    cur.next = pre
    return reverse(cur, temp)
  
  return reverse(None, head)

Reference: https://programmercarl.com/