用于在链表中插入节点的Python程序

我们在上一篇文章中介绍了链表。我们还创建了一个包含 3 个节点的简单链表并讨论了链表遍历。
这篇文章中讨论的所有程序都考虑了链表的以下表示。

Python

# Node class
class Node:
  
    # Function to initialize the 
    # node object
    def __init__(self, data):
  
        # Assign data
        self.data = data  
    
        # Initialize next as null
        self.next = None  
  
# Linked List class
class LinkedList:
    
    # Function to initialize the 
    # Linked List object
    def __init__(self): 
        self.head = None

在这篇文章中，讨论了在链表中插入新节点的方法。可以通过三种方式添加节点
1）在链表的前面
2）在给定节点之后。
3)在链表的末尾。

在前面添加一个节点：（4步过程）
新节点总是添加在给定链表的头部之前。新添加的节点成为链表的新头。例如，如果给定的链表是 10->15->20->25，我们在前面添加一个项目 5，那么链表变为 5->10->15->20->25。让我们将添加到列表前面的函数称为 push()。 push() 必须接收指向头指针的指针，因为 push 必须更改头指针以指向新节点（请参阅this）

以下是在前面添加节点的 4 个步骤。

Python

# This function is in LinkedList class
# Function to insert a new node at 
# the beginning
def push(self, new_data):
  
    # 1 & 2: Allocate the Node &
    #        Put in the data
    new_node = Node(new_data)
          
    # 3. Make next of new Node as head
    new_node.next = self.head
          
    # 4. Move the head to point to new Node 
    self.head = new_node

push() 的时间复杂度是 O(1)，因为它做的工作量是恒定的。
在给定节点之后添加一个节点：（5个步骤）
我们得到一个指向节点的指针，新节点插入到给定节点之后。

Python

# This function is in LinkedList class. 
# Inserts a new node after the given 
# prev_node. This method is defined 
# inside LinkedList class shown above 
def insertAfter(self, prev_node, new_data): 
  
    # 1. Check if the given prev_node exists 
    if prev_node is None: 
        print "The given previous node must in LinkedList."
        return
  
    # 2. Create new node & 
    # 3. Put in the data 
    new_node = Node(new_data) 
  
    # 4. Make next of new Node as next of prev_node 
    new_node.next = prev_node.next
  
    # 5. make next of prev_node as new_node 
    prev_node.next = new_node

insertAfter() 的时间复杂度是 O(1)，因为它做的工作量是恒定的。

最后添加一个节点：（6步过程）
新节点总是添加在给定链表的最后一个节点之后。例如，如果给定的链表是 5->10->15->20->25 并且我们在末尾添加了一个项目 30，那么链表变为 5->10->15->20->25- >30。
由于链接列表通常由其头部表示，因此我们必须遍历列表直到最后，然后将倒数第二个节点更改为新节点。

以下是最后添加节点的 6 个步骤。

Python

# This function is defined in Linked List 
# class appends a new node at the end.  
# This method is defined inside LinkedList 
# class shown above 
def append(self, new_data):
 
   # 1. Create a new node
   # 2. Put in the data
   # 3. Set next as None
   new_node = Node(new_data)
 
   # 4. If the Linked List is empty, then 
   #    make the new node as head
   if self.head is None:
        self.head = new_node
        return
 
   # 5. Else traverse till the last node
   last = self.head
   while (last.next):
       last = last.next
 
   # 6. Change the next of last node
   last.next =  new_node

追加的时间复杂度是 O(n)，其中 n 是链表中的节点数。由于从头到尾有一个循环，因此该函数执行 O(n) 工作。
通过保留一个指向链表尾部的额外指针，还可以优化此方法以在 O(1) 中工作/

下面是一个完整的程序，它使用上述所有方法来创建一个链表。

Python

# A complete working Python program to demonstrate all
# insertion methods of linked list
  
# Node class
class Node:
  
    # Function to initialize the 
    # node object
    def __init__(self, data):
  
        # Assign data
        self.data = data  
  
        # Initialize next as null
        self.next = None  
  
  
# Linked List class contains a
# Node object
class LinkedList:
  
    # Function to initialize head
    def __init__(self):
        self.head = None
  
    # Functio to insert a new node at
    # the beginning
    def push(self, new_data):
  
        # 1 & 2: Allocate the Node &
        #        Put in the data
        new_node = Node(new_data)
  
        # 3. Make next of new Node as head
        new_node.next = self.head
  
        # 4. Move the head to point to new Node
        self.head = new_node
  
  
    # This function is in LinkedList class. 
    # Inserts a new node after the given
    # prev_node. This method is defined 
    # inside LinkedList class shown above 
    def insertAfter(self, prev_node, new_data):
  
        # 1. Check if the given prev_node exists
        if prev_node is None:
            print "The given previous node must inLinkedList."
            return
  
        #  2. Create new node &
        #     Put in the data
        new_node = Node(new_data)
  
        # 4. Make next of new Node as next 
        #    of prev_node
        new_node.next = prev_node.next
  
        # 5. make next of prev_node as new_node
        prev_node.next = new_node
  
  
    # This function is defined in Linked List class
    # Appends a new node at the end.  This method is
    # defined inside LinkedList class shown above */
    def append(self, new_data):
  
        # 1. Create a new node
        # 2. Put in the data
        # 3. Set next as None
        new_node = Node(new_data)
  
        # 4. If the Linked List is empty, then make the
        #    new node as head
        if self.head is None:
            self.head = new_node
            return
  
        # 5. Else traverse till the last node
        last = self.head
        while (last.next):
            last = last.next
  
        # 6. Change the next of last node
        last.next =  new_node
  
    # Utility function to print the 
    # linked list
    def printList(self):
        temp = self.head
        while (temp):
            print temp.data,
            temp = temp.next
  
# Code execution starts here
if __name__=='__main__':
  
    # Start with the empty list
    llist = LinkedList()
  
    # Insert 6.  So linked list 
    becomes 6->None
    llist.append(6)
  
    # Insert 7 at the beginning. So 
    # linked list becomes 7->6->None
    llist.push(7);
  
    # Insert 1 at the beginning. So 
    # linked list becomes 1->7->6->None
    llist.push(1);
  
    # Insert 4 at the end. So linked list 
    # becomes 1->7->6->4->None
    llist.append(4)
  
    # Insert 8, after 7. So linked list 
    # becomes 1 -> 7-> 8-> 6-> 4-> None
    llist.insertAfter(llist.head.next, 8)
  
    print 'Created linked list is:',
    llist.printList()
# This code is contributed by Manikantan Narasimhan

输出：

Created Linked list is:  1  7  8  6  4

请参阅链表上的完整文章 |设置 2（插入节点）了解更多详情！