def merge_k_lists_naive2(self, lists): # Time: O(nk*k) where k is the number of lists, with each list having n nodes # since we'll be iterating for a total of nk nodes over k lists orig_head = cur_head = ListNode('dummy') while True: cur_min = ListNode(float('inf')) for index, node in enumerate(lists): if node is None: continue if node.val < cur_min.val: cur_min = node min_index = index if cur_min.val == float('inf'): return orig_head.next else: cur_head.next = cur_min lists[min_index] = cur_min.next cur_head = cur_head.next return orig_head.next if __name__ == '__main__': arr_list = [[10, 15, 25], [5, 12, 20], [1, 4, 7, 11, 17, 22]] # arr_list = [] sorted_list = [] for arr in arr_list: sorted_list.append(construct_linked_list_from_array(arr)) # print_linked_list(merge_k_sorted_lists(sorted_list)) # print_linked_list(merge_k_sorted_lists_using_heap(sorted_list)) print_linked_list(merge_k_sorted_lists_optimized(sorted_list))
while head is None: print(head.val) return orig_less_than_k.next if __name__ == '__main__': test_cases = [ ([], []), ([1, 2, 3, 4], [1, 4, 2, 3]), ([1, 2, 3, 4, 5, 6], [1, 6, 2, 5, 3, 4]), ([1, 2, 3, 4, 5], [1, 5, 2, 4, 3]), ([1, 2, 3], [1, 3, 2]), ([1, 2], [1, 2]), ([1], [1]), ] arr = [ -8, -2, -7, 4, 17, 16, 15, 6, -3, 8, 13, -11, 9, 22, 2, 3, -4, 11, 1, -5, -9, 21, 14, 19, 7, 18, 20, 5, -1, 0, 12, -6, 23, -10, -12, 10 ] head = construct_linked_list_from_array(arr) res = Solution().list_pivoting(head, 3) print 'res is ', res # for index, test_case in enumerate(test_cases, 1): # head = construct_linked_list_from_array(test_case[0]) # res = Solution().reorder_list(head) # expected_res = construct_linked_list_from_array(test_case[1]) # if compare_two_linked_lists(res, expected_res): # print "%d: Passed" % index # else: # print "%d: Failed" % index
root_node.left = left_node # Change head pointer of Linked List for parent recursive calls self.head = self.head.next # print 'new_head ', self.head # Relursively construct the right subtree and link it with root # The number of nodes in right subtree is total nodes - nodes in # left subtree - 1 (for root) which is n-n/2-1*/ root_node.right = self.construct_bst(n - n / 2 - 1) # print 'root_node right', root_node.right return root_node def sorted_linkedlist_to_bst(self, head): """ Idea: http://articles.leetcode.com/convert-sorted-list-to-balanced-binary Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST. """ n = self.get_ll_len(head) self.head = head return self.construct_bst(n) if __name__ == '__main__': arr = [0] arr = [1, 3] # res = Solution().sortedArrayToBST(arr) from linkedlistbase import construct_linked_list_from_array head = construct_linked_list_from_array([10, 20, 30, 40, 50, 60]) head = construct_linked_list_from_array([1]) res = Solution().sorted_linkedlist_to_bst(head)