def get(self, key): node = self.hash.get(key) if node: self._move_to_front(node) print_ll(self.first_page) return node.data if self.first_page: print_ll(self.first_page) return None
def get_max_list(a, b): result = None pre1 = curr1 = a pre2 = curr2 = b while curr1 is not None or curr2 is not None: sum1 = 0 sum2 = 0 # iterating till and equal node is found while curr1 is not None and curr2 is not None and curr1.data != curr2.data: if curr1.data < curr2.data: sum1 += curr1.data curr1 = curr1.nxt else: sum2 += curr2.data curr2 = curr2.nxt # if one of them becomes none in the process if curr1 is None: while curr2 is not None: sum2 += curr2.data curr2 = curr2.nxt if curr2 is None: while curr1 is not None: sum1 += curr1.data curr1 = curr1.nxt # initialization of result for the first time based on sum if pre1 == a and pre2 == b: result = pre1 if sum1 > sum2 else pre2 else: # further decisions based on sum if sum1 > sum2: pre2.nxt = pre1.nxt else: pre1.nxt = pre2.nxt pre1 = curr1 pre2 = curr2 if curr1 is not None: curr1 = curr1.nxt if curr2 is not None: curr2 = curr2.nxt if result: print_ll(result)
def put(self, key): if key in self.hash: node = self.hash[key] self._move_to_front(node) else: if self.node_count == self.max_count: self._remove_last_node() node = DNode(key) self.hash[key] = node self._add_to_front(node) self.node_count += 1 print_ll(self.first_page)
if new_head: new_tail.nxt = eqll_h else: new_head = eqll_h new_tail = eqll_t if gtll_h: if new_head: new_tail.nxt = gtll_h else: new_head = gtll_h return new_head if __name__ == '__main__': ll = create_linked_list([1, 4, 3, 2, 5, 2, 3]) res = partition_ll(ll, 3) print_ll(res) print '' ll = create_linked_list([1, 4, 2, 10]) res = partition_ll(ll, 3) print_ll(res) print '' ll = create_linked_list([10, 4, 20, 10, 3]) res = partition_ll(ll, 3) print_ll(res)
if head == h: prev, h, nxt, t = move_node_to_end(prev, h, nxt, True, t) head = h else: prev, h, nxt, t = move_node_to_end(prev, h, nxt, False, t) else: prev = h h = nxt nxt = nxt.nxt return head if __name__ == '__main__': _h = create_linked_list([17, 15, 8, 12, 10, 5, 4, 1, 7, 6]) print_ll(segregate_odd_and_even(_h)) """ better approach """ def add_to_ll(head, tail, node): if head: tail.nxt = node return head, node return node, node def segregate_odd_and_even_another_app(head): odd_h = odd_t = even_h = even_t = None
add_to_list(head) nxt = head.nxt flatten_depth_wise(head.down) flatten_depth_wise(nxt) if __name__ == '__main__': l1 = create_linked_list([1, 2, 3, 4], node=Node) n2 = l1.nxt n2.down = create_linked_list([7, 8, 10, 12], node=Node) l2 = n2.down l2.down = Node(9) l2.down.down = Node(14) l2.down.down.down = Node(15) l2.down.down.down.nxt = Node(23) l2.down.down.down.nxt.down = Node(24) l2n2 = l2.nxt l2n2.down = Node(16) l2n2.down.down = create_linked_list([17, 18, 19, 20], node=Node) l2n2.down.down.nxt.nxt.nxt.down = Node(21) l2.nxt.nxt.down = Node(11) flatten_depth_wise(l1) print '' print_ll(HEAD)
""" merge two sorted linked lists """ from G4G.Problems.linked_list.linked_list import create_linked_list, print_ll def sorted_merge(a, b): if a is None: return b if b is None: return a if a.data > b.data: result = b result.nxt = sorted_merge(a, b.nxt) else: result = a result.nxt = sorted_merge(b, a.nxt) return result if __name__ == '__main__': l1 = create_linked_list([1, 3, 5, 7, 9]) l2 = create_linked_list([2, 4, 6, 8, 10]) r = sorted_merge(l1, l2) print_ll(r)
if clone_node.nxt: clone_node.nxt = clone_node.nxt.nxt node = node.nxt return cl_start if __name__ == '__main__': # with extra space ll1 = create_linked_list([1, 2, 3, 4], node=Node) ll1.other = ll1.nxt.nxt ll1.nxt.other = ll1.nxt.nxt.nxt ll1.nxt.nxt.other = ll1 ll1.nxt.nxt.nxt.other = ll1.nxt print_ll(ll1) ll2 = clone_without_extra_space(ll1) print_ll(ll2) print ll2.other print ll2.nxt.other print ll2.nxt.nxt.other print ll2.nxt.nxt.nxt.other print '' # without extra space ll1 = create_linked_list([1, 2, 3, 4], node=Node) ll1.other = ll1.nxt.nxt ll1.nxt.other = ll1.nxt.nxt.nxt ll1.nxt.nxt.other = ll1 ll1.nxt.nxt.nxt.other = ll1.nxt
""" http://www.geeksforgeeks.org/rotate-a-linked-list/ """ from G4G.Problems.linked_list.linked_list import create_linked_list, print_ll from G4G.Problems.linked_list.segregate_odd_and_even_in_ll import get_tail_ll def rotate_ll(head, k): # converting to circular ll temporarily tail = get_tail_ll(head) tail.nxt = head while k > 0: tail = head head = head.nxt k -= 1 tail.nxt = None return head if __name__ == '__main__': h = create_linked_list([1, 2, 3, 4, 5, 6]) n = rotate_ll(h, 9) print_ll(n)
while b is not None and b.nxt is not None: a.nxt = a.nxt.nxt b.nxt = b.nxt.nxt a = a.nxt b = b.nxt a.nxt = None return h1, h2 if __name__ == '__main__': h = create_linked_list([0, 1, 0, 1, 0, 1]) _h1, _h2 = alternate_split(h) print_ll(_h1) print_ll(_h2) print '' h = create_linked_list([0, 1, 0, 1, 0]) _h1, _h2 = alternate_split(h) print_ll(_h1) print_ll(_h2) print '' h = create_linked_list([0, 1]) _h1, _h2 = alternate_split(h) print_ll(_h1) print_ll(_h2)
node.nxt = prev return prev def reverse2(node, prev): if node is None: return prev else: temp = reverse2(node.nxt, node) node.nxt = prev return temp if __name__ == '__main__': start = create_linked_list([1, 2, 3, 4, 5, 3, 2, 6, 7, 8, 9, 4, 7]) print_ll(start) new_head = reverse2(start, None) print_ll(new_head) """ Iterative reverse """ def iterative_reverse(head): prev = head curr = head.nxt prev.nxt = None while curr:
""" Delete a node from an ll given access to only that node """ from G4G.Problems.linked_list.linked_list import create_linked_list, print_ll, get_node def delete_node(node): if node.nxt: next_node = node.nxt node.data = next_node.data node.nxt = next_node.nxt next_node.nxt = None del next_node start = create_linked_list([1, 2, 3, 4, 5, 3, 2, 6, 7, 8, 9, 4, 7]) print_ll(start) node = get_node(start, 3) print node.data delete_node(node) print_ll(start)
t.nxt = head return h def add_lls(h1, h2): c1 = count_nodes(h1) c2 = count_nodes(h2) ll = h1 if c1 >= c2 else h2 sl = h1 if ll == h2 else h2 sl = append_zeros(sl, abs(c1 - c2)) carry = add_eq_len_lls(ll, sl) if carry > 0: head = Node(carry) head.nxt = h1 return head return h1 if __name__ == '__main__': l1 = create_linked_list([5, 6, 3]) l2 = create_linked_list([8, 4, 2]) _sum_list = add_lls(l1, l2) print_ll(_sum_list)
from sys import maxint # 1 2 3 from G4G.Problems.dp.min_matrix_cost_path_to_mn import print_matrix from G4G.Problems.linked_list.linked_list import create_linked_list, print_ll def reverse(head, prev): if head is None: return prev, head # 9, 8 - 8, 7 a, b = reverse(head.nxt, head) if b is None: return head, head b.nxt = head return a, head if __name__ == '__main__': h = create_linked_list([1, 2, 3, 4, 5, 6, 7, 8, 9]) rl, rt = reverse(h, None) rt.nxt = None print_ll(rl)
n2.nxt = nxt1 else: # somewhere in between pre1.nxt = n2 n2.nxt = nxt1 pre2.nxt = n1 n1.nxt = nxt2 return head if __name__ == '__main__': h = create_linked_list([1, 2, 3, 4, 5, 6, 7, 8]) h1 = swap_kth_beg_and_end(h, 1) print_ll(h1) print '' h = create_linked_list([1, 2, 3, 4, 5, 6, 7, 8]) h1 = swap_kth_beg_and_end(h, 2) print_ll(h1) print '' h = create_linked_list([1, 2, 3, 4, 5, 6, 7, 8]) h1 = swap_kth_beg_and_end(h, 3) print_ll(h1) print ''
def sort_abs_val_sorted_ll(head): curr = head.nxt prev = head while curr is not None: if curr.data < prev.data: prev.nxt = curr.nxt curr.nxt = head head = curr curr = prev else: prev = curr curr = curr.nxt return head if __name__ == '__main__': h = create_linked_list([0, 1, -2, 3, 4, 5, -5]) sh = sort_abs_val_sorted_ll(h) print_ll(sh)
while head1 is not None and head2 is not None: if head1.data <= head2.data: node = head1 head1 = head1.nxt head = add_to_list(node, head) else: node = head2 head2 = head2.nxt head = add_to_list(node, head) while head1 is not None: node = head1 head1 = head1.nxt head = add_to_list(node, head) while head2 is not None: node = head2 head2 = head2.nxt head = add_to_list(node, head) return head if __name__ == '__main__': h1 = create_linked_list([5, 10, 15, 40]) h2 = create_linked_list([2, 3, 20]) h = merge_sorted_lls(h1, h2) print_ll(h)
if l1.power >= l2.power: lp = l1 sp = l2 else: lp = l2 sp = l1 res = lp while lp.power != sp.power: lp = lp.nxt while lp is not None: lp.data += sp.data lp = lp.nxt sp = sp.nxt return res if __name__ == '__main__': l1 = Node(5, 2) l1.nxt = Node(4, 1) l1.nxt.nxt = Node(2, 0) l2 = Node(5, 1) l2.nxt = Node(5, 0) print_ll(add_poly(l1, l2))