def removeNthFromEnd(self, head, n): """ :type head: ListNode :type n: int :rtype: ListNode """ dummyHead = ListNode(None, None) dummyHead.next = head prev = dummyHead size = 0 while prev.next != None: prev.next = prev.next.next size += 1 dummyHead.next = head prev = dummyHead count = 0 while prev.next != None: if count == int(size - n): prev.next = prev.next.next else: prev = prev.next count += 1 return dummyHead.next
def Count(self, head, searchFor): dummpyHead = ListNode(None, None) dummpyHead.next = head prev = dummpyHead count = 0 while prev.next != None: if prev.next.val == searchFor: count += 1 prev = prev.next return count
def Count(self, head, val): dummpyHead = ListNode(-1) dummpyHead.next = head prev = dummpyHead count = 0 while prev.next != None: if prev.next.val == val: count += 1 prev = prev.next return count
def GetNth(self, head, index): count = 0 dummpyHead = ListNode(None, None) dummpyHead.next = head prev = dummpyHead while prev.next != None: if count == index: return prev.next.val prev = prev.next count += 1 return None
def partition(self, head: ListNode, x: int) -> ListNode: h1 = l1 = ListNode(0) h2 = l2 = ListNode(0) while head: if head.val < x: l1.next = head l1 = l1.next else: l2.next = head l2 = l2.next head = head.next l1.next = h2.next l2.next = None return h1.next
def removeElements(self, head, val): """ :type head: ListNode :type val: int :rtype: ListNode """ dummyHead = ListNode(-1) dummyHead.next = head prev = dummyHead while prev.next != None: if prev.next.val == val: prev.next = prev.next.next else: prev = prev.next return dummyHead.next
def backtrack(head: ListNode, pre: Union[ListNode, None]) -> Union[ListNode, None]: if not head: return head if pre and pre.val == head.val or head.next and head.val == head.next.val: return backtrack(head.next, head) else: head.next = backtrack(head.next, head) return head
def removeElements2(self, head: ListNode, val: int) -> ListNode: curr = dummy = ListNode(0) dummy.next = head while curr.next: if curr.next.val == val: curr.next = curr.next.next else: curr = curr.next return dummy.next
def removeElements3(self, head: ListNode, val: int) -> ListNode: """ recursive :param head: :param val: :return: """ if not head: return head head.next = self.removeElements2(head.next, val) return head if head.val != val else head.next
def removeElements1(self, head: ListNode, val: int) -> ListNode: prev = dummy = ListNode(None) curr = dummy.next = head while curr: while curr and curr.val == val: curr = curr.next prev.next = curr prev = curr if curr: curr = curr.next return dummy.next
def removeNthFromEnd(self, head, n): """ :type head: ListNode :type n: int :rtype: ListNode """ if head == None: return [] count_down = n dummy = ListNode(0) dummy.next = head pointer1 = pointer2 = dummy pointer2_previous = dummy while pointer1.next: count_down -= 1 if count_down < 1: pointer2_previous = pointer2 pointer2 = pointer2.next pointer1 = pointer1.next pointer2_previous.next = pointer2.next return dummy.next
def deleteDuplicates1(self, head: ListNode) -> ListNode: """ 额外链表 :param head: :return: """ dummy = ListNode(0) curr = dummy.next = head h = l = ListNode(0) while curr and curr.next: if curr.val != curr.next.val: l.next = curr curr = curr.next l = l.next else: tmp = curr.val while curr and curr.val == tmp: curr = curr.next l.next = curr return h.next
def add(p1, c1, p2, c2): curr = dummy = ListNode(None) while c1 > c2: curr.next = p1 curr = curr.next p1 = p1.next c1 -= 1 while p1 and p2: v = p1.val + p2.val if v >= 10: if curr.val: curr.val += 1 else: curr.next = ListNode(1) curr = curr.next v -= 10 curr.next = ListNode(v) curr = curr.next p1 = p1.next p2 = p2.next return dummy.next
def deleteNode(self, node: ListNode): """ :type node: ListNode :rtype: void Do not return anything, modify node in-place instead. """ prev = dummy = ListNode(0) curr = dummy.next = head while curr != node: curr = curr.next prev = prev.next prev.next = curr.next return dummy.next
def addTwoNumbers2(self, l1: ListNode, l2: ListNode) -> ListNode: """ 使用栈 :param l1: :param l2: :return: """ stack1, stack2 = [], [] while l1: stack1.append(l1) l1 = l1.next while l2: stack2.append(l2) l2 = l2.next s = 0 tail = ListNode(0) while stack1 or stack2: if stack1: s += stack1.pop().val if stack2: s += stack2.pop().val tail.val = int(s % 10) tmp = ListNode(int(s // 10)) tmp.next = tail tail = tmp s /= 10 return tail if tail.val != 0 else tail.next
def deleteDuplicates3(self, head: ListNode) -> ListNode: """ recursive :param head: :return: """ if not head or not head.next: return head if head.next and head.val == head.next.val: while head.next and head.val == head.next.val: head = head.next return self.deleteDuplicates3(head.next) else: head.next = self.deleteDuplicates3(head.next) return head
def insertionSortList(self, head: ListNode) -> ListNode: p = dummy = ListNode(0) curr = dummy.next = head while curr and curr.next: val = curr.next.val if curr.val <= val: curr = curr.next continue if p.next.val > val: p = dummy while p.next.val <= val: p = p.next tmp = curr.next curr.next = tmp.next tmp.next = p.next # 不是 tmp.next = curr e.g. [4, 4, 3, 2, 1] p.next = tmp return dummy.next
def deleteDuplicates2(self, head: ListNode) -> ListNode: """ in-place :param head: :return: """ pre = dummy = ListNode(0) dummy.next = head while head and head.next: if head.val == head.next.val: while head and head.next and head.val == head.next.val: head = head.next head = head.next pre.next = head # prev不前进 else: pre = pre.next head = head.next return dummy.next
def reverseKGroup2(self, head: ListNode, k: int) -> ListNode: if k == 1: return head count = 0 prev = dummy = ListNode(0) curr = tail = dummy.next = head while curr and curr.next: count += 1 curr = curr.next if count == k - 1: while count > 0: tmp = tail.next.next tail.next.next = prev.next prev.next = tail.next tail.next = tmp count -= 1 prev = tail tail = tail.next curr = tail return dummy.next
def reverseKGroup1(self, head: ListNode, k: int) -> ListNode: """ recursive :param head: :param k: :return: """ curr = head count = 0 while curr and count < k: curr = curr.next count += 1 if count == k: curr = self.reverseKGroup1(curr, k) while count > 0: tmp = head.next head.next = curr curr = head head = tmp count -= 1 head = curr return head
def sortList(self, head): """ :type head: ListNode :rtype: ListNode """ if head is None: return None def getSize(head): counter = 0 while head is not None: counter += 1 head = head.next return counter def split(head, step): """ 前进 step 步 然后cut一下, 这样head就是一个长度为step的ListNode 返回一个从head开始的第 step 个Node :param head: :param step: :return: """ i = 1 while i < step and head: head = head.next i += 1 if head is None: return None # disconnect/cut temp, head.next = head.next, None return temp def merge(l, r, head): """ 将两个ListNode合并 以 head 为头,往后将l r merge的结果填上,然后返回最后一个Node的位置 :param l: :param r: :param head: :return: """ cur = head while l and r: if l.val < r.val: cur.next, l = l, l.next else: cur.next, r = r, r.next cur = cur.next cur.next = l if l is not None else r # 让cur指向最后一个Node while cur.next is not None: cur = cur.next return cur size = getSize(head) bs = 1 dummy = ListNode(0) dummy.next = head while bs < size: cur = dummy.next tail = dummy while cur: l = cur r = split(l, bs) cur = split(r, bs) tail = merge(l, r, tail) bs <<= 1 return dummy.next
""" Given a list and an index, return the data in the nth node of the list. The nodes are numbered from 0. Assert fails if the index is invalid (outside 0..lengh-1). """ def GetNth(self, head, index): count = 0 dummpyHead = ListNode(None, None) dummpyHead.next = head prev = dummpyHead while prev.next != None: if count == index: return prev.next.val prev = prev.next count += 1 return None if __name__ == '__main__': linkedList = LinkedListProblems() nums = [1, 2, 3, 1] head = ListNode(None, nums) count = linkedList.Count(head, 2) print(count) value = linkedList.GetNth(head, 2) print(value)