def reverseKGroup(self, head, k): """ :type head: ListNode :type k: int :rtype: ListNode """ # Get Length p = head ll = 0 while p is not None: p = p.next ll += 1 # reverse p = head head = ListNode(0) head.next = p prev_end = head for i in range(0, ll // k): cur_start = cur_end = prev_end.next for j in range(0, k - 1): cur_end = cur_end.next if cur_end is None: next_start = None else: next_start = cur_end.next p, q, r = prev_end, prev_end.next, prev_end.next.next for j in range(0, k): q.next = p p, q = q, r if r is not None: r = r.next cur_start.next = next_start prev_end.next = cur_end prev_end = cur_start return head.next
def reverseBetween(self, head, m, n): """ :type head: ListNode :type m: int :type n: int :rtype: ListNode """ if head is None or head.next is None or m == n: return head head, p = ListNode(0), head head.next = p p, q, r = head, head.next, head.next.next n -= m m -= 1 while m > 0: p, q = q, r if r is not None: r = r.next m -= 1 flag1, flag2 = p, q n += 1 while n > 0: q.next = p n -= 1 if n == 0: flag1.next, flag2.next = q, r break p, q = q, r if r is not None: r = r.next return head.next
def insertionSortList(self, head): if not head or not head.next: return head dummy_head = ListNode(-1) dummy_head.next = head pre = dummy_head cur = dummy_head while cur.next: if cur.next.val < pre.next.val: pre = dummy_head while pre.next.val < cur.next.val: pre = pre.next if pre != cur: # insert tmp after pre tmp = cur.next cur.next = tmp.next tmp.next = pre.next pre.next = tmp else: cur = cur.next return dummy_head.next
def mergeKLists(self, lists: List[ListNode]) -> ListNode: min_node, max_node = ListNode(-2**32), ListNode(2**32 - 1) self.lists = [min_node] for ele in lists: self.lists.append(ele if ele else max_node) self.length = len(lists) if not self.length: return else: dummy_head = ListNode(None) node = dummy_head for i in range(self.length): if not self.lists[i]: self.lists[i] = max_node self.createLoserTree() while self.lists[self.loser_tree[0]] != max_node: node.next = self.lists[self.loser_tree[0]] node = node.next if self.lists[self.loser_tree[0]].next: self.lists[self.loser_tree[0]] = self.lists[ self.loser_tree[0]].next else: self.lists[self.loser_tree[0]] = max_node self.adjustTree(self.loser_tree[0]) node.next = None return dummy_head.next
def reverseList(self, head: ListNode) -> ListNode: if not head: return None head_1, head_2 = ListNode(0), ListNode(0) head_1.next = head while head_1.next: node = head_1.next head_1.next = node.next node.next = head_2.next head_2.next = node return head_2.next
def removeElements(self, head: ListNode, val: int) -> ListNode: dummy = ListNode(None) dummy.next = head pre, cur = dummy, head while cur: if cur.val == val: cur = cur.next pre.next = cur else: pre = cur cur = cur.next return dummy.next
def deleteDuplicates(self, head: ListNode) -> ListNode: dummy = ListNode(None) dummy.next = head pre, cur = dummy, head while cur and cur.next: if cur.val == cur.next.val: node = cur.next.next while node and node.val == cur.val: node = node.next pre.next = node cur = node else: pre, cur = cur, cur.next return dummy.next
def reverseListIterative(self, head: ListNode) -> ListNode: # First store the elements in a normal list: stack while scanning though the linked list current = head stack = [] while current.val: stack.append(current.val) current = current.next reverse = ListNode(stack.pop()) current = reverse # Build the reverse list by poping the element from the stack one after another while stack: current.next = ListNode(stack.pop()) current = current.next return reverse
def partition(self, head: ListNode, x: int) -> ListNode: p0, p1 = ListNode(0), ListNode(0) head0, head1 = p0, p1 while head is not None: if head.val < x: p0.next = head p0 = p0.next else: p1.next = head p1 = p1.next head = head.next p0.next = head1.next p1.next = None return head0.next
def swapPairs(self, head): """ :type head: ListNode :rtype: ListNode """ p = head head = ListNode(0) head.next = p p = head while p.next is not None and p.next.next is not None: tp1, tp2, q = p.next, p.next.next, p.next.next.next p.next, tp2.next, tp1.next = tp2, tp1, q p = tp1 return head.next
def build_testing_node_sequence(self): node_1 = ListNode(-2) node_0 = ListNode(-1) node_2 = ListNode(-3) node_1.insert_precursor(node_0) node_1.insert_successor(node_2) return node_0
def removeElements(self, head, val): """ :type head: ListNode :type val: int :rtype: ListNode """ p = head head = ListNode(0) head.next = p p = head while p is not None and p.next is not None: while p.next is not None and p.next.val == val: p.next = p.next.next p = p.next return head.next
def __init__(self, initial_iterable=None): """ Constructor Args: initial_iterable (iterable): iterable object which has the data used to be saved in nodes of this list """ self._head = ListNode(data=None, precursor=None, successor=None) self._tail = ListNode(data=None, precursor=self._head, successor=None) self._head._successor = self._tail self._size = 0 if initial_iterable is not None: self.copy_from(initial_iterable)
def partition(self, head: ListNode, x: int) -> ListNode: d_l = ListNode(None) d_h = ListNode(None) n_l, n_h = d_l, d_h while head: if head.val < x: n_l.next = head n_l = n_l.next else: n_h.next = head n_h = n_h.next head = head.next n_l.next = d_h.next n_h.next = None return d_l.next
def deleteDuplicates(self, head: 'ListNode') -> 'ListNode': if head is None: return None p = ListNode(0) p.next = head head = p while p.next is not None and p.next.next is not None: if p.next.val == p.next.next.val: current = p.next.val while p.next.next is not None and p.next.next.val == current: p.next.next = p.next.next.next p.next = p.next.next else: p = p.next return head.next
def removeNthFromEnd(self, head, n): """ :type head: ListNode :type n: int :rtype: ListNode """ node_1, node_2 = ListNode(None), head node_1.next = head head = node_1 for i in range(1, n): node_2 = node_2.next while node_2.next: node_1 = node_1.next node_2 = node_2.next node_1.next = node_1.next.next return head.next
def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode: dummy = ListNode(None) dummy.next = head prev, cur = dummy, head i = 1 while i<m: prev, cur = cur, cur.next i += 1 head, tail = prev, cur while i<=n: next_node = cur.next cur.next = prev prev, cur = cur, next_node i += 1 head.next = prev tail.next = cur return dummy.next
def removeNthFromEnd(self, head, n): dummy = ListNode(-1) dummy.next = head pre = dummy cur = head end = head for i in range(1, n): end = end.next while end.next: pre = pre.next cur = cur.next end = end.next pre.next = cur.next return dummy.next
def make_cycle_list(L: list, pos) -> ListNode: """ Almost make a circle list """ node = ListNode(L[0]) res = node pointer = 1 count = 1 # Add next node while count < 3 * len(L): node.next = ListNode(L[pointer]) node = node.next if pointer % len(L) == len(L) - 1: pointer = pos else: pointer += 1 count += 1 return res
def reverseKGroup(self, head: ListNode, k: int) -> ListNode: dummy_N, dummy_O = ListNode(0), ListNode(0) dummy_O.next = head length, node = 0, head while node: length += 1 node = node.next node_N = dummy_N for _ in range(length // k): tail = dummy_O.next for _ in range(k): node_O = dummy_O.next dummy_O.next = node_O.next node_O.next = node_N.next node_N.next = node_O node_N = tail node_N.next = dummy_O.next return dummy_N.next
def mergeTwoListsIterative(self, l1: ListNode, l2: ListNode) -> ListNode: if l1 is None: return l2 elif l2 is None: return l1 # Trick to initialize res = ListNode(0) node = res while l1 or l2: if (l1 and l2 and l1.val < l2.val) or (not l2): node.val = l1.val l1 = l1.next elif (l1 and l2 and l1.val >= l2.val) or (not l1): node.val = l2.val l2 = l2.next if l1 or l2: node.next = ListNode(0) node = node.next return res
def sortArray_Radix(self, nums: List[int]) -> List[int]: head = ListNode(None) node = head max_val = min_val = nums[0] for num in nums: if num > max_val: max_val = num if min_val > num: min_val = num node.next = ListNode(num) node = node.next if min_val < 0: val = max(max_val, abs(min_val)) else: val = max_val key_count = len(str(val)) for i in range(key_count): head = self.collect(self.distribute(head, i)) return self.traverse(head)
def swapPairs(self, head: ListNode) -> ListNode: if not head: return head cur = ListNode(None) cur.next = head head = cur while True: if cur.next: node_1 = cur.next if node_1.next: node_2 = node_1.next cur.next = node_2 node_1.next = node_2.next node_2.next = node_1 cur = node_1 else: break else: break return head.next
def removeNthFromEnd(self, head, n): """ :type head: ListNode :type n: int :rtype: ListNode """ # get length p = head ll = 0 while p is not None: ll += 1 p = p.next on = ll + 1 - n # delete node p = ListNode(0) p.next = head q = p for _ in range(1, on): q = q.next q.next = q.next.next return p.next
def isPalindrome(self, head: ListNode) -> bool: dummy1, dummy2 = ListNode(None), ListNode(None) dummy1.next = head slow = fast = dummy1 while fast and fast.next: slow = slow.next fast = fast.next.next cur = slow.next while cur: node = cur.next cur.next = dummy2.next dummy2.next = cur cur = node slow, fast = dummy1, dummy2 while slow and fast: if slow.val==fast.val: slow = slow.next fast = fast.next else: return False else: return True
def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode: dummy = ListNode(None) dummy.next = head i = 1 head = dummy while i<m: head = head.next i += 1 node = head.next while i<n: node = node.next i+=1 tail = node.next node.next = None node = head.next head.next = tail while node: temp = node.next node.next = head.next head.next = node node = temp return dummy.next
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode: dummy_head = ListNode(0) node = dummy_head while l1 and l2: if l1.val < l2.val: node.next = l1 l1 = l1.next else: node.next = l2 l2 = l2.next node = node.next node.next = l1 if l1 else l2 return dummy_head.next
def distribute(self, head, key): lists = list() for _ in range(10): dummy_head = ListNode(None) node = dummy_head lists.append((dummy_head, node)) node = head.next while node: val = node.val // (10**key) % 10 h, n = lists[val] n.next = node node = node.next n = n.next n.next = None lists[val] = (h, n) return lists
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode: head = ListNode(None) pos = head while l1 and l2: if l1.val >= l2.val: pos.next = l2 l2 = l2.next else: pos.next = l1 l1 = l1.next pos = pos.next if l1: pos.next = l1 elif l2: pos.next = l2 return head.next
def mergeKLists(self, lists): """ :type lists: List[ListNode] :rtype: ListNode """ heap = PriorityQueue() for list_item in lists: if list_item is not None: heap.put(HeapItem(list_item.val, list_item)) p = result_head = ListNode(0) while not heap.empty(): current = heap.get() p.next = current.data if current.data.next is not None: heap.put(HeapItem(current.data.next.val, current.data.next)) p = p.next p.next = None return result_head.next
def copy_from(self, iterable): """ Copies content from given iterable Args: iterable (iterable): iterable object from which contents are copied and put into list """ temp = self._head self._size = 0 for e in iterable: new_node = ListNode(data=e, precursor=temp) temp.insert_successor(new_node) temp = temp._successor self._size += 1 temp._successor = self._tail self._tail._precursor = temp
def insertionSortList(self, head: ListNode) -> ListNode: head_n = ListNode(float("-inf")) while head: n_1, n_2 = head_n, head_n.next while n_2: if head.val<n_2.val: n_1.next = head head = head.next n_1.next.next = n_2 break else: n_1 = n_2 n_2 = n_2.next else: n_1.next = head head = head.next n_1.next.next = None return head_n.next
if a is b: found = True break # distance from head to loop head is the same as meeting piont to loop head # find the loop head by moving a and h if found: h = head while h is not a: a = a.next h = h.next return h return None else: return None t = ListNode(3) t.next = ListNode(2) t.next.next = ListNode(0) t.next.next.next = ListNode(-4) t.next.next.next.next = t.next #t = ListNode(1) #t.next = ListNode(2) #t.next.next = t sol = Solution() print sol.detectCycle(t).val