示例#1
0
def add_depend_reverse(head1, head2):
    """
    利用链表翻转实现链表节点值相加
    :type head1:Node
    :type head2:Node
    :param head1:
    :param head2:
    :return:
    """
    head1_reverse = head1.reverse()
    head2_reverse = head2.reverse()
    carry = 0
    result = None
    while head1_reverse or head2_reverse:
        h1 = head1_reverse.value if head1_reverse else 0
        h2 = head2_reverse.value if head2_reverse else 0
        sun = carry + h1 + h2
        carry = math.floor(sun / 10)
        node = result
        result = Node(sun % 10)
        result.next = node
        head1_reverse = head1_reverse.next if head1_reverse else None
        head2_reverse = head2_reverse.next if head2_reverse else None
    # 最后可能有进位
    if carry:
        node = result
        result = Node(1)
        result.next = node
    return result
示例#2
0
 def test_property_setter_next(self):
     next_node = Node(2)
     node = Node(1)
     node.next = next_node
     self.assertEqual(id(node.next), id(next_node))
     with self.assertRaises(TypeError):
         node.next = 1
 def test_for_multiple_nodes(self):
     node2 = Node(2)
     node1 = Node(1, node2)
     self.assertIsNone(node2.next())
     node1.append(3)
     self.assertIsNotNone(node2.next(), None)
     self.assertEqual(node2.next().value(), 3)
示例#4
0
def add_depend_list(head1, head2):
    """
    利用列表(栈)实现链表节点值相加
    :type head1:Node
    :type head2:Node
    :param head1:
    :param head2:
    :return:
    """
    head1_list = []
    head2_list = []
    while head1:
        head1_list.append(head1.value)
        head1 = head1.next
    while head2:
        head2_list.append(head2.value)
        head2 = head2.next
    carry = 0
    result = None
    while head1_list or head2_list:
        h1 = head1_list.pop() if head1_list else 0
        h2 = head2_list.pop() if head2_list else 0
        sun = h1 + h2 + carry
        node = result
        result = Node(sun % 10)
        result.next = node
        carry = math.floor(sun / 10)
    # 最后可能有进位
    if carry:
        node = result
        result = Node(1)
        result.next = node
    return result
示例#5
0
    def test_add_last_in_list(self):
        head = Node(123)
        to_be_last_node = Node(555)

        head.next = to_be_last_node
        to_be_last_node.next = Node(7656)

        self.linked_list.head = head
        self.helper.helper_add_last_in_list(self.linked_list, to_be_last_node)
示例#6
0
    def test_delete_node_after_head(self):
        head = Node(6)
        after_node = Node(100)
        node_to_delete = Node(8528)

        head.next = node_to_delete
        node_to_delete.next = after_node

        self.helper.helper_delete_node_after_head(self.linked_list, head, node_to_delete)
示例#7
0
 def test_linking_nodes(self):
     node1 = Node('A')
     node2 = Node('B')
     node3 = Node('C')
     # Link nodes together
     node1.next = node2
     node2.next = node3
     # Node links should be transitive
     assert node1.next is node2  # One link
     assert node1.next.next is node3  # Two links
示例#8
0
def ll_1():
    el1 = Node(3)
    el2 = Node(4)
    el3 = Node(5)
    el4 = Node(8)

    el1.next = el2
    el2.next = el3
    el3.next = el4
    el4.next = None
    return LinkedList(el1)
示例#9
0
 def insert_before(self, index, value):
     newnode = Node(value)
     if index == 0:
         newnode.next = self.head_node
         if self.head_node == None:  # insert_before(0,*) should still work on an empty list
             self.tail_node = newnode
         self.head_node = newnode
     else:
         node = self.get_node_by_index(index - 1)
         newnode.next = node.next
         node.next = newnode
     self.list_length += 1
示例#10
0
def ll_cycle():
    el1 = Node(2)
    el2 = Node(4)
    el3 = Node(8)
    el4 = Node(11)

    el1.next = el2
    el2.next = el3
    el3.next = el4
    el4.next = el2

    return LinkedList(el1)
示例#11
0
 def insert_before(self, index, value):
     newnode = Node(value)
     if index == 0:
         newnode.next = self.head_node
         if self.head_node == None:  # insert_before(0,*) should still work on an empty list
             self.tail_node = newnode
         self.head_node = newnode
     else:
         node = self.get_node_by_index(index - 1)
         newnode.next = node.next
         node.next = newnode
     self.list_length += 1
