def reverseKGroup(head, k): """ :type head: ListNode :type k: int :rtype: ListNode """ helper = ListNode(0) helper.next = head pre, tail = helper, helper count = 0 while tail: tail = tail.next count += 1 if ( count == k ) and tail: # bug fixed --- need to reconsider tail if it has been updated. consider the case 1->2->None with k = 3 nextHead = tail.next # temporarily save the next group's head (newHead, newTail) = reverseKGroup2(head, tail, k) # swap this k group nodes pre.next = newHead # link the pre node with the new head newTail.next = nextHead # link the new tail with the previously saved next group's head pre = newTail # update pre node head = nextHead # update head node tail = newTail # update tail node count = 0 return helper.next
def reorder(head): if not head: return None it = curr = head # construct a reverse list p_head = p = ListNode(it.val) length = 1 while it.next: it = it.next length += 1 p.next = ListNode(it.val) p = p.next tail = reverse(p_head) # construct the reordered list count = 0 while count < length: store = tail.next temp = curr.next curr.next = tail count += 1 if count == length: curr.next = None break tail.next = temp count += 1 if count == length: curr.next.next = None break curr = temp tail = store # show(head) return head
def return_linear_list(head): ## find if cyclic or not tup1 = floyds_2pointer_steps(head) if tup1[0] == -1: return head tup2 = floyds_2pointer_steps(tup1[1]) ##find the no of nodes in cycle nNodesInCycle = tup2[0] ##find the point of repetition p1 = head p2= head count = 1 while True: if p2.next == p1: p2.next = None if (count-nNodesInCycle)%2 == 1: n = ListNode('added') n.next = p1 return n else: return p1 if count<nNodesInCycle: p2=p2.next else: p1=p1.next p2 = p2.next count+=1
def rotateRight(self, head, k): """ :type head: ListNode :type k: int :rtype: ListNode """ if k == 0 or not head or head.next is None: return head # helper node to handle the new head case pre = ListNode(0) pre.next = head tail, l = pre, 0 while tail.next is not None and l < k: # When while condition fails, tail is either on "tail" node, or l == k, which means tail is on the ready to move position l += 1 tail = tail.next if tail.next is None: # if tail is on "tail", this means k >= l, so we need to put the tail back on k%l position k = k % l tail = pre for i in range(k): tail = tail.next helper = pre while tail.next is not None: # After this, helper's next will point to the start node of the section to be rotated to the beginning helper = helper.next tail = tail.next tail.next = pre.next pre.next = helper.next helper.next = None return pre.next
def deleteDuplicates2(head): if head == None or head.next == None: return head p = head cur = p.val dup = False lastHead = None lastDis = None while p.next != None: if p.next.val == cur: dup = True p = p.next elif not dup: if lastDis == None: lastHead = ListNode.ListNode(p.val) lastDis = lastHead else: lastDis.next = ListNode.ListNode(p.val) lastDis = lastDis.next p = p.next cur = p.val dup = False else: p = p.next cur = p.val dup = False if not dup: if lastDis == None: lastHead = ListNode.ListNode(p.val) lastDis = lastHead else: lastDis.next = ListNode.ListNode(p.val) return lastHead
def reverseKGroup(self, head: ListNode, k: int) -> ListNode: def reverse(head): pre = None curr = head while curr: next = curr.next curr.next = pre pre = curr curr = next return pre dummy = ListNode(-1) dummy.next = head # pre:指向待翻转区域的前一个节点 # end:指向待翻转区域的最后一个节点 # next:指向待翻转区域的后一个节点,即end.next pre, end = dummy, dummy while end.next: i = 0 while i < k and end: end = end.next i += 1 if end == None: break start = pre.next next = end.next end.next = None pre.next = reverse(start) start.next = next pre = start end = pre return dummy.next
def deleteDuplicates(self, head): """ :type head: ListNode :rtype: ListNode """ if not head or head.next is None: return head pre = ListNode(0) pre.next = head num = head.val left, right, node = pre, head.next, head # node is the candidate ListNode to be linked to left while right: if right.val == num: node = None else: if node: left.next = node left = left.next node = right num = right.val right = right.next if node: # bug fixed here: forgot the remaining node when "while" loop ends left.next = node node.next = None else: left.next = None return pre.next
def addTwoNumbers(self, l1, l2): numbers = [] for l in (l1, l2): tens = 1 no = 0 no = no + (l.val * tens) tens = tens * 10 while (l.next_node != None): no = no + l.next_node.val * tens tens = tens * 10 l = l.next_node numbers.append(no) l_sum = numbers[0] + numbers[1] first_val = l_sum % 10 l_sum = l_sum / 10 l3 = ListNode.ListNode(first_val) head = l3 while (l_sum > 0): val = l_sum % 10 l_sum = l_sum / 10 l_node = ListNode.ListNode(val) l3.next_node = l_node l3 = l3.next_node return head
def reverseBetween(self, head, m, n): """ :type head: ListNode :type m: int :type n: int :rtype: ListNode """ helper = ListNode(0) helper.next = head pre = helper for i in range(m - 1): pre = pre.next # Now pre.next will be the 1st node to be reversed head, left, right = pre.next, pre.next, pre.next.next for j in range(n - m): temp = right.next right.next = left left = right right = temp pre.next = left head.next = right return helper.next
def partition(head, x): """ :type head: ListNode :type x: int :rtype: ListNode """ if not head: return head dummy = ListNode(0) dummy.next = head curr = last = mark = dummy while curr.next: if curr.next.val >= x: last = curr mark = curr.next break curr = curr.next stack = [] while mark.next: if mark.next.val < x: stack.append(mark.next.val) mark.next = mark.next.next else: mark = mark.next while stack: val = stack.pop(0) temp = last.next last.next = ListNode(val) last.next.next = temp last = last.next return dummy.next
def add(x, y): start = ListNode(-1) res= start values = [0] x1, x2= x, y m, n = 0, 0 while x1: x1 = x1.next m += 1 while x2: x2 = x2.next n += 1 # make sure x is the longer if n > m: x, y, m ,n = y, x, n, m for i in range(m-n): values.append(x.val) x = x.next for _ in range(n): values.append(x.val + y.val) x, y = x.next, y.next for idx in range(len(values)-1, 0, -1): values[idx-1]= values[idx -1] + values[idx]/10 values[idx] = values[idx] % 10 for k in range(len(values)): start.next= ListNode(values[k]) start = start.next if res.next.val == 0: return res.next.next return res.next
def isPalindrome(head): if head == None: return True temp_node = ListNode(head.val) orig_head = temp_node node = head while node.next != None: node = node.next new_node = ListNode(node.val) temp_node.next = new_node temp_node = new_node next_node = None prev_node = None curr_node = head while curr_node != None: next_node = curr_node.next curr_node.next = prev_node prev_node = curr_node curr_node = next_node head = prev_node isPalindrome = True while head.next != None: if head.val != orig_head.val: isPalindrome = False break else: head = head.next orig_head = orig_head.next return isPalindrome
def addTwoNumbers_in_order_result(self, l1, l2): """ :type l1: ListNode :type l2: ListNode :rtype: ListNode """ if not l1 or not l2: return l1 or l2 cur = self carry = 0 pre = None while l1 or l2 or carry: if l1: carry = carry + l1.val l1 = l1.next if l2: carry = carry + l2.val l2 = l2.next temp = ListNode(carry % 10) temp.next = pre cur.next = temp pre = temp carry = carry // 10 return cur
def reverseBetween2(self, head: ListNode, m: int, n: int) -> ListNode: fakeHead = ListNode(0) fakeHead.next = head # find the pre node (whose next is mth node) and the tail node (nth node) pre, tail = fakeHead, None node = fakeHead # iterator for step in range(1, n + 1): node = node.next if step == m - 1: pre = node if step == n: tail = node # get the head (mth node) head = pre.next pre.next = None # disconnect pre and this section of list temp = tail.next # temporarily save tail.next to be connected in future tail.next = None # disconnect tail with temp # reverse the partial list pre1, node = None, head while node: t = node.next node.next = pre1 pre1 = node node = t # connect pre with the new head (previous tail) pre.next = tail # connect new tail (previous head) with temp head.next = temp return fakeHead.next
def rotateRight(self, head: ListNode, k: int) -> ListNode: if head == None or head.next == None: return head length = 0 dummy = ListNode(-1) dummy.next = head cur = dummy.next while cur: length += 1 cur = cur.next k = k % length p, q = dummy, dummy for i in range(k): q = q.next while q.next: p, q = p.next, q.next q.next = dummy.next dummy.next = p.next p.next = None return dummy.next
def sortList(self, head: ListNode) -> ListNode: if not head or not head.next: return head pseudoHead = ListNode(0) pseudoHead.next = head # find the mid node fast, mid = pseudoHead, pseudoHead while fast and fast.next: fast = fast.next.next mid = mid.next right, mid.next = mid.next, None # recursively sort left and right part left, right = self.sortList(head), self.sortList(right) pre = pseudoHead # merge two lists while left or right: lVal = 2**31 if not left else left.val rVal = 2**31 if not right else right.val if lVal < rVal: pre.next = left left = left.next else: pre.next = right right = right.next pre = pre.next return pseudoHead.next
def reverseList2(self, head): l = None while not head == None: l2 = ListNode(head.val) l2.next = l l = l2 head = head.next return l
def revHelp(self, head): if head.next == None: l2 = ListNode(head.val) return (l2, l2) rev, last = self.revHelp(head.next) last.next = ListNode(head.val) return (rev, last.next)
def __init__(self): self.front = ListNode() self.back = ListNode() self.front.setNext(self.back) self.front.setPrev(None) self.back.setPrev(self.front) self.back.setNext(None) self.current = self.front return None
def removeElements(self, head, val): root = ListNode(0) root.next = head travel = root while travel.next: if travel.next.val == val: travel.next = travel.next.next travel = travel.next return root.next
def enqueue(self, item): if self.front == None: self.front = ListNode(item) self.rear = self.front else: temp = ListNode(item) current = self.rear self.rear = temp current.set_link(temp)
def sortList(self, head:ListNode) -> ListNode: # h:指向未归并链表头部 # length:链表总长度 # inv:归并链表的长度 h, length, intv = head, 0, 1 # 计算length while h: h, length = h.next, length+1 # 虚拟头结点 res = ListNode(-1) res.next = head while intv < length: # pre:指向待归并链表的前一个节点 pre, h = res, res.next while h: # 获取两个归并链表的头节点h1,h2 # 获取h1 h1, i = h, intv while i and h: h, i = h.next, i-1 # h1指向的链表不足inv,无需归并 if i: break # 获取h2和h2链表长度, 更新h h2, i = h, intv while i and h: h, i = h.next, i-1 # 归并h1、h2 c1, c2 = intv, intv - i while c1 and c2: if h1.val < h2.val: pre.next = h1 h1 = h1.next c1 -= 1 else: pre.next = h2 h2 = h2.next c2 -= 1 pre = pre.next pre.next = h1 if c1 else h2 # 归并剩余 while c1>0 or c2>0: pre = pre.next c1 -= 1 c2 -= 1 pre.next = h intv = intv*2 return res.next
def create_LinkedList(arr=None): if len(arr) == 0: return None else: head = ListNode(int(arr[0])) temp = head for i in arr[1:]: temp.next = ListNode(int(i)) temp = temp.next return head
def solution(self, head): if not head: return False newHead = ListNode(-1) newHead.next = head slow = newHead fast = newHead.next while slow and fast and fast.next: if slow == fast: return True slow = slow.next fast = fast.next.next return False
def hasCycle(self, head): if not head: return False newHead = ListNode(-1) newHead.next = head slow = newHead fast = newHead.next while slow and fast and fast.next: if hash(slow) == hash(fast): return slow slow = slow.next fast = fast.next.next return False
def create_linked_list(node_value_list): """Construct linked list from give list :param node_value_list: Python list with node values :return: Head node of the constructed list """ temp = head = ListNode.ListNode(node_value_list[0]) for v in node_value_list: node = ListNode.ListNode(v) temp.next = node temp = temp.next return head
def countNodes(self, head): # write your code here dummy = ListNode(0) dummy.next = head head = dummy count = 0 while head.next: count += 1 head = head.next return count
def main(): vec = [2, 3, 9, 5, 1, 7] head = ListNode.ListNode(0) head.creatFromList(vec) vec2 = [0] * 500 head2 = ListNode.ListNode(0) head2.creatFromList(vec2) s = Solution() s.test(head.next, True) s.test(head2.next, False)
def removeElements(self, head: ListNode, val: int) -> ListNode: dummy_Head = ListNode(-1) dummy_Head.next = head cur = dummy_Head while cur.next != None: if cur.next.val == val: # 删除cur.next cur.next = cur.next.next else: cur = cur.next return dummy_Head.next
def createListNodes(self, sortedLists): result = [] for l in sortedLists: dummyHead = ListNode.ListNode(None) current = dummyHead for i in range(len(l)): node = ListNode.ListNode(l[i]) current.next = node current = node result.append(dummyHead.next) return result
def solution(self, head): visited = set() if not self.hasCycle(head): return None newHead = ListNode(-1) newHead.next =head while newHead is not None: key = hash(newHead) if key in visited: break else: visited.add(key) newHead = newHead.next return newHead
def solution(self, head, val): if not head: return head top = ListNode(0) top.next = head prev = head = top while top: if top.val == val: if top.next: top.val = top.next.val top.next = top.next.next else: prev.next = None break else: prev = top top = top.next return head.next
def getIntersectionNode(headA, headB): """ :type head1, head1: ListNode :rtype: ListNode """ if headA == None or headB == None: return None else: temp = ListNode(0) temp.next = headB while headA.next != None: while headB.next!=None: if headB.next.val==headA.next.val: return headA.next headB = headB.next headA = headA.next headB = temp.next return None
def deleteDuplicates(self, head): sentry = ListNode(0) sentry.next = head p = sentry.next prev = sentry.next while p: if p.val == prev.val: p = p.next continue prev.next = p prev = p p = p.next if prev: prev.next = p return sentry.next
def removeNthFromEnd(self, head, n): if head == None: return None if head.next == None and n == 1: return None dummyHead = ListNode(-1) dummyHead.next = head prev = dummyHead; cur = head; while n > 0 and cur != None: cur = cur.next n -= 1 if n > 0: return head while cur != None: prev = prev.next cur = cur.next prev.next = prev.next.next return dummyHead.next
def swapPairs(self, head): """ :type head: ListNode :rtype: ListNode """ prehead = ListNode(None) prehead.next = head preptr = prehead ptr = head stack = [] while ptr != None: stack.append(ptr) ptr = ptr.next # print ptr if ptr is None else ptr.val if len(stack) == 2: preptr.next = stack.pop() preptr.next.next = stack.pop() preptr = preptr.next.next if len(stack) == 1: preptr.next = stack.pop() preptr = preptr.next preptr.next = None return prehead.next
def sortedListToBST(self, head): if not head: return head slow = head fast = head pre = None while fast.next and fast.next.next: pre = slow slow = slow.next fast = fast.next.next if pre is not None: pre.next = None else: head = None root = TreeNode(slow.val) root.left = self.sortedListToBST(head) root.right = self.sortedListToBST(slow.next) return root from ListNode import * from TreeNode import * node1 = ListNode(1) node2 = ListNode(3) node3 = ListNode(1) node1.next = node2 solu = Solution() tree = solu.sortedListToBST(node1) print 'ok'
def reverseList(self, head): dummy = ListNode(float("-inf")) while head: dummy.next, head.next, head = head, dummy.next, head.next return dummy.next
def removeNthFromEnd(self, head, n): # create a forward pointer and a sentry forward = head sentry = ListNode(0) sentry.next = head curr = sentry # move a forward pointer for _ in range(0, n): forward = forward.next # move both at the same time while forward: forward = forward.next curr = curr.next # remove element curr.next = curr.next.next return sentry.next