Algorithm: linked list reversion

link.py

#!/usr/bin/env python

class Node(object):
    def __init__(self, value, next_=None):
        self.value = value
        self.next_ = next_

    def __repr__(self):
        return "Node({0}, {1})".format(self.value, self.next_)


class LinkedList(object):
    def __init__(self, *values):
        self.head = None
        for val in reversed(values):
            self.head = Node(val, self.head)

    def as_tuple(self):
        return tuple(node.value for node in self)

    def _reverse(self, this, prev):
        next_ = this.next_
        this.next_ = prev
        if next_:
            self._reverse(next_, this)
        else:
            self.head = this

    def reverse(self):
        if self.head and self.head.next_:
            self._reverse(self.head, None)

    def __iter__(self):
        node = self.head
        while node:
            yield node
            node = node.next_

    def __repr__(self):
        return "LinkedList({0})".format(
            ", ".join(str(node.value) for node in self)
        )

    
if __name__ == "__main__":
    import unittest
    
    
    class LinkedListsTests(unittest.TestCase):
        
        def test_can_create_node(self):
            node = Node(1, None)
            self.assertEqual(node.value, 1)
            self.assertEqual(node.next_, None)

        def test_list_has_correct_head(self):
            lst = LinkedList(1, 2)
            self.assertEqual(lst.head.value, 1)

        def test_can_create_list_with_one_node(self):
            lst = LinkedList(1)
            self.assertEqual([lst.head], list(lst))

        def test_can_create_list_with_three_nodes(self):
            lst = LinkedList(1, 2, 3)
            self.assertEqual(lst.as_tuple(), (1, 2, 3))

        def test_can_create_list_with_many_nodes(self):
            lst = LinkedList(*range(20))
            self.assertEqual(lst.as_tuple(), tuple(range(20)))

        def test_can_reverse_list(self):
            lst = LinkedList(1, 2, 3, 4, 5)
            lst.reverse()
            self.assertEqual(lst.as_tuple(), (5, 4, 3, 2, 1))

    unittest.main()