def insert(self, index, data): """ Purpose: Insert new node at given index position :param index: node index to insert :param data: new node data :return: """ if index == 0 or self.head is None: self.push_front(data=data) return if index >= self.__len__(): self.push_back(data=data) return n = Node(data=data) i = 0 current = self.head prev = self.head while current: if index == i: prev.next = n n.next = current self.size += 1 return i += 1 prev = current current = current.next
def push(self, new_data): new_node = Node(data = new_data) new_node.prev = None # at the beginning new_node.next = self.head if self.head is not None: self.head.prev = new_node self.head = new_node
def add_two_numbers(l1, l2): result_nodes = [] remember_val = 0 current_node_l1, current_node_l2 = l1, l2 while True: result_val = (current_node_l1.value if current_node_l1 else 0) + (current_node_l2.value if current_node_l2 else 0) + remember_val if result_val > 9: result_val -= 10 remember_val = 1 else: remember_val = 0 result_nodes.append(Node(result_val)) current_node_l1, current_node_l2 = current_node_l1.next_node if current_node_l1 else None, current_node_l2.next_node if current_node_l2 else None if not current_node_l1 and not current_node_l2: break if remember_val: result_nodes.append(Node(remember_val)) for i in range(len(result_nodes) - 1): result_nodes[i].next_node = result_nodes[i+1] return result_nodes[0]
def insert_after(self, prev_node, new_data): if prev_node is None: print("Error: given prev_node is None") return new_node = Node(data = new_data) new_node.prev = prev_node new_node.next = prev_node.next if new_node.next is not None: # if new_node.next (prev_node.next) is None it means we are at the end of the list new_node.next.prev = new_node prev_node.next = new_node
def add_to_head(self, item): new_node = Node() new_node.item = item if not self.head: self.head = new_node else: old_head = self.head new_node.next = old_head self.head = new_node
def insert_before(self, next_node, new_data): if next_node is None: print("Error: given next_node is None") return new_node = Node(data = new_data) new_node.next = next_node new_node.prev = next_node.prev if new_node.prev is not None: # if new_node.prev (next_node.prev) is None it means we are at the beginning of the list new_node.prev.next = new_node next_node.prev = new_node
def add_to_head(self, item): new_node = Node() new_node.item = item if not self.head: self.head = new_node else: old_head = self.head new_node.next = old_head self.head = new_node
def append(self, new_data): new_node = Node(data = new_data) new_node.next = None # at the last last = self.tail # if list is empty then this is the first node if last is None: new_node.prev = None self.head = new_node return last.next = new_node new_node.prev = last
def add_to_tail(self, item): if not self.head: return self.add_to_head(item) current = self.head old_tail = current while (current): old_tail = current current = current.next new_tail = Node() new_tail.item = item old_tail.next = new_tail
def add_to_tail(self, item): if not self.head: return self.add_to_head(item) current = self.head old_tail = current while(current): old_tail = current current = current.next new_tail = Node() new_tail.item = item old_tail.next = new_tail
def push_front(self, data): """ Purpose: Push (add) node to front of SLL :param data: new node data :return: """ n = Node(data=data) if self.head is None: self.head = n self.size += 1 return old_head = self.head self.head = n n.next = old_head self.size += 1
def flatten(self, head): """ :type head: Node :rtype: Node """ if head is None: return None dummy = Node(0, None, head, None) cur = dummy stack = [] stack.append(head) while len(stack) > 0: node = stack.pop() cur.next = node node.prev = cur cur = node if node.next: stack.append(node.next) if node.child: stack.append(node.child) node.child = None head = dummy.next head.prev = None return head
def solve(self, node: Node): if node.next: copied_node = node.next node.val, node.next = copied_node.val, copied_node.next copied_node.next = None else: node = None
def __init__(self): super().__init__() self.test_cases = [({ 'head': Node( 1, Node(5, Node(3, Node(8, Node(10, Node(11, Node(15, Node(18)))))))), 'k': 1 }, 15)]
def insert_at_position(self, position, data): """ Insert at given position of the Linked List. """ new_node = Node(data) if position == 1: # Insert at 1st position, # when linked list is empty or if to insert at position 1 when linked list contains items. new_node.set_next(self.head) self.head = new_node self.size += 1 else: # Insert ay any position between 2 to last+1 temp = self.head for i in range(1, position - 1): # Traverse still position-1 temp = temp.get_next() new_node.set_next(temp.get_next()) temp.set_next(new_node) self.size += 1
def append(self, value): ''' Appends a new element to the Linked List at the end. If the list is empty, then it´s added as both, head and tail nodes. Arguments: value -- an object to add. ''' new_node = Node() new_node.data = value if(self.head is None): self.head = new_node self.tail = new_node self.size = 1 return self.size = 1 self.tail.next = new_node new_node.previous = self.tail self.tail = new_node
def insert_at_head(self, data): """ Given the object, data Then increment the linked list size by one And create a new node using the object, data When the head is not currently assigned (self.head == None) Then assign the newly created node to the head node When the head does have a valid object reference Then link the newly created node as the head (new_node = self.head) Performance: O(1) :param data: the object that the node will hold """ self.size = self.size + 1 new_node = Node(data) if self.head is not None: # link the new node to the current head new_node.next_node = self.head # assign the head position to the new node self.head = new_node
def solve(self, head: Node, node: Node): new_head = node new_tail = node current = head while current is not None: current_copy = Node(current.val) if current < node: new_head, new_head.next = current_copy, new_head else: new_tail.next = current_copy new_tail = current_copy current = current.next return new_head
def test_something(self): node1 = Node(1) node2 = Node(2) node3 = Node(3) node4 = Node(4) node5 = Node(5) node1.next_node = node2 # node2.next_node = node3 # node3.next_node = node4 # node4.next_node = node5 remove_nth_from_end(node1, 2) self.assertEqual(True, False)
def push_back(self, data): """ Purpose: Push (add) node to back of SLL :param data: new node data :return: """ if self.head is None: self.push_front(data=data) return n = Node(data=data) current = self.head while current: if current.next is None: current.next = n self.size += 1 return current = current.next
def insert_at_tail(self, data): """ Given the object, data Then increment the linked list size by one And create a new node using the object, data And set the current node reference to the head node Given that the current node is not None Then assign the current node to the current node's next node When current_node is None Then assign the current node to the new node (effectively inserting at the list's tail) :param data: the data value to insert into the linked list """ self.size = self.size + 1 new_node = Node(data) current_node = self.head while current_node.next_node is not None: current_node = current_node.next_node current_node.next_node = new_node
def insert_at(self, index, value): ''' Inserts a value at the given position. index -- the position as an int. value -- an object. ''' if not isinstance(index, int): raise TypeError("index is not of type int") if index < 0 or index > self.size: raise LookupError("index out of bounds") new_node = Node() new_node.data = value if self.head is None: self.head = new_node self.tail = new_node self.size = 1 return if index == 0: new_node.next = self.head self.head.previous = new_node self.head = new_node self.size = 1 else: current_node = self.head for i in range(index-1): current_node = current_node.next new_node.previous = current_node new_node.next = current_node.next current_node.next = new_node if(new_node.next is None): self.tail = new_node self.size = 1
def __init__(self): super().__init__() self.test_cases = [({ 'head': None }, None), ({ 'head': Node(1) }, Node(1)), ({ 'head': Node(1, _next=Node(2)) }, Node(1, _next=Node(2))), ({ 'head': Node(1, _next=Node(1, _next=Node(1, _next=Node(2)))) }, Node(1, _next=Node(2)))]
def test_something(self): l1_node1 = Node(2) l1_node2 = Node(4) l1_node3 = Node(3) l1_node1.next_node = l1_node2 l1_node2.next_node = l1_node3 l2_node1 = Node(5) l2_node2 = Node(6) l2_node3 = Node(4) l2_node1.next_node = l2_node2 l2_node2.next_node = l2_node3 l3_node1 = Node(7) l3_node2 = Node(0) l3_node3 = Node(8) l3_node1.next_node = l3_node2 l3_node2.next_node = l3_node3 result = add_two_numbers(l1_node1, l2_node1) self.assertEqual(result.value, l3_node1.value) self.assertEqual(result.next_node.value, l3_node2.value) self.assertEqual(result.next_node.next_node.value, l3_node3.value)
# def append(self, cur, dummy): # while cur: # dummy.next = cur # cur.prev = dummy # dummy = dummy.next # if cur.child: # next = cur.next # dummy = self.append(cur.child, dummy) # cur.child = None # cur = next # else: # cur = cur.next # # return dummy # n1 = Node(1, None, None, None) n2 = Node(2, n1, None, None) n3 = Node(3, n2, None, None) n4 = Node(4, n3, None, None) n5 = Node(5, n4, None, None) n6 = Node(6, n5, None, None) n7 = Node(7, n6, None, None) n8 = Node(8, n7, None, None) n9 = Node(9, n8, None, None) n10 = Node(10, n9, None, None) n11 = Node(11, n10, None, None) n12 = Node(12, n11, None, None) n1.next = n2 n2.next = n3 n3.next = n4 n4.next = n5