def main(): linked_list = LinkedList(0) for i in range(10): linked_list.insert(i+1) linked_list.print_linked_list() linked_list.delete(3) linked_list.print_linked_list()
def main(): first_list = LinkedList() second_list = LinkedList() for i in range(3): first_list.insert(i) for i in range(3): second_list.insert(i)
def test_insert_node_in_the_begining(self): ll = LinkedList(5) ll.append_node(6) ll.append_node(10) ll.append_node(20) ll.insert_node_in_the_begining(7) result_ll = ll.get_linkedlist() actual_list = [7,5,6,10,20] self.assertEqual(result_ll,actual_list)
def test_delete_node(self): ll = LinkedList(5) ll.append_node(6) ll.append_node(10) ll.append_node(20) ll.delete_node(6) result_ll = ll.get_linkedlist() actual_list = [5,10,20] self.assertEqual(result_ll,actual_list)
def rearrange(list): first = list slow = first fast = slow secound = None new_list = LinkedList() new_node = None flag = True while fast.get_next() and fast.get_next().get_next(): slow = slow.get_next() fast = fast.get_next().get_next() secound = slow.get_next() slow.set_next(None) l1 = LinkedList(secound) l1.reverse_list() secound = l1.head while first and secound: if new_node is None: new_node = Node(first.get_data()) new_list.head = new_node first = first.get_next() flag = False elif flag is True: new_node.set_next(Node(first.get_data())) new_node = new_node.get_next() first = first.get_next() flag = False elif flag is False: new_node.set_next(Node(secound.get_data())) new_node = new_node.get_next() secound = secound.get_next() flag = True if secound is not None: new_node.set_next(secound) if first is not None: new_node.set_next(first) return new_list.head
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def __len__(self): return self.size def enqueue(self, value): # self.storage.append(value) self.storage.add_to_tail(value) self.size += 1 def dequeue(self): if self.size == 0: return None self.size -= 1 return self.storage.remove_head()
class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def __len__(self): return self.size def enqueue(self, value): self.size += 1 return self.storage.add_to_tail(value) def dequeue(self): if self.size > 0: self.size -= 1 return self.storage.remove_head() def len(self): return len(self.storage)
def test_validdata(self): ll = LinkedList(5) ll.append_node(6) ll.append_node(10) ll.append_node(20) result_ll = ll.get_linkedlist() actual_list = [5,6,10,20] self.assertEqual(result_ll,actual_list)
class Stack: def __init__(self): self.size = 0 # self.storage = [] self.storage = LinkedList() def __len__(self): return self.size def push(self, value): # self.storage.append(value) #adding values to the list self.size += 1 #incrementing size so when we ask for lenth we get the correct answer self.storage.add_to_tail(value) def pop(self): if self.size == 0: return None self.size -= 1 return self.storage.remove_tail()
from single_linked_list import LinkedList, Node def getCount(head_node): #code here cnt = 0 temp = head_node while temp != None: cnt += 1 temp = temp.next return cnt if __name__ == '__main__': # t = int(input()) # for cases in range(t): n = int(input()) a = LinkedList() nodes = list(map(int, input().strip().split())) for data in nodes: node = Node(data) a.append(node) print(getCount(a.head))
def test_merge(self): s_list_one = LinkedList() s_list_one.add_in_tail(Node(1)) s_list_one.add_in_tail(Node(2)) s_list_one.add_in_tail(Node(3)) s_list_one.add_in_tail(Node(4)) s_list_one.add_in_tail(Node(5)) s_list_one.add_in_tail(Node(6)) s_list_one.add_in_tail(Node(7)) s_list_one.add_in_tail(Node(8)) s_list_one.add_in_tail(Node(9)) s_list_one.add_in_tail(Node(10)) s_list_one.add_in_tail(Node(11)) s_list_one.add_in_tail(Node(12)) s_list_one.add_in_tail(Node(13)) s_list_two = LinkedList() s_list_two.add_in_tail(Node(13)) s_list_two.add_in_tail(Node(12)) s_list_two.add_in_tail(Node(11)) s_list_two.add_in_tail(Node(10)) s_list_two.add_in_tail(Node(9)) s_list_two.add_in_tail(Node(8)) s_list_two.add_in_tail(Node(7)) s_list_two.add_in_tail(Node(6)) s_list_two.add_in_tail(Node(5)) s_list_two.add_in_tail(Node(4)) s_list_two.add_in_tail(Node(3)) s_list_two.add_in_tail(Node(2)) s_list_two.add_in_tail(Node(1)) s_list_merged = merge_list(s_list_two, s_list_one) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.assertEqual(s_list_merged.len(), self.list_test.len()) node = s_list_merged.head node_test = self.list_test.head while node is not None and node_test is not None: self.assertEqual(node.value, node_test.value) node = node.next node_test = node_test.next
from single_linked_list import Node, LinkedList def kth_to_last(self, k): fast = self.head slow = self.head for i in xrange(k): fast = fast.next while fast.next: fast = fast.next slow = slow.next return slow setattr(LinkedList, 'kth_to_last', kth_to_last) val_list = [1, 2, 3, 4, 5] linked_list = LinkedList.from_val_list(val_list) print linked_list k = 2 print 'the {k}th to last is {node}'.format(k=k, node=linked_list.kth_to_last(k))
""" if linked_list.is_empty(): return False fast = linked_list.head.next slow = linked_list.head.next # 快慢指针查找中位数 while fast is not None and fast.next is not None: fast = fast.next.next slow = slow.next if __name__ == '__main__': # 创建一个链表对象 linked_list = LinkedList() print('链表是否为空:%d' % linked_list.is_empty()) linked_list.append('l') linked_list.append('e') linked_list.append('v') linked_list.append('e') linked_list.append('l') print('遍历单链表:') linked_list.traverse()
from single_linked_list import LinkedList, Node def getNth(head, k): # Code here idx = 0 temp = head while idx != k-1: temp = temp.next idx += 1 return temp.data if __name__ == "__main__": T = int(input()) while T > 0: llist = LinkedList() n, k = list(map(int, input().split())) nodes = list(map(int, input().split())) for data in reversed(nodes): llist.push(data) m = getNth(llist.head, k) print(m) T -= 1
__author__ = '__naresh__' ## WAP to print list from the END """ ------------ Algo ------------ Simple Just use Recursion. Once End reach start printing data """ from single_linked_list import LinkedList def print_list_from_end(head): if head is None: return print_list_from_end(head.get_next()) print head.get_data() if __name__ == "__main__": l1 = LinkedList() l1.create_list([40, 35, 30, 25, 20, 15, 10, 5, 1, 2, 75, 85]) print_list_from_end(l1.head)
class TestLinkedList(unittest.TestCase): def setUp(self): self.list = LinkedList() self.list_test = LinkedList() def test_remove(self): self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(2)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(2)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(10)) self.list.add_in_tail(Node(3)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(4)) self.list.add_in_tail(Node(1)) self.list_test.add_in_tail(Node(2)) self.list_test.add_in_tail(Node(1)) self.list_test.add_in_tail(Node(2)) self.list_test.add_in_tail(Node(1)) self.list_test.add_in_tail(Node(1)) self.list_test.add_in_tail(Node(1)) self.list.delete(1) self.list.delete(10) self.list.delete(3) self.list.delete(4) self.assertEqual(self.list.len(), self.list_test.len()) node = self.list.head node_test = self.list_test.head while node is not None and node_test is not None: self.assertEqual(node.value, node.value) node = node.next node_test = node_test.next def test_mass_remove(self): self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(2)) self.list.add_in_tail(Node(2)) self.list.add_in_tail(Node(128)) self.list.add_in_tail(Node(128)) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(9)) self.list_test.add_in_tail(Node(2)) self.list_test.add_in_tail(Node(2)) self.list_test.add_in_tail(Node(128)) self.list_test.add_in_tail(Node(128)) self.list.delete(1, all=True) self.list.delete(9, all=True) self.assertEqual(self.list.len(), self.list_test.len()) node = self.list.head node_test = self.list_test.head while node is not None and node_test is not None: self.assertEqual(node.value, node_test.value) node = node.next node_test = node_test.next def test_clear(self): self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(2)) self.list.add_in_tail(Node(2)) self.list.add_in_tail(Node(128)) self.list.add_in_tail(Node(128)) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(9)) self.list.clean() self.assertEqual(self.list.len(), 0) self.assertIsNone(self.list.head, 'Проверяем, что голова пустая') self.assertIsNone(self.list.tail, 'Проверяем, что хвост пуст') def test_search(self): self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(9)) self.assertEqual(self.list.find(9), self.list.head) self.assertEqual(self.list.find(1), self.list.head.next.next) self.assertIsNone(self.list.find(120)) def test_mass_search(self): self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(2)) self.list.add_in_tail(Node(2)) self.list.add_in_tail(Node(128)) self.list.add_in_tail(Node(128)) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(9)) self.assertEqual(len(self.list.find_all(9)), 4) self.assertEqual(len(self.list.find_all(1)), 5) self.assertEqual(len(self.list.find_all(128)), 2) def test_len(self): self.list.add_in_tail(Node(1)) self.assertEqual(self.list.len(), 1) self.list.add_in_tail(Node(1)) self.assertEqual(self.list.len(), 2) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(2)) self.list.add_in_tail(Node(2)) self.assertEqual(self.list.len(), 5) self.list.add_in_tail(Node(128)) self.list.add_in_tail(Node(128)) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(1)) self.assertEqual(self.list.len(), 10) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(1)) self.assertEqual(self.list.len(), 12) self.list.add_in_tail(Node(9)) self.assertEqual(self.list.len(), 13) def test_insert(self): self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(2)) self.list.add_in_tail(Node(2)) self.list.add_in_tail(Node(128)) self.list.add_in_tail(Node(128)) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(9)) self.list.add_in_tail(Node(1)) self.list.add_in_tail(Node(9)) self.list_test.add_in_tail(Node(-9)) self.list_test.add_in_tail(Node(-10)) self.list_test.add_in_tail(Node(-11)) self.list_test.add_in_tail(Node(-2)) self.list_test.add_in_tail(Node(1)) self.list_test.add_in_tail(Node(1)) self.list_test.add_in_tail(Node(1)) self.list_test.add_in_tail(Node(2)) self.list_test.add_in_tail(Node(-1)) self.list_test.add_in_tail(Node(-3)) self.list_test.add_in_tail(Node(2)) self.list_test.add_in_tail(Node(128)) self.list_test.add_in_tail(Node(128)) self.list_test.add_in_tail(Node(9)) self.list_test.add_in_tail(Node(9)) self.list_test.add_in_tail(Node(1)) self.list_test.add_in_tail(Node(9)) self.list_test.add_in_tail(Node(1)) self.list_test.add_in_tail(Node(9)) self.list_test.add_in_tail(Node(-111)) self.list.insert(None, Node(-11)) self.list.insert(None, Node(-10)) self.list.insert(None, Node(-9)) self.list.insert(self.list.head.next.next.next.next.next.next, Node(-1)) self.list.insert(self.list.head.next.next, Node(-2)) self.list.insert( self.list.head.next.next.next.next.next.next.next.next, Node(-3)) self.list.insert(self.list.tail, Node(-111)) self.assertEqual(self.list.len(), self.list_test.len()) node = self.list.head node_test = self.list_test.head while node is not None and node_test is not None: self.assertEqual(node.value, node_test.value) node = node.next node_test = node_test.next self.list.clean() self.list_test.clean() node = Node(2) self.list.insert(None, node) self.assertEqual(self.list.head, node) self.assertEqual(self.list.tail, node) self.list_test.add_in_tail(node) self.assertEqual(self.list_test.head, node) self.assertEqual(self.list_test.tail, node) def test_merge(self): s_list_one = LinkedList() s_list_one.add_in_tail(Node(1)) s_list_one.add_in_tail(Node(2)) s_list_one.add_in_tail(Node(3)) s_list_one.add_in_tail(Node(4)) s_list_one.add_in_tail(Node(5)) s_list_one.add_in_tail(Node(6)) s_list_one.add_in_tail(Node(7)) s_list_one.add_in_tail(Node(8)) s_list_one.add_in_tail(Node(9)) s_list_one.add_in_tail(Node(10)) s_list_one.add_in_tail(Node(11)) s_list_one.add_in_tail(Node(12)) s_list_one.add_in_tail(Node(13)) s_list_two = LinkedList() s_list_two.add_in_tail(Node(13)) s_list_two.add_in_tail(Node(12)) s_list_two.add_in_tail(Node(11)) s_list_two.add_in_tail(Node(10)) s_list_two.add_in_tail(Node(9)) s_list_two.add_in_tail(Node(8)) s_list_two.add_in_tail(Node(7)) s_list_two.add_in_tail(Node(6)) s_list_two.add_in_tail(Node(5)) s_list_two.add_in_tail(Node(4)) s_list_two.add_in_tail(Node(3)) s_list_two.add_in_tail(Node(2)) s_list_two.add_in_tail(Node(1)) s_list_merged = merge_list(s_list_two, s_list_one) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.list_test.add_in_tail(Node(14)) self.assertEqual(s_list_merged.len(), self.list_test.len()) node = s_list_merged.head node_test = self.list_test.head while node is not None and node_test is not None: self.assertEqual(node.value, node_test.value) node = node.next node_test = node_test.next
from single_linked_list import Node, LinkedList def is_palindrome(self): fast = self.head slow = self.head stack = [] while fast and fast.next: fast = fast.next.next slow = slow.next stack.append(slow.val) if not fast: stack.pop() slow = slow.next while slow and stack.pop() == slow.val: slow = slow.next return (True if not slow else False) setattr(LinkedList, 'is_palindrome', is_palindrome) val_list_1 = [1, 2, 3, 4, 5] linked_list_1 = LinkedList.from_val_list(val_list_1) print linked_list_1.is_palindrome() val_list_2 = [1, 2, 3, 2, 1] linked_list_2 = LinkedList.from_val_list(val_list_2) print linked_list_2.is_palindrome()
def setUp(self): self.list = LinkedList() self.list_test = LinkedList()
n1 = l1.head.next head = Node() current = head carry = 0 while n0 or n1 or carry: addition = carry if n0: addition += n0.val n0 = n0.next if n1: addition += n1.val n1 = n1.next current.next = Node(val=(addition % 10)) current = current.next carry = addition / 10 return cls(head.next, True) setattr(LinkedList, "from_addition", from_addition) val_list_1 = [3, 7, 5] linked_list_1 = LinkedList.from_val_list(val_list_1) val_list_2 = [9, 7, 3, 7, 2] linked_list_2 = LinkedList.from_val_list(val_list_2) linked_list_3 = LinkedList.from_addition(linked_list_1, linked_list_2) print linked_list_1 print linked_list_2 print linked_list_3
def from_addition(cls, l0, l1): n0 = l0.head.next n1 = l1.head.next head = Node() current = head carry = 0 while n0 or n1 or carry: addition = carry if n0: addition += n0.val n0 = n0.next if n1: addition += n1.val n1 = n1.next current.next = Node(val=(addition % 10)) current = current.next carry = addition / 10 return cls(head.next, True) setattr(LinkedList, 'from_addition', from_addition) val_list_1 = [3, 7, 5] linked_list_1 = LinkedList.from_val_list(val_list_1) val_list_2 = [9, 7, 3, 7, 2] linked_list_2 = LinkedList.from_val_list(val_list_2) linked_list_3 = LinkedList.from_addition(linked_list_1, linked_list_2) print linked_list_1 print linked_list_2 print linked_list_3
main_node = Node(0) node = main_node while l1 is not None and l2 is not None: if l2.get_data() <= l1.get_data(): node.set_next(Node(l1.get_data())) node = node.get_next() l1 = l1.get_next() elif l1.get_data() <= l2.get_data(): node.set_next(Node(l2.get_data())) node = node.get_next() l2 = l2.get_next() if l1 is None: node.set_next(l2) else: node.set_next(l1) return main_node.get_next() if __name__ == '__main__': l1 = LinkedList() l2 = LinkedList() l1.create_list([40, 30, 15, 5]) l2.create_list([45, 40, 10]) out = merge(l1.head, l2.head) while out is not None: print(out.get_data(), end=' ') out = out.get_next()
elif flag is True: new_node.set_next(Node(first.get_data())) new_node = new_node.get_next() first = first.get_next() flag = False elif flag is False: new_node.set_next(Node(secound.get_data())) new_node = new_node.get_next() secound = secound.get_next() flag = True if secound is not None: new_node.set_next(secound) if first is not None: new_node.set_next(first) return new_list.head if __name__ == '__main__': l1 = LinkedList() l1.create_list([40, 35, 30, 25, 20, 15, 10]) out = rearrange(l1.head) while out is not None: print(out.get_data(), end=' ') out = out.get_next()
from single_linked_list import Node, LinkedList def loop_head(self): fast = self.head slow = self.head while fast and fast.next: fast = fast.next.next slow = slow.next if fast == slow: break if not fast or not fast.next: return None p0 = self.head p1 = fast while p0 != p1: p0 = p0.next p1 = p1.next return p0 setattr(LinkedList, 'loop_head', loop_head) val_list = [1, 2, 3, 4, 5] linked_list = LinkedList.from_val_list(val_list) linked_list.last().next = linked_list.head.next.next.next print linked_list.loop_head().val
def __init__(self): self.size = 0 self.storage = LinkedList()
current = next_node return prev def reverse_block(head, k): start = end = pointer = head temp = 0 while end is not None: if temp == k: if start == head: head = reverse_list(start, end) pointer = start else: pointer.set_next(reverse_list(start, end)) pointer = start start = end temp = 0 temp += 1 end = end.get_next() return head if __name__ == "__main__": l1 = LinkedList() l1.create_list([40, 35, 30, 25, 20, 15, 10, 5, 1, 2, 75, 85]) l1.head = reverse_block(l1.head, 2) l1.print_data(l1.head)