示例#12
0
    def test_delete_node_after_head(self):
        head = Node(6)
        after_node = Node(100)
        node_to_delete = Node(8528)

        head.next = node_to_delete
        node_to_delete.prev = head

        node_to_delete.next = after_node
        after_node.prev = node_to_delete

        self.helper.helper_delete_node_after_head(self.linked_list, head, node_to_delete)

        self.assertEqual(after_node.prev, head)
 def testNext(self):
     node = Node(data="data",next=None)
     first_node = Node(data="first",next=node)
     self.assertEqual(first_node.next,node)
     third = Node(data="third",next=None)
     node.next = third
     self.assertEqual(node.next,third)
示例#14
0
    def insert(self, item_new, pos):
        """given an item and a position, this method insert an item at the position required"""

        actual_position = 0
        previous_position = None
        current = self.head
        new_node = Node(None, item_new)

        while actual_position != pos and current is not None:
            previous_position = current
            current = current.next
            actual_position += 1

        if actual_position != pos:
            raise ValueError("Invalid Position %d" % pos)

        previous_position.next = new_node
        new_node.next = current
        new_node.previous = previous_position

        if current is None:
            self.tail = new_node
        else:
            current.previous = new_node

        return self
示例#15
0
def add_numbers(node_1, node_2):
    """Recursive math is delightful."""
    # First, get the next nodes for node_1 and node_2
    if node_1 is not None:
        next_1 = node_1.next
        next_2 = node_2.next

        # Computer the value for the next step to build up
        result_node, carryover = add_numbers(next_1, next_2)

        # Sum the two values and the carryover
        sum_value = node_1.data + node_2.data + carryover
        # Take the modulo 10 number and assign it to digit
        digit = sum_value % 10
        # Flat divide by ten and assign that to carryover
        carryover = sum_value // 10

        # Create our new node with the digit
        new_node = Node(digit)
        # Assign the result of the next step as the next node
        new_node.next = result_node

        return (new_node, carryover)

    # End of the list, recursion stops
    else:
        return (None, 0)
示例#16
0
    def test_find_loop_start(self):
        print('Test: Empty list')
        linked_list = MyLinkedList()
        assert_equal(linked_list.find_loop_start(), None)

        print('Test: Not a circular linked list: One element')
        head = Node(1)
        linked_list = MyLinkedList(head)
        assert_equal(linked_list.find_loop_start(), None)

        print('Test: Not a circular linked list: Two elements')
        linked_list.append(2)
        assert_equal(linked_list.find_loop_start(), None)

        print('Test: Not a circular linked list: Three or more elements')
        linked_list.append(3)
        assert_equal(linked_list.find_loop_start(), None)

        print('Test: General case: Circular linked list')
        node10 = Node(10)
        node9 = Node(9, node10)
        node8 = Node(8, node9)
        node7 = Node(7, node8)
        node6 = Node(6, node7)
        node5 = Node(5, node6)
        node4 = Node(4, node5)
        node3 = Node(3, node4)
        node2 = Node(2, node3)
        node1 = Node(1, node2)
        node0 = Node(0, node1)
        node10.next = node3
        linked_list = MyLinkedList(node0)
        assert_equal(linked_list.find_loop_start(), node3)

        print('Success: test_find_loop_start')
def test_node_set_next():
    first_node = Node(4)
    second_node = Node(5)

    first_node.next = second_node

    assert first_node.next.data == 5
示例#18
0
 def testNext(self):
     node = Node(data="data", next=None)
     first_node = Node(data="first", next=node)
     self.assertEqual(first_node.next, node)
     third = Node(data="third", next=None)
     node.next = third
     self.assertEqual(node.next, third)
示例#19
0
def add_forward(node1, node2):
    if not node1 and not node2:
        return (None, 0)
    next, carry = add_forward(node1.next, node2.next)
    q, r = divmod(node1.value + node2.value + carry, 10)
    node = Node(r)
    node.next = next
    return (node, q)
示例#20
0
 def insert_after(self, index, value):
     node = self.get_node_by_index(index)
     newnode = Node(value)
     newnode.next = node.next
     node.next = newnode
     if newnode.next == None:
         self.tail_node = newnode
     self.list_length += 1
