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)