search

Hướng dẫn insert node into linked list recursively python - chèn nút vào danh sách liên kết một cách đệ quy python

1 năms trước
Trả lời: 0
Lượt xem: 197

Bạn có cần phải có các lớp riêng cho Node và LinkedList không? Nếu không, bạn có thể đơn giản hóa mã như sau:

Show
class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node
    def __repr__(self):
        return f"{self.data}, {self.next}" if self.next else str(self.data)
    def insert(self, value, index=0):
        if self.next:
            if index == 0:
                self.next, self.data = Node(self.data, self.next), value
            else:
                self.next.insert(value, index - 1)
        else: # if terminal node, ignore index
            self.next = Node(value)

ll = Node(1, Node(3, Node(4)))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5

Về cơ bản, mỗi Node thể hiện một danh sách được liên kết bắt đầu từ nút đó, mà (tôi tin) phù hợp với khái niệm đệ quy.

Ở đây, insert chỉ thực hiện công việc thực sự khi index == 0, ý tưởng tương tự như trong giải pháp lặp của bạn. Mặt khác (nếu index > 0), nó sẽ ném công việc vào nút tiếp theo với một chỉ mục ít hơn (self.next.insert(value, index - 1)).

Nếu bạn phải duy trì cấu trúc ____ 2 -________ 3, bạn có thể làm như sau:

class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5

Lưu ý rằng insert có thêm một biến trạng thái 

class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
2. Mặc dù về mặt kỹ thuật đệ quy, tôi có đặt phòng về vẻ đẹp của nó.

Bước 4 Traverse Till Key được tìm thấy và điểm (PTR) để tiêu đề ..

Bước 5 Kiểm tra xem ptr-> data == key thì Goto Bước 6 khác Bước 7 ..