示例#21
0
def add_forward(node1, node2):
    if not node1 and not node2:
        return (None, 0)
    next, carry = add_forward(node1.next, node2.next)
    q, r = divmod(node1.value + node2.value + carry, 10)
    node = Node(r)
    node.next = next
    return (node, q)
def reverse_and_clone(node):
    head = None
    while node != None:
        new_node = Node(node.data)
        new_node.next = head
        head = new_node
        node = node.next
    return head
示例#23
0
 def insert_after(self, index, value):
     node = self.get_node_by_index(index)
     newnode = Node(value)
     newnode.next = node.next
     node.next = newnode
     if newnode.next == None:
         self.tail_node = newnode
     self.list_length += 1
示例#24
0
 def push(self, data):
     node = Node(data)
     if self.top is None:
         self.top = node
         self.size = self.size + 1
     else:
         node.next = self.top
         self.top = node
         self.size = self.size + 1
    def push(self, data):
        node = Node(data)
        if not self._head:
            self._head = node
        else:
            node.next = self._head
            self._head = node

        self._size += 1
示例#26
0
    def linked_list_intro_play(self):
        """ Linked List | Set 1 (Introduction)"""
        # Steps are:
        # 1. Create an empty list
        # 2. Create nodes
        # 3. Link the nodes.

        # Start with the empty list
        llist = LinkedList()

        llist.head = Node(1)
        second = Node(2)
        third = Node(3)

        '''
        Three nodes have been created.
        We have references to these three blocks as first,
        second and third

        llist.head        second              third
             |                |                  |
             |                |                  |
        +----+------+     +----+------+     +----+------+
        | 1  | None |     | 2  | None |     |  3 | None |
        +----+------+     +----+------+     +----+------+
        '''

        llist.head.next = second  # Link first node with second

        '''
        Now next of first Node refers to second.  So they
        both are linked.

        llist.head        second              third
             |                |                  |
             |                |                  |
        +----+------+     +----+------+     +----+------+
        | 1  |  o-------->| 2  | null |     |  3 | null |
        +----+------+     +----+------+     +----+------+
        '''

        second.next = third  # Link second node with the third node

        '''
        Now next of second Node refers to third.  So all three
        nodes are linked.

        llist.head        second              third
             |                |                  |
             |                |                  |
        +----+------+     +----+------+     +----+------+
        | 1  |  o-------->| 2  |  o-------->|  3 | null |
        +----+------+     +----+------+     +----+------+
        '''

        # traversing the entire linked list and printing
        llist.print_list()
示例#27
0
def delete_node(node: Node) -> None:
    '''
    Overwrite each value of a linked list, starting from the node we are given to delete.
    '''
    while node.next != None:
        node.val = node.next.val
        if node.next.next == None:
            node.next = None
        else:
            node = node.next
示例#28
0
def reverseList(head: Node) -> Node:
    if head == None or head.next == None:
        return head

    # reversed_list = 뒤집어진 리스트의 Head node
    reversed_list = reverseList(head.next)
    head.next.next = head
    head.next = None

    return reversed_list
def insert_in_sorted_list(node, item):
    previous = None
    current = node.head
    stop = False

    while current != None and not stop:
        if current.data > item:
            stop = True
        else:
            previous = current
            current = current.next

    temp = Node(item)
    if previous == None:
        temp.next = node.head
        node.head = temp
    else:
        temp.next = current
        previous.next = temp
示例#30
0
def insert_at_middle(head, data, position):
    temp = head
    pos = 0
    while temp.next:
        old_node = temp
        new_node = temp.next
        temp = temp.next
        pos += 1
        if position == pos:
            node_to_insert = Node(data)
            old_node.next = node_to_insert
            node_to_insert.next = new_node
示例#31
0
def test_llist_init_str_repr(llist):
    first_node = Node(1)
    second_node = Node('a')
    assert str(llist) == 'None'
    assert repr(llist) == 'LinkedList()'
    llist.head = first_node
    first_node.next = second_node
    assert str(llist) == '1 -> a -> None'
    assert repr(llist) == 'LinkedList(1, a)'
    llist = LinkedList([2, 'b'])
    assert str(llist) == '2 -> b -> None'
    assert repr(llist) == 'LinkedList(2, b)'
