질문있습니다. 지금 한방향연결리스트를 공부중입니다. 그런데 insert함수에서 2 15를 입력시 0 1 2 의 2번째 방이 아닌 1번째 방에 15가 입력이 됩니다.

또 insert 함수를 구현하면서 .number를 사용했는데 .number를 사용하지 않고 insert함수를 구현하는 방법은 무엇이 있나요?

class Node:
    def __init__(self, key=None):
        self.key = key
        self.next = None
        self.number=0
    def __str__(self):
        return str(self.key)

class SinglyLinkedList:
    def __init__(self):
        self.head = None
        self.size = 0

    def __len__(self):
        return self.size

    def printList(self):
        v = self.head
        while(v):
            print(v.key, "->", end=" ")
            v = v.next
        print("None")

    def pushFront(self, key):
        new_node = Node(key)
        new_node.next = L.head
        L.head = new_node
        L.size += 1 

    def pushBack(self, key):
        v = Node(key)
        if len(self) == 0:
            self.head = v
        else:
            tail = self.head
            while tail.next != None:
                tail = tail.next
            tail.next = v
        self.size += 1

    def popFront(self): 
        # head 노드의 값 리턴. empty list이면 None 리턴
        if len(self)==0:
            return None
        else:
            x=self.head
            key = x.key
            self.head = x.next
            self.size -= 1
            del x
            return key

    def popBack(self):
        # tail 노드의 값 리턴. empty list이면 None 리턴
        if len(self)==0: return None
        else:
            prev,tail = None, self.head
            while tail.next != None:
                prev=tail
                tail=tail.next
            if len(self)==1:
                self.head=None
            else:
                prev.next=tail.next
            key = tail.key
            del tail
            self.size -= 1
            return key

    def search(self, key):
        # key 값을 저장된 노드 리턴. 없으면 None 리턴
        v = self.head
        while v != None:
            if v.key == key:
                return v
            v = v.next
        return None
    def remove(self, x):
        # 노드 x를 제거한 후 True리턴. 제거 실패면 False 리턴
        node_head=self.head
        temp = Node()
        if node_head == None: return False

        if node_head == x:
            temp = self.head
            self.head = self.head.next
            del temp
            return True
        node = self.head
        while node.next:
            if node.next == x:
                temp = node.next
                node.next = node.next.next
                del temp
                return True
            node = node.next

        return False
    def reverse(self):
        prev = None
        current = self.head
        while(current != None):
            next = current.next
            current.next = prev
            prev = current
            current = next
        self.head = prev
    def findMax(self):
        # self가 empty이면 None, 아니면 max key 리턴
        current = self.head 
        if len(self) == 0: return None
        else:
            maxnum = self.head.key
            while(current != None):
                if(maxnum < current.key):
                    maxnum = current.key
                current = current.next
        return maxnum
    def deleteMax(self):
        # self가 empty이면 None, 아니면 max key 지운 후, max key 리턴
        current = self.head

        if len(self) == 0 : return None
        else:
            maxnum = self.head.key
            while(current != None):
                if(maxnum < current.key):
                    maxnum = current.key
                current = current.next
            max_node = self.search(maxnum)
            self.remove(max_node)
        return maxnum

    def insert(self, k, val):
        node_head = self.head
        insert_node = Node(val)
        insert_node.number = k-1
        temp = Node()

        while node_head.next:
            if node_head.number+2 == k:
                temp = node_head.next
                node_head.next = insert_node
                insert_node.next = temp
                break
            else:
                node_head = self.head
                while node_head.next != None:
                    node_head = node_head.next
            node_head.next = insert_node
            self.size += 1
            break

# 아래 코드는 수정하지 마세요!
L = SinglyLinkedList()
while True:
    cmd = input().split()
    if cmd[0] == "pushFront":
        L.pushFront(int(cmd[1]))
        print(int(cmd[1]), "is pushed at front.")
    elif cmd[0] == "pushBack":
        L.pushBack(int(cmd[1]))
        print(int(cmd[1]), "is pushed at back.")
    elif cmd[0] == "popFront":
        x = L.popFront()
        if x == None:
            print("List is empty.")
        else:
            print(x, "is popped from front.")
    elif cmd[0] == "popBack":
        x = L.popBack()
        if x == None:
            print("List is empty.")
        else:
            print(x, "is popped from back.")
    elif cmd[0] == "search":
        x = L.search(int(cmd[1]))
        if x == None:
            print(int(cmd[1]), "is not found!")
        else:
            print(int(cmd[1]), "is found!")
    elif cmd[0] == "remove":
        x = L.search(int(cmd[1]))
        if L.remove(x):
            print(x.key, "is removed.")
        else:
            print("Key is not removed for some reason.")
    elif cmd[0] == "reverse":
        L.reverse()
    elif cmd[0] == "findMax":
        m = L.findMax()
        if m == None:
            print("Empty list!")
        else:
            print("Max key is", m)
    elif cmd[0] == "deleteMax":
        m = L.deleteMax()
        if m == None:
            print("Empty list!")
        else:
            print("Max key", m, "is deleted.")
    elif cmd[0] == "insert":
        L.insert(int(cmd[1]), int(cmd[2]))
        print(cmd[2], "is inserted at", cmd[1]+"-th position.")
    elif cmd[0] == "printList":
        L.printList()
    elif cmd[0] == "size":
        print("list has", len(L), "nodes.")
    elif cmd[0] == "exit":
        print("DONE!")
        break
    else:
        print("Not allowed operation! Enter a legal one!")
    ```