Bước 6 Tạo liên kết và thêm giá trị dữ liệu vào nút mới ..

  • Xem thảo luận
  • Cải thiện bài viết

    • Bước 4 Traverse Till Key được tìm thấy và điểm (PTR) để tiêu đề ..

    Bước 5 Kiểm tra xem ptr-> data == key thì Goto Bước 6 khác Bước 7 ..

    Bước 6 Tạo liên kết và thêm giá trị dữ liệu vào nút mới ..

    Xem thảo luận

    Cải thiện bài viết To create a Linked list using recursion follow these steps. Below steps insert a new node recursively at the end of linked list.  

    C++

    Lưu bài viết

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    Đọc

    Bàn luận

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node4

    Node5Node6

    Chúng tôi đã thảo luận về các phương pháp khác nhau của việc chèn danh sách liên kết. Làm thế nào để tạo ra một danh sách được liên kết?

    Chèn đệ quy ở cuối: & nbsp; để tạo một danh sách được liên kết bằng cách sử dụng đệ quy làm theo các bước này. Dưới đây các bước chèn một nút mới đệ quy ở cuối danh sách được liên kết. & Nbsp; & nbsp;

    class Node: def __init__(self, data, node=None): self.data = data self.next = node class LinkedList: def __init__(self, node=None): self.head = node def __repr__(self): values = [] curr = self.head while curr: values.append(curr.data) curr = curr.next return ', '.join(map(str, values)) def insert(self, value, index=0, node=None): node = node or self.head # if node==None, then assign self.head if node.next: if index == 0: node.next, node.data = Node(node.data, node.next), value else: self.insert(value, index=index-1, node=node.next) else: # if terminal node, ignore index node.next = Node(value) ll = LinkedList(Node(1, Node(3, Node(4)))) print(ll) # 1, 3, 4 ll.insert(2, 1) print(ll) # 1, 2, 3, 4 ll.insert(5, 4) print(ll) # 1, 2, 3, 4, 5 3class Node: def __init__(self, data, node=None): self.data = data self.next = node class LinkedList: def __init__(self, node=None): self.head = node def __repr__(self): values = [] curr = self.head while curr: values.append(curr.data) curr = curr.next return ', '.join(map(str, values)) def insert(self, value, index=0, node=None): node = node or self.head # if node==None, then assign self.head if node.next: if index == 0: node.next, node.data = Node(node.data, node.next), value else: self.insert(value, index=index-1, node=node.next) else: # if terminal node, ignore index node.next = Node(value) ll = LinkedList(Node(1, Node(3, Node(4)))) print(ll) # 1, 3, 4 ll.insert(2, 1) print(ll) # 1, 2, 3, 4 ll.insert(5, 4) print(ll) # 1, 2, 3, 4, 5 4 class Node: def __init__(self, data, node=None): self.data = data self.next = node class LinkedList: def __init__(self, node=None): self.head = node def __repr__(self): values = [] curr = self.head while curr: values.append(curr.data) curr = curr.next return ', '.join(map(str, values)) def insert(self, value, index=0, node=None): node = node or self.head # if node==None, then assign self.head if node.next: if index == 0: node.next, node.data = Node(node.data, node.next), value else: self.insert(value, index=index-1, node=node.next) else: # if terminal node, ignore index node.next = Node(value) ll = LinkedList(Node(1, Node(3, Node(4)))) print(ll) # 1, 3, 4 ll.insert(2, 1) print(ll) # 1, 2, 3, 4 ll.insert(5, 4) print(ll) # 1, 2, 3, 4, 5 5

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    9

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    Node0Node1 Node2

    Bàn luận

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node4

    Node5Node7

    Chúng tôi đã thảo luận về các phương pháp khác nhau của việc chèn danh sách liên kết. Làm thế nào để tạo ra một danh sách được liên kết?

    LinkedList0

    Python3

    Chèn đệ quy ở cuối: & nbsp; để tạo một danh sách được liên kết bằng cách sử dụng đệ quy làm theo các bước này. Dưới đây các bước chèn một nút mới đệ quy ở cuối danh sách được liên kết. & Nbsp; & nbsp;

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    3
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    4 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    5

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    9

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node4index == 06

    Node0Node1 Node2

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node1 Node9

    C#

    LinkedList0

    self.next.insert(value, index - 1)1

    Java

    LinkedList1 LinkedList2

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    4 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    5

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node4

    Node5Node3

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 LinkedList8LinkedList9Node0

    LinkedList0

    insert2 insert3

    Node8

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 insert6insert7insert7 insert9index == 00

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    Node0Node1 Node2

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node1 Node9

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node4

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    Node5Node7

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList0

    Chúng tôi đã thảo luận về các phương pháp khác nhau của việc chèn danh sách liên kết. Làm thế nào để tạo ra một danh sách được liên kết?

    LinkedList0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    26

    Chèn đệ quy ở cuối: & nbsp; để tạo một danh sách được liên kết bằng cách sử dụng đệ quy làm theo các bước này. Dưới đây các bước chèn một nút mới đệ quy ở cuối danh sách được liên kết. & Nbsp; & nbsp; 
    The idea is simple, we print current node and recur for remaining list.  

    Hướng dẫn insert node into linked list recursively python - chèn nút vào danh sách liên kết một cách đệ quy python
    Implementation:

    C++

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    3
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    4 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    5

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    Đọc

    Bàn luận

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    37
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    38
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    35

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    41

    LinkedList0

    class Node: def __init__(self, data, node=None): self.data = data self.next = node class LinkedList: def __init__(self, node=None): self.head = node def __repr__(self): values = [] curr = self.head while curr: values.append(curr.data) curr = curr.next return ', '.join(map(str, values)) def insert(self, value, index=0, node=None): node = node or self.head # if node==None, then assign self.head if node.next: if index == 0: node.next, node.data = Node(node.data, node.next), value else: self.insert(value, index=index-1, node=node.next) else: # if terminal node, ignore index node.next = Node(value) ll = LinkedList(Node(1, Node(3, Node(4)))) print(ll) # 1, 3, 4 ll.insert(2, 1) print(ll) # 1, 2, 3, 4 ll.insert(5, 4) print(ll) # 1, 2, 3, 4, 5 3class Node: def __init__(self, data, node=None): self.data = data self.next = node class LinkedList: def __init__(self, node=None): self.head = node def __repr__(self): values = [] curr = self.head while curr: values.append(curr.data) curr = curr.next return ', '.join(map(str, values)) def insert(self, value, index=0, node=None): node = node or self.head # if node==None, then assign self.head if node.next: if index == 0: node.next, node.data = Node(node.data, node.next), value else: self.insert(value, index=index-1, node=node.next) else: # if terminal node, ignore index node.next = Node(value) ll = LinkedList(Node(1, Node(3, Node(4)))) print(ll) # 1, 3, 4 ll.insert(2, 1) print(ll) # 1, 2, 3, 4 ll.insert(5, 4) print(ll) # 1, 2, 3, 4, 5 4 class Node: def __init__(self, data, node=None): self.data = data self.next = node class LinkedList: def __init__(self, node=None): self.head = node def __repr__(self): values = [] curr = self.head while curr: values.append(curr.data) curr = curr.next return ', '.join(map(str, values)) def insert(self, value, index=0, node=None): node = node or self.head # if node==None, then assign self.head if node.next: if index == 0: node.next, node.data = Node(node.data, node.next), value else: self.insert(value, index=index-1, node=node.next) else: # if terminal node, ignore index node.next = Node(value) ll = LinkedList(Node(1, Node(3, Node(4)))) print(ll) # 1, 3, 4 ll.insert(2, 1) print(ll) # 1, 2, 3, 4 ll.insert(5, 4) print(ll) # 1, 2, 3, 4, 5 5

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    9

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    Node0Node1 Node2

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node1
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    35

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    56
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    38
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    58

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    60

    LinkedList0

    Python3

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node1 Node9

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    3
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    4 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    5

    Node5Node1

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    9

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    80index == 09Node0

    C#

    LinkedList1 

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    27 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    45

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 LinkedList8LinkedList9Node0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node1
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    35

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    96
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    38
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    58

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    60

    LinkedList0

    & nbsp; chương trình hoàn chỉnh: & nbsp; bên dưới là chương trình hoàn chỉnh để chứng minh hoạt động của chèn và di chuyển một danh sách được liên kết. & nbsp;
    Complete Program: Below is complete program to demonstrate working of insert and traverse a linked list. 

    C++

    Node02

    Node03 Node04 Node05

    Node06 Node07

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    4 Node10

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node12

    Node13

    Node14

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    4 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    5

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node19Node20 Node21

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node23

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node25

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node1 Node28

    LinkedList0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    3
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    4 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    5

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    9

    Node0Node1 Node2

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node4

    Node5Node6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node1 Node9

    LinkedList0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    27 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    28

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    9

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    33Node1
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    35

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    37
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    38
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    35

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    41

    LinkedList0

    Node0Node1 Node2

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node68

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node70

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node72

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node74

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node76

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node78

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node80

    LinkedList0

    Node5Node6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node1 Node9

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    27 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    28

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    4 Node10

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node93

    Node13

    Node14

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    4 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    5

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node19Node20 Node21

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList05

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList07LinkedList9
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    35

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node1 Node28

    LinkedList0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    3
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    4 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    5

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 LinkedList8LinkedList9Node0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    9

    Node0Node1 Node2

    Node5Node7

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node1 Node9

    LinkedList0

    LinkedList1 

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    27 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    45

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 LinkedList8LinkedList9Node0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node1
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    35

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    56
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    38
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    58

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    60

    LinkedList0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    27 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    28

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList60LinkedList9
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    35

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList64LinkedList65
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    58

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList64LinkedList69
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    58

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList64LinkedList73
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    58

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    4 Node65

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList64LinkedList81
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    58

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node80

    LinkedList0

    LinkedList0

    Python3

    Java

    Node82 Node83

    LinkedList1 Node82 Node

    LinkedList1 Node96

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    4 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    5

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList01Node20 LinkedList03

    LinkedList1 LinkedList2

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    4 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    5

    Node5Node1 Node2

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node4

    LinkedList54 LinkedList1 

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    27 LinkedList57

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList64LinkedList777
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    58

    LinkedList87 LinkedList88

    Node82 LinkedList90

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7insert2 LinkedList93LinkedList94LinkedList95

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node4index == 06

    Node5LinkedList94LinkedList98insert7 Node00

    Node5LinkedList94Node03index == 09 insert7 insert9

    insert2 Node08

    Node82 LinkedList90

    Node5Node1

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7insert2 LinkedList93LinkedList94LinkedList95

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    80index == 09Node0

    Node5LinkedList94LinkedList98insert7 Node00

    Node5LinkedList94Node03index == 09 insert7 insert9

    insert2 Node08

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node10insert7 Node12

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node14insert7 Node00

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node18index == 09 insert7 insert9

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node1 Node24

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7insert12

    C#

    insert2 insert3

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node1 Node9

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    27 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    28

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    4 Node65

    Java

    Node13

    Node14

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    4 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    5

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node19Node20 Node21

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList05

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList07LinkedList9
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    35

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node1 Node28

    LinkedList0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    3
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    4 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    5

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 LinkedList8LinkedList9Node0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    9

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node4

    Node0Node1 Node2

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node1 Node9

    LinkedList0

    LinkedList1 

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    27 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    45

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 LinkedList8LinkedList9Node0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node1
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    35

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    96
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    38
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    58

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    60

    LinkedList0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    27 
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    28

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList60LinkedList9
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    35

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node70

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node72

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node74

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node76

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node78

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node80

    LinkedList0

    LinkedList0

    JavaScript

    Node8

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7index == 014

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    Node5index == 018

    index == 019index == 020index == 021LinkedList9

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    35

    index == 019index == 020index == 026

    Node5LinkedList0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node9 index == 03

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    Node5index == 037Node20 index == 039

    Node5Node1 Node28

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node9 index == 047

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    Node5

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 LinkedList8LinkedList9Node0

    index == 055Node1 Node2

    Node5Node4

    index == 055Node7

    Node5Node1 Node9

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node9 insert12

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    6

    Node5

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    8 LinkedList8LinkedList9Node0

    index == 055Node1

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    35

    Node5index == 081

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    38
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    58

    Node5

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    60

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7LinkedList0

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7index == 089LinkedList9
    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    35

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node70

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node72

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node74

    index == 055Node1 Node2

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node78

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    7Node80

    class Node:
    def __init__(self, data, node=None):
        self.data = data
        self.next = node

class LinkedList:
    def __init__(self, node=None):
        self.head = node
    def __repr__(self):
        values = []
        curr = self.head
        while curr:
            values.append(curr.data)
            curr = curr.next
        return ', '.join(map(str, values))
    def insert(self, value, index=0, node=None):
        node = node or self.head # if node==None, then assign self.head
        if node.next:
            if index == 0:
                node.next, node.data = Node(node.data, node.next), value
            else:
                self.insert(value, index=index-1, node=node.next)
        else: # if terminal node, ignore index
            node.next = Node(value)

ll = LinkedList(Node(1, Node(3, Node(4))))
print(ll) # 1, 3, 4
ll.insert(2, 1)
print(ll) # 1, 2, 3, 4
ll.insert(5, 4)
print(ll) # 1, 2, 3, 4, 5
    26

    Node5Node1 Node9AMIT KUMAR. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to . See your article appearing on the GeeksforGeeks main page and help other Geeks. 


    Làm thế nào để bạn thêm một nút trong một danh sách được liên kết đệ quy?

    Để chèn một nút ở đầu sau của danh sách được liên kết ...
    Tạo một hàm (giả sử insertrear ()) lấy con trỏ nút đầu và nút mới làm đối số hàm. ....
    Cơ sở là khi con trỏ đầu trỏ đến null. ....
    Khác, hãy gọi hàm insertrear () cho đầu-> tiếp theo ..
    Trả lại con trỏ đầu sau bước đệ quy ..

    Làm thế nào để bạn chèn một nút trong một danh sách được liên kết tại một vị trí nhất định trong Python?

    Cách tiếp cận: Để chèn một dữ liệu nhất định tại một vị trí được chỉ định, thuật toán dưới đây sẽ được tuân theo:..
    Đi qua danh sách được liên kết lên đến các nút vị trí-1 ..
    Khi tất cả các nút vị trí-1 được chuyển qua, phân bổ bộ nhớ và dữ liệu đã cho cho nút mới ..
    Chỉ con trỏ tiếp theo của nút mới vào nút tiếp theo của nút hiện tại ..

    Bạn có thể chèn một nút ở giữa danh sách được liên kết không?

    Chèn các yếu tố vào một danh sách được liên kết.Bạn có thể thêm các phần tử vào phần đầu, giữa hoặc cuối của danh sách được liên kết.You can add elements to either the beginning, middle or end of the linked list.

    Làm thế nào để bạn thêm một nút vào một vị trí ngẫu nhiên trong một danh sách được liên kết?

    Algorithm..
    Bước 1 Bắt đầu ..
    Bước 2 Lưu trữ phần tử để thêm vào danh sách liên kết ..
    Bước 3 Lưu trữ dữ liệu của nút sau đó nút mới sẽ được chèn (khóa).
    Bước 4 Traverse Till Key được tìm thấy và điểm (PTR) để tiêu đề ..
    Bước 5 Kiểm tra xem ptr-> data == key thì Goto Bước 6 khác Bước 7 ..
    Bước 6 Tạo liên kết và thêm giá trị dữ liệu vào nút mới ..

    programming python Insert node recursively

    Bài Viết Liên Quan

    Hướng dẫn cài dual boot kali linux
    Hướng dẫn cài dual boot kali linux

    Hướng dẫn which of the following is not a built-in associative array used by php - mảng nào sau đây không phải là mảng kết hợp dựng sẵn được php sử dụng
    Hướng dẫn which of the following is not a built-in associative array used by php - mảng nào sau đây không phải là mảng kết hợp dựng sẵn được php sử dụng

    Hướng dẫn index of last occurrence python - chỉ mục của lần xuất hiện cuối cùng python
    Hướng dẫn index of last occurrence python - chỉ mục của lần xuất hiện cuối cùng python

    Hướng dẫn is an empty string null php? - là một chuỗi rỗng null php?
    Hướng dẫn is an empty string null php? - là một chuỗi rỗng null php?

    Điểm chuẩn đại học 2023 y dược
    Điểm chuẩn đại học 2023 y dược

    Hướng dẫn how do you do a carriage return in python? - làm thế nào để bạn thực hiện một ký tự xuống dòng trong python?
    Hướng dẫn how do you do a carriage return in python? - làm thế nào để bạn thực hiện một ký tự xuống dòng trong python?

    Hướng dẫn php add seconds to datetime - php thêm giây vào datetime
    Hướng dẫn php add seconds to datetime - php thêm giây vào datetime

    Hướng dẫn python subprocess get output - quy trình con python lấy đầu ra
    Hướng dẫn python subprocess get output - quy trình con python lấy đầu ra

    Hướng dẫn postfix javascript - hậu tố javascript
    Hướng dẫn postfix javascript - hậu tố javascript

    Hướng dẫn python instance variable type - loại biến phiên bản python
    Hướng dẫn python instance variable type - loại biến phiên bản python

    MỚI CẬP NHẬP

    Nóng đỏ tai phải là điềm gì năm 2024
    18 phúts trước . bởi MortalHoarding
    Những bài toán lớp 1 giúp trẻ tư duy năm 2024
    25 phúts trước . bởi AnnoyedWomanhood
    Top 10 chien binh manh nhat trong yugioh năm 2024
    51 phúts trước . bởi Air-conditioningSnack
    2023 việt nam công nghiệp hóa điện đại hóa năm 2024
    1 giờs trước . bởi VirileStimulus
    Bồ công anh là cây gì năm 2024
    1 giờs trước . bởi UntowardDeparture
    Bút toán góp vốn vốn đầu tư nước ngoài năm 2024
    1 giờs trước . bởi FloralCross-examination
    Woocommerce bị lỗi thư mục đích đã tồn tại năm 2024
    1 giờs trước . bởi UnitaryBrightness
    Đặc biệt phải kể đến trong tiếng anh là gì năm 2024
    2 giờs trước . bởi ImmortalCollaborator
    Huyện triệu sơn tỉnh thanh hóa có bao nhiêu xã năm 2024
    2 giờs trước . bởi DiminishingIniquity
    Bột bả trét tường tiếng anh là gì năm 2024
    2 giờs trước . bởi PorousPlateau

    Xem Nhiều

    Yeu tố nước trong kiến trúc cảnh quan là gì năm 2024
    6 ngàys trước . bởi PreservingWiring
    File kẹp tài liệu đục lỗ tiếng anh là gì năm 2024
    17 giờs trước . bởi InsidiousReceptor
    Lỗi khi mở folder màn hình view bị thu nhỏ năm 2024
    2 ngàys trước . bởi RegimentalAdoption
    Rách giời rơi xuống nghĩa là gì năm 2024
    2 ngàys trước . bởi VastOrientation
    Uống vitamin d vào lúc nào tốt nhất năm 2024
    1 ngàys trước . bởi PrimordialHacker
    Chính sách kế hoạch hóa gia đình 2023 năm 2024
    5 ngàys trước . bởi FinancialAllotment
    Những bài toán lớp 1 giúp trẻ tư duy năm 2024
    25 phúts trước . bởi AnnoyedWomanhood
    He had two trains but they were armored là gì năm 2024
    6 ngàys trước . bởi ItinerantDominion
    Bởi vì em hết yêu anh đạo từ bài nào năm 2024
    3 ngàys trước . bởi ImprovisedTraveler
    Hiến pháp hoa kỳ được làm ra như thế nào năm 2024
    1 tuầns trước . bởi StainedCurfew

    Chúng tôi

    Điều khoản

    Trợ giúp

    Mạng xã hội

    Bản quyền © 2024 Inc.