def mergeInBetween(self, list1, a, b, list2): """ :type list1: ListNode :type a: int :type b: int :type list2: ListNode :rtype: ListNode """ dummy = ListNode(-1) dummy.next = list1 cur = dummy cnt, a, b = 0, a + 1, b + 2 tail1, head1 = None, None while cur: pre = cur cur = cur.next cnt += 1 if cnt == a: tail1 = pre if cnt == b: head1 = cur pre.next = None break cur = list2 while cur.next: cur = cur.next tail1.next = list2 cur.next = head1 return dummy.next
def rotateList(self, head, k): if head == None or head.next == None: return head fake_node = ListNode(0) fake_node.next = head fast = fake_node slow = fake_node # calculate the length l = 0 while fast.next != None: fast = fast.next l += 1 # we need to move the list after (l-k%l)th node node_pos = l - k % l while node_pos > 0: slow = slow.next node_pos -= 1 fast.next = fake_node.next fake_node.next = slow.next slow.next = None return fake_node.next
def mergeKLists(self, lists: List[ListNode]) -> ListNode: """ Running time: O(nk) Space complexity: O(k) """ merged = ListNode('*') merged_head = merged first_nodes_vals = list() for i, node in enumerate(lists): if node is not None: bisect.insort(first_nodes_vals, (node.val, i)) while first_nodes_vals: # find the node with the next min value _, idx = first_nodes_vals.pop(0) # add it to the merged seq merged.next = lists[idx] # update merged and lists[idx] new_head_subseq = lists[idx].next merged = merged.next merged.next = None lists[idx] = new_head_subseq # add new value to first_nodes_vals if applicable if lists[idx] is not None: bisect.insort(first_nodes_vals, (lists[idx].val, idx)) return merged_head.next
def swapNodes(self, head, v1, v2): # write your code here dummy = ListNode(-1) dummy.next = head pre, cur = dummy, head n1, n2 = None, None n1p, n2p = None, None n1x, n2x = None, None while cur: if cur.val == v1: n1, n1p, n1x = cur, pre, cur.next if cur.val == v2: n2, n2p, n2x = cur, pre, cur.next pre = cur cur = cur.next if n1 and n2: if n1.next == n2: n1p.next = n2 n2.next = n1 n1.next = n2x elif n2.next == n1: n2p.next = n1 n1.next = n2 n2.next = n1x else: n1p.next = n2 n2.next = n1x n2p.next = n1 n1.next = n2x return dummy.next
def deleteDuplicates(self, head): """ :type head: ListNode :rtype: ListNode """ if head is None or head.next is None: return head tempNode = ListNode(0) tempNode.next = head cur = head prev = tempNode while cur.next is not None: if cur.val != cur.next.val: remove = False if prev.next == cur: prev = prev.next else: prev.next = cur.next else: remove = True cur = cur.next if remove: prev.next = cur.next return tempNode.next
def addTwoNumbers(l1, l2): carry = 0 ptr_l1 = l1 ptr_l2 = l2 dummy_root = ListNode(0) ptr_res = dummy_root while ptr_l1 and ptr_l2: s = ptr_l1.val + ptr_l2.val + carry carry = int(s / 10) # print(s % 10, carry) ptr_res.next = ListNode(s % 10) ptr_res = ptr_res.next ptr_l1 = ptr_l1.next ptr_l2 = ptr_l2.next while ptr_l1: s = carry + (ptr_l1.val if ptr_l1 else 0) carry = int(s / 10) ptr_res.next = ListNode(s % 10) ptr_res = ptr_res.next ptr_l1 = ptr_l1.next while ptr_l2: s = carry + (ptr_l2.val if ptr_l2 else 0) carry = int(s / 10) ptr_res.next = ListNode(s % 10) ptr_res = ptr_res.next ptr_l2 = ptr_l2.next if carry: ptr_res.next = ListNode(carry) return dummy_root.next
def list_pivoting(L, p): '''Partition L so nodes with value less than p comes before p, and nodes with value greater than p comes after p ''' # create 3 linked list to store the three partitions # constant space since reusing existing nodes less_head = less_iter = ListNode() equal_head = equal_iter = ListNode() greater_head = greater_iter = ListNode() # iterate through list and append node to appropriate lists while L: if L.data < p: less_iter.next = L less_iter = less_iter.next elif L.data > p: greater_iter.next = L greater_iter = greater_iter.next else: # equal to p equal_iter.next = L equal_iter = equal_iter.next # process next node L = L.next # join the three partitions greater_iter.next = None equal_iter.next = greater_head.next less_iter.next = equal_head.next return less_head.next
def removeNthFromEnd(head, n): start = ListNode(0) slow, fast = start, start start.next = head for i in range(0, n + 1): fast = fast.next while fast: slow = slow.next fast = fast.next slow.next = slow.next.next return start.next
def mergeKLists(self, lists): items = [] for node in lists: while node: items.append(node.val) node = node.next dummy = cur = ListNode(None) for i in sorted(items): cur.next = ListNode(i) cur = cur.next return dummy.next
def swapPairs2(head): node = ListNode(0) node.next = head prev, curr = node, head while curr and curr.next: temp = curr.next.next curr.next.next = prev.next prev.next = curr.next curr.next = temp prev = curr curr = prev.next return node.next
def swapPairs(self, head): """ :type head: ListNode :rtype: ListNode """ dummy = ListNode(None) dummy.next = head cur = dummy while cur.next and cur.next.next: a, b = cur.next, cur.next.next cur.next, b.next, a.next = b, a, b.next # swap cur = cur.next.next # link is restored after swap return dummy.next
def removeNthFromEnd2(self, head, n): dummy = ListNode(0) dummy.next = head first = dummy second = dummy for _ in range(n + 1): if first == None: return head first = first.next while (first != None): first = first.next second = second.next second.next = second.next.next return dummy.next
def partition(self, A, B): dummy_left = cur_left = ListNode(None) dummy_right = cur_right = ListNode(None) while A: if A.val < B: cur_left.next = A cur_left = cur_left.next else: cur_right.next = A cur_right = cur_right.next A = A.next cur_right.next = None # end of right might not be empty! cur_left.next = dummy_right.next return dummy_left.next
def Merger(a: ListNode, b: ListNode): if a is None: return b elif b is None: return a if a.val < b.val: a.next = Merger(a.next, b) result = a else: b.next = Merger(a, b.next) result = b return result
def partition(self, head, x): """ :type head: ListNode :type x: int :rtype: ListNode """ tempNodeL = ListNode(0) tempNodeH = ListNode(0) headL = tempNodeL headH = tempNodeH while head: if head.val < x: tempNodeL.next = head tempNodeL = tempNodeL.next else: tempNodeH.next = head tempNodeH = tempNodeH.next head = head.next tempNodeH.next = None tempNodeL.next = headH.next return headL.next
def insertionSortList(A): if A==None or A.next == None: return A current = res = ListNode(A.val) A = A.next while A: if current.val>A.val: head = res #it means node will come before head if head.val>A.val: temp = ListNode(A.val) temp.next = head res = temp A=A.next else: while head and head.next and head.next.val<A.val: head = head.next temp = ListNode(A.val) temp.next = head.next head.next = temp A=A.next else: current.next = ListNode(A.val) current = current.next A = A.next return res
def addTwoNumbers(self, A, B): dummy = node = ListNode(None) carry = 0 while A or B or carry: a_val = A.val if A else 0 b_val = B.val if B else 0 total = a_val + b_val + carry carry, cur_val = divmod(total, 10) node.next = ListNode(cur_val) node = node.next if A: A = A.next if B: B = B.next return dummy.next
def addTwoNumbers2(l1, l2): dummy_root = ListNode(0) ptr = dummy_root carry = 0 while l1 or l2 or carry: l1_val = l1.val if l1 else 0 l2_val = l2.val if l2 else 0 s = l1_val + l2_val + carry ptr.next = ListNode(s % 10) carry = s // 10 if l1: l1 = l1.next if l2: l2 = l2.next ptr = ptr.next # print(listNodeToList(dummy_root.next)) return dummy_root.next
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode: p1, p2 = l1, l2 current = result = ListNode(0) previous = None while p1 or p2 : m_sum = (p1.val if p1 else 0) + (p2.val if p2 else 0) + current.val current.val = m_sum % 10 current.next = ListNode(int(m_sum / 10)) previous = current current = current.next p1 = p1.next if p1 else None p2 = p2.next if p2 else None if previous.next.val == 0: previous.next = None return result
def partition(head, x): curr = head head = tempHead = ListNode(0) pivot = tempPivot = ListNode(x) while curr: if curr.val < x: tempHead.next = curr tempHead = tempHead.next else: tempPivot.next = curr tempPivot = tempPivot.next curr = curr.next tempHead.next = pivot.next tempPivot.next = None return head.next
def addTwoNumbers2(l1, l2): head = ListNode(0) carry, temp = 0, head while l1 or l2 or carry: if l1: temp.val += l1.val l1 = l1.next if l2: temp.val += l2.val l2 = l2.next carry = temp.val / 10 temp.val %= 10 if l1 or l2 or carry: temp.next = ListNode(carry) temp = temp.next return head
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode: dummy = ListNode(0) dummy.next = head slow = dummy fast = head for _ in range(n): fast = fast.next while fast: slow = slow.next fast = fast.next slow.next = slow.next.next return dummy.next
def mergeTwoLists(self, l1, l2): """ :type l1: ListNode :type l2: ListNode :rtype: ListNode """ # If either list is empty return the other list if not l1: return l2 if not l2: return l1 # Use newList for return and curNode for processing each node in the list newList = curNode = ListNode(0) while l1 and l2: if l1.val < l2.val: curNode.next = l1 l1 = l1.next else: curNode.next = l2 l2 = l2.next curNode = curNode.next # Append the list that still has data to the end # All the values will be the largest if l1: curNode.next = l1 else: curNode.next = l2 # The or operator in assignment takes the first value that evaluates to True # and returns it. It's equivalent to the above if/else in this case # curNode.next = l1 or l2 return newList.next
def solve_for_lists(lst: List[List[int]]) -> 'ListNode': lst = [ListNode.to_linkedlist(l) for l in lst] ans = Solution().mergeKLists(lst) if ans is None: return [] else: return ans.to_list()
def mergeKLists1(lists): if not lists: return None elif len(lists) == 1: return lists[0] elif len(lists) == 2: head = temp = ListNode(0) l1, l2 = lists[0], lists[1] while l1 and l2: if l1.val < l2.val: temp.next = l1 l1 = l1.next else: temp.next = l2 l2 = l2.next temp = temp.next if l1: temp.next = l1 if l2: temp.next = l2 return head.next else: length = len(lists) / 2 return mergeKLists1( [mergeKLists1(lists[:length]), mergeKLists1(lists[length:])])
def removeDuplicates(self, head): m = defaultdict(int) dummy = ListNode(-1) dummy.next = head cur = head while cur: m[cur.val] += 1 cur = cur.next pre = dummy cur = head while cur: if m[cur.val] == 1: pre.next = cur pre = cur cur = cur.next pre.next = None return dummy.next
def remove_node(self, head: ListNode) -> ListNode: """ Runtime and space complexity: O(1) """ node = head.next head.next = head.next.next node.next = None return node
def make_tree(arr): head = ListNode('*') head2 = head mapping = [] for val, _ in arr: head2.next = ListNode(val) head2 = head2.next mapping.append(head2) head = head.next head2 = head for _, random in arr: if random is None: head2.random = None else: head2.random = mapping[random] head2 = head2.next return head
def list_partition(head): pivot = median3(head) s_head = s_ptr = ListNode(float("-inf")) l_head = l_ptr = ListNode(float("-inf")) p_head = p_ptr = ListNode(float("-inf")) while head: if head.val < pivot: s_ptr.next = head s_ptr = s_ptr.next elif head.val > pivot: l_ptr.next = head l_ptr = l_ptr.next else: p_ptr.next = head p_ptr = p_ptr.next head = head.next s_ptr.next, l_ptr.next, p_ptr.next = None, None, None return s_head.next, l_head.next, p_head.next, p_ptr
def reverseList_n(self, head: ListNode, n: int) -> ListNode: global successor if (n == 1): successor = head.next return head last = self.reverseList_n(head.next, n - 1) head.next.next = head head.next = successor return last
def addTwoNumbers(self, A, B): #pdb.set_trace() A = self.reverseLinkedList(A) B = self.reverseLinkedList(B) if A is None: return B elif B is None: return A sum = A.val + B.val carry = sum / 10 C = ListNode(sum % 10) returnHead = C A = A.next B = B.next while A is not None and B is not None: sum = A.val + B.val + carry carry = sum / 10 C.next = ListNode(sum % 10) C = C.next A = A.next B = B.next while A is not None: sum = A.val + carry carry = sum / 10 C.next = ListNode(sum % 10) C = C.next A = A.next while B is not None: sum = B.val + carry carry = sum / 10 C.next = ListNode(sum % 10) C = C.next B = B.next if carry != 0: C.next = ListNode(carry) return returnHead
from MergeSortedList import Solution from LinkedList import ListNode head01 = ListNode(1) head02 = ListNode(2) p01 = ListNode(3) p02 = ListNode(5) p03 = ListNode(7) q01 = ListNode(6) q02 = ListNode(8) q03 = ListNode(9) head01.next = p01 p01.next = p02 p02.next = p03 head02.next = q01 q01.next = q02 q02.next =q03 test = Solution() testHead = test.mergeTwoLists(head01, head02) while testHead: print testHead.val testHead = testHead.next
from LinkedListCycle import Solution from LinkedList import ListNode node01 = ListNode(1) node02 = ListNode(2) node03 = ListNode(3) node04 = ListNode(4) node05 = ListNode(5) node01.next = node02 #node02.next = node03 node03.next = node04 node04.next = node05 node05.next = node04 test = Solution() result = test.detectCycle(node01) print result.val if result else None
def push(self, item): node = ListNode(item) if not self.isEmpty(): node.next = self._head self._head = node self._count += 1