示例#32
0
def reverse(linked_list):
    # HINT: Create New Nodes
    pre_node = None
    reversed_linked_list = LinkedList()

    for value in linked_list:
        new_node = Node(value)
        new_node.next = pre_node
        pre_node = new_node

    reversed_linked_list.head = pre_node
    return reversed_linked_list
示例#33
0
def add_reversed(node1, node2, carry):
    if not node1 and not node2 and carry == 0:
        return
    sum = carry
    if node1:
        sum += node1.value
    if node2:
        sum += node2.value
    q, r = divmod(sum, 10)
    node = Node(r)
    node.next = add_reversed(node1.next if node1 else None,
                             node2.next if node2 else None, q)
    return node
def delete_n_th_reversed(head: Node, n: int):
    sentinel = Node(0)
    sentinel.next = head
    p = sentinel
    q = sentinel
    for _ in range(n + 1):
        p = p.next
    while p:
        p = p.next
        q = q.next
    q.next = q.next.next

    return sentinel.next
示例#35
0
def reverse_2(head: Node):
    """
    递归
    :param head:
    :return:
    """
    # 找到最后一个节点
    if head.next is None or head is None:
        return head
    new_head = reverse_2(head.next)
    head.next.next = head
    head.next = None
    return new_head
示例#36
0
def add_reversed(node1, node2, carry):
    if not node1 and not node2 and carry == 0:
        return
    sum = carry
    if node1:
        sum += node1.value
    if node2:
        sum += node2.value
    q, r = divmod(sum, 10)
    node = Node(r)
    node.next = add_reversed(node1.next if node1 else None,
                             node2.next if node2 else None,
                             q)
    return node
示例#37
0
def solution2(head1, head2):
    # If linked lists have different lengths, pad with 0s
    len1, len2 = length(head1), length(head2)
    if len1 < len2:
        head1 = pad_with_zeros(head1, len2-len1)
    elif len1 > len2:
        head2 = pad_with_zeros(head2, len1-len2)

    # Now that the linked lists are of equal size, add them
    head, carry = add_forward(head1, head2)
    if carry != 0:
        node = Node(carry)
        node.next, head = head, node  # insert at front

    return head
示例#38
0
def pad_with_zeros(head, count):
    for i in range(count):
        node = Node(0)
        node.next, head = head, node  # insert at front
    return head
 def test_node_str_representation_with_next(self):
     n = Node(9)
     n.next = Node('X')
     self.assertEqual(str(n), "Node(9) > Node(X)")
示例#40
0
    if length == 1:
        return node.next
    if length == 2:
        if node.value == node.next.value:
            return node.next.next
        else:
            return -1
    last_node = visit(node.next, length-2)
    if last_node != -1:
        if node.value == last_node.value:
            return last_node.next
    return -1


def palindrome(head):
    length = 0
    node = head
    while node:
        length += 1
        node = node.next
    print visit(head, length)


head = Node('r')
head.next = Node('a')
head.next.next = Node('d')
head.next.next.next = Node('a')
head.next.next.next.next = Node('r')

palindrome(head)  # None if palindrome, -1 otherwise
示例#41
0
	prev= None
	current = n1
	while current!=None:
		right = current.next
		current.next = prev
		prev = current
		current = right
	return prev
	
def printList(n):
	while n!= None:
		print n.value
		n = n.next

n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
n4 = Node(4)
n5 = Node(5)

n1.next = n2
n2.next = n3
n3.next = n4
n4.next = n5
n5.next = None

printList(n1)
nret = reverse(n1)
print nret.value
printList(nret)
from linked_list import Node


acyclic = Node(1, Node(2, Node(3)))

cyclic = Node(1)
cyclic.next = Node(2, Node(3, Node(4, cyclic)))

def node_generator(node):
    while node:
        yield node
        node=node.next
    

def is_cyclic(node):
    faster_generator = node_generator(node)
    slower_generator = node_generator(node)
    try:
        next(faster_generator)
        for item in slower_generator: #item = 3
            item0 = next(faster_generator) # item0 = 2
            item1 = next(faster_generator) # item1 = 3
            if id(item) == id(item0) or id(item) == id(item1):
                return True     
    except StopIteration:
        pass
    return False
   
    
print(is_cyclic(acyclic))
print(is_cyclic(cyclic))