def basic_tests(): sll = SLL() try: sll.pop_back() except UnderFlowError as e: print "Tried popping from an empty SLL. Error:", e sll.push_back(1) assert(sll.size == 1) assert(sll.head.value == 1) assert(sll.tail.value == 1) sll.push_front(0) assert(sll.size == 2) assert(sll.head.value == 0) assert(sll.tail.value == 1) sll.push_back(2) assert(sll.size == 3) assert(sll.head.value == 0) assert(sll.tail.value == 2) sll.push_back(3) assert(sll.size == 4) assert(sll.head.value == 0) assert(sll.tail.value == 3) sll.push_back(4) assert(sll.size == 5) assert(sll.head.value == 0) assert(sll.tail.value == 4) assert(4 == sll.pop_back()) assert(sll.size == 4) assert(sll.head.value == 0) assert(sll.tail.value == 3) assert(0 == sll.pop_front()) assert(sll.size == 3) assert(sll.head.value == 1) assert(sll.tail.value == 3) assert(1 == sll.pop_front()) assert(sll.size == 2) assert(sll.head.value == 2) assert(sll.tail.value == 3) assert(3 == sll.pop_back()) assert(sll.size == 1) assert(sll.head.value == 2) assert(sll.tail.value == 2) assert(2 == sll.pop_back()) assert(sll.size == 0) assert(sll.head == None) assert(sll.tail == None) # fromList and toList assert(SLL.toList(SLL.fromList(range(9, 0, -2))) == range(9, 0, -2))
def test_iterator(): s = SLL() for i in range(10): s.push_back(i+1) # Using for/in -> implicit next() it = iter(s) i = 1 for x in it: assert(x == i) i = i + 1 # Using the next/iter methods it = iter(s) i = 1 while it: try: assert(it.next() == i) except StopIteration: break i = i + 1 # Use an external next() on the iterator as opposed to it.next() it = iter(s) i = 1 while it: try: assert(next(it) == i) except StopIteration: break i = i + 1
def test_iterator(): s = SLL() for i in range(10): s.push_back(i + 1) # Using for/in -> implicit next() it = iter(s) i = 1 for x in it: assert (x == i) i = i + 1 # Using the next/iter methods it = iter(s) i = 1 while it: try: assert (it.next() == i) except StopIteration: break i = i + 1 # Use an external next() on the iterator as opposed to it.next() it = iter(s) i = 1 while it: try: assert (next(it) == i) except StopIteration: break i = i + 1
def test_len(): sll = SLL() assert(not sll == True) if not sll: assert(len(sll) == 0) sll.push_back(1) if sll: assert(len(sll) == 1)
def test_len(): sll = SLL() assert (not sll == True) if not sll: assert (len(sll) == 0) sll.push_back(1) if sll: assert (len(sll) == 1)
def top_view_LR(self, aggregate_fn=_default_printfn, **kwargs): if not self.root: return # Queue to help with level-order traversal q = Queue() # Store L/R width of a node and its value if it is visible in the top-view, in a sorted list # ordered by the width # at the end of the level-order traversal the list would contain # [(-max_left_width, node value), ...., (0, root.value), ... (max_right_width, node value)] slist = SLL() # pairs a(w1, node_val1) vs b(w2, node_val2) are valued against each other # depending on w1 vs w2 (where w1 and w2 are widths, so slist is kept sorted by the nodes' L/R widths) pair_comparator = lambda (w1, node_val1), (w2, node_val2): cmp(w1, w2) min_width = 0 max_width = 0 q.enqueue((0, self.root)) # Top-view begins with the root node slist.place((0, self.root.value)) while q.length() != 0: width, node = q.dequeue() if width < min_width: min_width = width slist.place((width, node.value)) elif width > max_width: max_width = width slist.place((width, node.value)) # NOTE: width 0, is root, would already be filled in at root, # and in a top-view is not going to replaced q.enqueue((width - 1, node.left)) if node.left else None q.enqueue((width + 1, node.right)) if node.right else None # At the end of the level-order traversal, # slist is ordered by width, so # (-max_left_width, ..., 0, ..., max_right_width) # Just retrieve the SLL L-R for the top view (L-R) while slist.size != 0: width, item = slist.pop_front() aggregate_fn(kwargs, item)
def test_indexing(): sll = SLL.fromList(range(1,11)) for i in range(10): assert(sll[i] == i+1) try: assert(sll[10] == None) except IndexError: print "sll[10] index error on sll, SLL has only %d elements" %(len(sll)) for i in range(1,11): assert(sll[-i] == 10-i+1) try: assert(sll[-11] == None) except IndexError: print "sll[-11] index error on sll, SLL has only %d elements" %(len(sll))
def test_indexing(): sll = SLL.fromList(range(1, 11)) for i in range(10): assert (sll[i] == i + 1) try: assert (sll[10] == None) except IndexError: print "sll[10] index error on sll, SLL has only %d elements" % ( len(sll)) for i in range(1, 11): assert (sll[-i] == 10 - i + 1) try: assert (sll[-11] == None) except IndexError: print "sll[-11] index error on sll, SLL has only %d elements" % ( len(sll))
def test_find(): s = SLL() for x in [6, 4, 2]: s.place(x) for x in [5, 1]: s.place(x) s.place(0) s.place(7) assert s.find(0) == 0 assert s.find(7) == 7 assert s.find(1) == 1 assert s.find(2) == 2 assert s.find(4) == 4 assert s.find(3) == None assert s.find(10) == None assert s.find(-1) == None # Test custom comparator s2 = SLL.fromList([(2, 1), (1, 'a'), (2, 3), (0, 'c'), (4, 1), (3, 0)]) assert s2.find((2, 1)) == (2, 1) assert s2.find((4, 3), comparatorfn=lambda (a, b), (c, d): cmp(b, d)) == (2, 3) # compare only the first item in the pair between two nodes assert s2.find((2, 100), comparatorfn=lambda (a, b), (c, d): cmp(a, c)) == (2, 1) assert s2.find((0, 100), comparatorfn=lambda (a, b), (c, d): cmp(a, c)) == (0, 'c')
def test_find(): s = SLL() for x in [6,4,2]: s.place(x) for x in [5, 1]: s.place(x) s.place(0) s.place(7) assert s.find(0) == 0 assert s.find(7) == 7 assert s.find(1) == 1 assert s.find(2) == 2 assert s.find(4) == 4 assert s.find(3) == None assert s.find(10) == None assert s.find(-1) == None # Test custom comparator s2 = SLL.fromList([(2,1), (1, 'a'), (2, 3), (0, 'c'), (4,1), (3,0)]) assert s2.find((2,1)) == (2,1) assert s2.find((4,3), comparatorfn = lambda (a,b),(c,d): cmp(b,d)) == (2,3) # compare only the first item in the pair between two nodes assert s2.find((2,100), comparatorfn = lambda (a,b),(c,d): cmp(a,c)) == (2,1) assert s2.find((0,100), comparatorfn = lambda (a,b),(c,d): cmp(a,c)) == (0, 'c')
def test_findMatchingNode(): s = SLL() for x in [6,4,2]: s.place(x) for x in [5, 1]: s.place(x) s.place(0) s.place(7) assert s.findMatchingNode(0) == s.head assert s.findMatchingNode(7) == s.tail assert s.findMatchingNode(1) == s.head.next assert s.findMatchingNode(2) == s.head.next.next assert s.findMatchingNode(4) == s.head.next.next.next assert s.findMatchingNode(3) == None assert s.findMatchingNode(10) == None assert s.findMatchingNode(-1) == None # Test custom comparator s2 = SLL.fromList([(2,1), (1, 'a'), (2, 3), (0, 'c'), (4,1), (3,0)]) assert s2.findMatchingNode((2,1)) == s2.head assert s2.findMatchingNode((2,3), comparatorfn = lambda (a,b),(c,d): cmp(b,d)) == s2.head.next.next # compare only the first item in the pair between two nodes assert s2.findMatchingNode((2,100), comparatorfn = lambda (a,b),(c,d): cmp(a,c)) == s2.head node = s2.findMatchingNode((0,100), comparatorfn = lambda (a,b),(c,d): cmp(a,c)) # change node's value node.value = (0, 'e') assert node == s2.head.next.next.next assert node.value == (0, 'e') assert SLL.toList(s2) == [(2,1), (1, 'a'), (2, 3), (0, 'e'), (4,1), (3,0)]
# then again, next k-blocks begin at start.next (d->g), start = 'g' # then later, start becomes 'i', and next k-block begins at start.next = 'j' start = start.next tmp = reverse_k_group(start, k) # If we had k-nodes to begin with, link last block to this reversed block # if reverse_k_group() returned None, we are left with fewer than k nodes # at the end, return immediately if tmp: last.next = tmp if __name__ == '__main__': sll = SLL.fromList("abcde") assert(lookahead(sll.head, 4) == True) assert(lookahead(sll.head, 5) == True) assert(lookahead(sll.head, 6) == False) tmp = reverse_k_group(sll.head, 4) sll.head = tmp assert(SLL.toList(sll) == map (lambda x: x, "dcbae")) sll2 = SLL.fromList("abcde") tmp = reverse_k_group(sll2.head, 6) assert(tmp == None) assert(SLL.toList(sll2) == map (lambda x: x, "abcde")) sll = SLL.fromList("abcde") reverse(sll, 2) assert(SLL.toList(sll) == map (lambda x: x, "badce"))
def test_reverse(): sll = SLL() sll.push_back(1) sll.push_back(2) sll.push_back(3) sll.push_back(4) sll.reverse() it = iter(sll) i = 4 for x in it: assert(x == i) i -= 1 # sll itself returns an SLLIterator, so we needn't get an iterator to # traverse the sll i = 4 for x in sll: assert(x == i) i -= 1 s2 = SLL() s2.push_back('a') s2.reverse() assert(s2.size == 1) assert(s2.head.value == 'a') assert(s2.tail.value == 'a') s2.push_back('b') s2.reverse() assert(s2.size == 2) assert(s2.head.value == 'b') assert(s2.tail.value == 'a')
def __init__(self, vertices, directed=False): GraphBase.__init__(self, vertices, directed) self._adjlists = [SLL() for x in xrange(vertices)]
def test_place(): s = SLL() for x in [6, 4, 2]: s.place(x) for x in [5, 3, 1]: s.place(x) s.place(0) s.place(7) # wont get added s.place(0, allowduplicates=False) s.place(4, allowduplicates=False) s.place(7, allowduplicates=False) l = [] collate_fn = lambda kwargs, data: kwargs['lst'].append(data) s.traverse(collate_fn, lst=l) assert (l == range(8)) # Test custom comparator s2 = SLL() test_list = [(2, 1), (1, 'a'), (2, 3), (0, 'c'), (4, 1), (3, 0)] for x in test_list: s2.place(x, lambda (a, b), (c, d): cmp(a, c)) # Duplicates, won't get added s2.place((0, 'c'), allowduplicates=False) s2.place((2, 1), allowduplicates=False) s2.place((4, 1), allowduplicates=False) l = [] collate_fn = lambda xargs, data: xargs['lst'].append(data) s2.traverse(collate_fn, lst=l) assert (l == [(0, 'c'), (1, 'a'), (2, 1), (2, 3), (3, 0), (4, 1)]) # Test custom comparator2 s3 = SLL() test_list = [(2, 1), (1, 'a'), (2, 3), (0, 'c'), (4, 1), (3, 0)] for x in test_list: s3.place(x, lambda (a, b), (c, d): cmp(b, d)) l = [] collate_fn = lambda xargs, data: xargs['lst'].append(data) s3.traverse(collate_fn, lst=l) assert l == [(3, 0), (2, 1), (4, 1), (2, 3), (1, 'a'), (0, 'c')]
def test_place(): s = SLL() for x in [6,4,2]: s.place(x) for x in [5, 3, 1]: s.place(x) s.place(0) s.place(7) # wont get added s.place(0, allowduplicates=False) s.place(4, allowduplicates=False) s.place(7, allowduplicates=False) l = [] collate_fn = lambda kwargs, data : kwargs['lst'].append(data) s.traverse(collate_fn, lst=l) assert(l == range(8)) # Test custom comparator s2 = SLL() test_list = [(2,1), (1, 'a'), (2, 3), (0, 'c'), (4,1), (3,0)] for x in test_list: s2.place(x, lambda (a,b),(c,d): cmp(a, c)) # Duplicates, won't get added s2.place((0, 'c'), allowduplicates=False) s2.place((2, 1), allowduplicates=False) s2.place((4, 1), allowduplicates=False) l = [] collate_fn = lambda xargs, data : xargs['lst'].append(data) s2.traverse(collate_fn, lst=l) assert(l == [(0, 'c'), (1, 'a'), (2, 1), (2, 3), (3, 0), (4, 1)]) # Test custom comparator2 s3 = SLL() test_list = [(2,1), (1, 'a'), (2, 3), (0, 'c'), (4,1), (3,0)] for x in test_list: s3.place(x, lambda (a,b),(c,d): cmp(b, d)) l = [] collate_fn = lambda xargs, data : xargs['lst'].append(data) s3.traverse(collate_fn, lst=l) assert l == [(3, 0), (2, 1), (4, 1), (2, 3), (1, 'a'), (0, 'c')]
def test_findMatchingNode(): s = SLL() for x in [6, 4, 2]: s.place(x) for x in [5, 1]: s.place(x) s.place(0) s.place(7) assert s.findMatchingNode(0) == s.head assert s.findMatchingNode(7) == s.tail assert s.findMatchingNode(1) == s.head.next assert s.findMatchingNode(2) == s.head.next.next assert s.findMatchingNode(4) == s.head.next.next.next assert s.findMatchingNode(3) == None assert s.findMatchingNode(10) == None assert s.findMatchingNode(-1) == None # Test custom comparator s2 = SLL.fromList([(2, 1), (1, 'a'), (2, 3), (0, 'c'), (4, 1), (3, 0)]) assert s2.findMatchingNode((2, 1)) == s2.head assert s2.findMatchingNode((2, 3), comparatorfn=lambda (a, b), (c, d): cmp(b, d)) == s2.head.next.next # compare only the first item in the pair between two nodes assert s2.findMatchingNode((2, 100), comparatorfn=lambda (a, b), (c, d): cmp(a, c)) == s2.head node = s2.findMatchingNode((0, 100), comparatorfn=lambda (a, b), (c, d): cmp(a, c)) # change node's value node.value = (0, 'e') assert node == s2.head.next.next.next assert node.value == (0, 'e') assert s2.toList() == [(2, 1), (1, 'a'), (2, 3), (0, 'e'), (4, 1), (3, 0)]
def basic_tests(): sll = SLL() try: sll.pop_back() except UnderFlowError as e: print "Tried popping from an empty SLL. Error:", e sll.push_back(1) assert (sll.size == 1) assert (sll.head.value == 1) assert (sll.tail.value == 1) sll.push_front(0) assert (sll.size == 2) assert (sll.head.value == 0) assert (sll.tail.value == 1) sll.push_back(2) assert (sll.size == 3) assert (sll.head.value == 0) assert (sll.tail.value == 2) sll.push_back(3) assert (sll.size == 4) assert (sll.head.value == 0) assert (sll.tail.value == 3) sll.push_back(4) assert (sll.size == 5) assert (sll.head.value == 0) assert (sll.tail.value == 4) assert (4 == sll.pop_back()) assert (sll.size == 4) assert (sll.head.value == 0) assert (sll.tail.value == 3) assert (0 == sll.pop_front()) assert (sll.size == 3) assert (sll.head.value == 1) assert (sll.tail.value == 3) assert (1 == sll.pop_front()) assert (sll.size == 2) assert (sll.head.value == 2) assert (sll.tail.value == 3) assert (3 == sll.pop_back()) assert (sll.size == 1) assert (sll.head.value == 2) assert (sll.tail.value == 2) assert (2 == sll.pop_back()) assert (sll.size == 0) assert (sll.head == None) assert (sll.tail == None) # fromList and toList assert (SLL.fromList(range(9, 0, -2)).toList() == range(9, 0, -2))
def test_reverse(): sll = SLL() sll.push_back(1) sll.push_back(2) sll.push_back(3) sll.push_back(4) sll.reverse() it = iter(sll) i = 4 for x in it: assert (x == i) i -= 1 # sll itself returns an SLLIterator, so we needn't get an iterator to # traverse the sll i = 4 for x in sll: assert (x == i) i -= 1 s2 = SLL() s2.push_back('a') s2.reverse() assert (s2.size == 1) assert (s2.head.value == 'a') assert (s2.tail.value == 'a') s2.push_back('b') s2.reverse() assert (s2.size == 2) assert (s2.head.value == 'b') assert (s2.tail.value == 'a')
# Have 'trail' follow 'trav' until # trav 'falls off' end of the SLL # placing 'trav' at nth node from the end trail = sll.head while trav: trail = trail.next trav = trav.next return trail.value except: # SLL has <n items raise UnderFlowError if __name__ == "__main__": sll1 = SLL.fromList([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) assert (find_last_nth(sll1, 0) == 1) assert (find_last_nth_size_known(sll1, 0) == 1) assert (find_last_nth(sll1, 3) == 8) assert (find_last_nth_size_known(sll1, 3) == 8) assert (find_last_nth(sll1, 1) == 10) assert (find_last_nth_size_known(sll1, 1) == 10) assert (find_last_nth(sll1, 10) == 1) assert (find_last_nth_size_known(sll1, 10) == 1) try: assert (find_last_nth(sll1, 11) == None) except UnderFlowError: print "1: Underflow error as expected!" try:
curr = prev.next # All nodes until 'prev' is sorted # 'curr' < 'prev' => yank it and place it to the left if curr.value < prev.value: yank(prev, curr) place(curr) else: # 'curr' is already in the right place # advance 'prev' to next node, i,e 'curr' prev = curr if __name__ == '__main__': l = [2,5,1,4,3] s = SLL.fromList(l) Sort.insertion_sort(s) assert sorted(l) == s.toList() l = [2,4,6,1,3,5] s = SLL.fromList(l) Sort.insertion_sort(s) assert sorted(l) == s.toList() l = [1,3,5,2,4,6] s = SLL.fromList(l) Sort.insertion_sort(s) assert sorted(l) == s.toList() l = [1,2,3,4,5,6] s = SLL.fromList(l)
# Have 'trail' follow 'trav' until # trav 'falls off' end of the SLL # placing 'trav' at nth node from the end trail = sll.head while trav: trail = trail.next trav = trav.next return trail.value except: # SLL has <n items raise UnderFlowError if __name__ == "__main__": sll1 = SLL.fromList([1,2,3,4,5,6,7,8,9,10]) assert(find_last_nth(sll1, 0) == 1) assert(find_last_nth_size_known(sll1, 0) == 1) assert(find_last_nth(sll1, 3) == 8) assert(find_last_nth_size_known(sll1, 3) == 8) assert(find_last_nth(sll1, 1) == 10) assert(find_last_nth_size_known(sll1, 1) == 10) assert(find_last_nth(sll1, 10) == 1) assert(find_last_nth_size_known(sll1, 10) == 1) try: assert(find_last_nth(sll1, 11) == None) except UnderFlowError: print "1: Underflow error as expected!" try: