How do you add elements to the end of a linked list in Python?

Linked List | Set 2 (Inserting a node)

Table of Contents Show

Linked List | Set 2 (Inserting a node)
Python Program For Inserting A Node In A Linked List
Python - Linked Lists
Linked Lists in Python: An Introduction
Linked List Operations: Traverse, Insert and Delete
Things to Remember about Linked List

We have introduced Linked Lists in the previous post. We also created a simple linked list with 3 nodes and discussed linked list traversal.
All programs discussed in this post consider the following representations of linked list.

C++

// A linked list node

class Node

{

public:

int data;

Node *next;

};

// This code is contributed by rathbhupendra

// A linked list node

struct Node

{

int data;

struct Node *next;

};

Java

// Linked List Class

class LinkedList
{

Node head; // head of list

/* Node Class */

class Node

{

int data;

Node next;

// Constructor to create a new node

Node(int d) {data = d; next = null; }

}
}

Python

# Node class

class Node:

# Function to initialize the node object

def __init__(self, data):

self.data = data # Assign data

self.next = None # Initialize next as null

# Linked List class

class LinkedList:

# Function to initialize the Linked List object

def __init__(self):

self.head = None

/* Linked list Node*/

public class Node

{

public int data;

public Node next;

public Node(int d) {data = d; next = null; }

}

Javascript

<script>
// Linked List Class

var head; // head of list

/* Node Class */

class Node {

// Constructor to create a new node

constructor(d) {

this.data = d;

this.next = null;

}

}
// This code is contributed by todaysgaurav 
</script>

In this post, methods to insert a new node in linked list are discussed. A node can be added in three ways
1) At the front of the linked list
2) After a given node.
3) At the end of the linked list.

Python Program For Inserting A Node In A Linked List

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

In this post, methods to insert a new node in linked list are discussed. A node can be added in three ways
1) At the front of the linked list
2) After a given node.
3) At the end of the linked list.

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Add a node at the front: (4 steps process)
The new node is always added before the head of the given Linked List. And newly added node becomes the new head of the Linked List. For example, if the given Linked List is 10->15->20->25 and we add an item 5 at the front, then the Linked List becomes 5->10->15->20->25. Let us call the function that adds at the front of the list is push(). The push() must receive a pointer to the head pointer, because push must change the head pointer to point to the new node (See this)

Following are the 4 steps to add a node at the front.

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

Time complexity of push() is O(1) as it does a constant amount of work.
Add a node after a given node: (5 steps process)
We are given a pointer to a node, and the new node is inserted after the given node.

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

Time complexity of insertAfter() is O(1) as it does a constant amount of work.

Add a node at the end: (6 steps process)
The new node is always added after the last node of the given Linked List. For example if the given Linked List is 5->10->15->20->25 and we add an item 30 at the end, then the Linked List becomes 5->10->15->20->25->30.
Since a Linked List is typically represented by the head of it, we have to traverse the list till the end and then change the next to last node to a new node.

Following are the 6 steps to add node at the end.

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

Time complexity of append is O(n) where n is the number of nodes in the linked list. Since there is a loop from head to end, the function does O(n) work.
This method can also be optimized to work in O(1) by keeping an extra pointer to the tail of the linked list/

Following is a complete program that uses all of the above methods to create a linked list.

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

Output:

Created Linked list is: 1 7 8 6 4

Please refer complete article on Linked List | Set 2 (Inserting a node) for more details!

Article Tags :

Linked List

Python

Python Programs

Linked Lists

TCS

Wipro

Practice Tags :

Wipro

TCS

Linked List

Read Full Article

Python - Linked Lists

Linked Lists in Python: An Introduction

by Pedro Pregueiro intermediate python

Mark as Completed

Tweet Share Email

Table of Contents

Remove ads

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Working With Linked Lists in Python

Linked lists are like a lesser-known cousin of lists. They’re not as popular or as cool, and you might not even remember them from your algorithms class. But in the right context, they can really shine.

In this article, you’ll learn:

What linked lists are and when you should use them
How to use collections.deque for all of your linked list needs
How to implement your own linked lists
What the other types of linked lists are and what they can be used for

If you’re looking to brush up on your coding skills for a job interview, or if you want to learn more about Python data structures besides the usual dictionaries and lists, then you’ve come to the right place!

You can follow along with the examples in this tutorial by downloading the source code available at the link below:

Get the Source Code: Click here to get the source code you’ll use to learn about linked lists in this tutorial.

Linked List Operations: Traverse, Insert and Delete

In this tutorial, you will learn different operations on a linked list. Also, you will find implementation of linked list operations in C/C++, Python and Java.

There are various linked list operations that allow us to perform different actions on linked lists. For example, the insertion operation adds a new element to the linked list.

Here's a list of basic linked list operations that we will cover in this article.

Traversal - access each element of the linked list
Insertion - adds a new element to the linked list
Deletion - removes the existing elements
Search - find a node in the linked list
Sort - sort the nodes of the linked list

Before you learn about linked list operations in detail, make sure to know about Linked List first.

Things to Remember about Linked List

head points to the first node of the linked list
next pointer of the last node is NULL, so if the next current node is NULL, we have reached the end of the linked list.

In all of the examples, we will assume that the linked list has three nodes 1 --->2 --->3 with node structure as below:

struct node { int data; struct node *next; };