Example 1: doubly linked list in python
Full implementation of Doubly Linked List:
https://github.com/shreyasvedpathak/Data-Structure-Python/tree/master/LinkedList
Example 2: linked list in python
class Node:
def __init__(self, data = None, next_node = None):
self.data = data
self.nextNode = next_node
def get_data(self):
return self.data
def set_data(self, data):
self.data = data
def get_nextNode(self):
return self.nextNode
def set_nextNode(self, nextNode):
self.nextNode = nextNode
class LinkedList:
def __init__(self, head = None):
self.head = head
def add_Node(self, data):
# if empty
if self.head == None:
self.head = Node(data)
# not empty
else:
curr_Node = self.head
# if node added is at the start
if data < curr_Node.get_data():
self.head = Node(data, curr_Node)
# not at start
else:
while data > curr_Node.get_data() and curr_Node.get_nextNode() != None:
prev_Node = curr_Node
curr_Node = curr_Node.get_nextNode()
# if node added is at the middle
if data < curr_Node.get_data():
prev_Node.set_nextNode(Node(data, curr_Node))
# if node added is at the last
elif data > curr_Node.get_data() and curr_Node.get_nextNode() == None:
curr_Node.set_nextNode(Node(data))
def search(self, data):
curr_Node = self.head
while curr_Node != None:
if data == curr_Node.get_data():
return True
else:
curr_Node = curr_Node.get_nextNode()
return False
def delete_Node(self, data):
if self.search(data):
# if data is found
curr_Node = self.head
#if node to be deleted is the first node
if curr_Node.get_data() == data:
self.head = curr_Node.get_nextNode()
else:
while curr_Node.get_data() != data:
prev_Node = curr_Node
curr_Node = curr_Node.get_nextNode()
#node to be deleted is middle
if curr_Node.get_nextNode() != None:
prev_Node.set_nextNode(curr_Node.get_nextNode())
# node to be deleted is at the end
elif curr_Node.get_nextNode() == None:
prev_Node.set_nextNode(None)
else:
return "Not found."
def return_as_lst(self):
lst = []
curr_Node = self.head
while curr_Node != None:
lst.append(curr_Node.get_data())
curr_Node = curr_Node.get_nextNode()
return lst
def size(self):
curr_Node = self.head
count = 0
while curr_Node:
count += 1
curr_Node = curr_Node.get_nextNode()
return count
## TEST CASES #
test1 = LinkedList()
test2 = LinkedList()
test1.add_Node(20)
test1.add_Node(15)
test1.add_Node(13)
test1.add_Node(14)
test1.delete_Node(17)
print(test1.return_as_lst())
print(test2.size())
Example 3: doubly linked list python
class ListNode:
def __init__(self, value, prev=None, next=None):
self.prev = prev
self.value = value
self.next = next
class DoublyLinkedList:
def __init__(self, node=None):
self.head = node
self.tail = node
self.length = 1 if node is not None else 0
def __len__(self):
return self.length
def add_to_head(self, value):
new_node = ListNode(value, None, None)
self.length += 1
if not self.head and not self.tail:
self.head = new_node
self.tail = new_node
else:
new_node.next = self.head
self.head.prev = new_node
self.head = new_node
def remove_from_head(self):
value = self.head.value
self.delete(self.head)
return value
def add_to_tail(self, value):
new_node = ListNode(value, None, None)
self.length += 1
if not self.tail and not self.head:
self.tail = new_node
self.head = new_node
else:
new_node.prev = self.tail
self.tail.next = new_node
self.tail = new_node
def remove_from_tail(self):
value = self.tail.value
self.delete(self.tail)
return value
def move_to_front(self, node):
if node is self.head:
return
value = node.value
if node is self.tail:
self.remove_from_tail()
else:
node.delete()
self.length -= 1
self.add_to_head(value)
def move_to_end(self, node):
if node is self.tail:
return
value = node.value
if node is self.head:
self.remove_from_head()
self.add_to_tail(value)
else:
node.delete()
self.length -= 1
self.add_to_tail(value)
def delete(self, node):
self.length -= 1
if not self.head and not self.tail:
return
if self.head == self.tail:
self.head = None
self.tail = None
elif self.head == node:
self.head = node.next
node.delete()
elif self.tail == node:
self.tail = node.prev
node.delete()
else:
node.delete()
def get_max(self):
if not self.head:
return None
max_val = self.head.value
current = self.head
while current:
if current.value > max_val:
max_val = current.value
current = current.next
return max_val
Example 4: double linked list java
class doublelinkedlist{
Node head;
Node tail;
static class Node{
int data;
Node previous;
Node next;
Node(int data) { this.data = data; }
}
public void addLink(int data) {
Node node = new Node(data);
if(head == null) {
head = tail = node;
head.previous = null;
} else {
tail.next = node;
node.previous = tail;
tail = node;
}
tail.next = null;
}
}
Example 5: doubly linked list python
# Initialise the Node
class Node:
def __init__(self, data):
self.item = data
self.next = None
self.prev = None
# Class for doubly Linked List
class doublyLinkedList:
def __init__(self):
self.start_node = None
# Insert Element to Empty list
def InsertToEmptyList(self, data):
if self.start_node is None:
new_node = Node(data)
self.start_node = new_node
else:
print("The list is empty")
# Insert element at the end
def InsertToEnd(self, data):
# Check if the list is empty
if self.start_node is None:
new_node = Node(data)
self.start_node = new_node
return
n = self.start_node
# Iterate till the next reaches NULL
while n.next is not None:
n = n.next
new_node = Node(data)
n.next = new_node
new_node.prev = n
# Delete the elements from the start
def DeleteAtStart(self):
if self.start_node is None:
print("The Linked list is empty, no element to delete")
return
if self.start_node.next is None:
self.start_node = None
return
self.start_node = self.start_node.next
self.start_prev = None;
# Delete the elements from the end
def delete_at_end(self):
# Check if the List is empty
if self.start_node is None:
print("The Linked list is empty, no element to delete")
return
if self.start_node.next is None:
self.start_node = None
return
n = self.start_node
while n.next is not None:
n = n.next
n.prev.next = None
# Traversing and Displaying each element of the list
def Display(self):
if self.start_node is None:
print("The list is empty")
return
else:
n = self.start_node
while n is not None:
print("Element is: ", n.item)
n = n.next
print("\n")
# Create a new Doubly Linked List
NewDoublyLinkedList = doublyLinkedList()
# Insert the element to empty list
NewDoublyLinkedList.InsertToEmptyList(10)
# Insert the element at the end
NewDoublyLinkedList.InsertToEnd(20)
NewDoublyLinkedList.InsertToEnd(30)
NewDoublyLinkedList.InsertToEnd(40)
NewDoublyLinkedList.InsertToEnd(50)
NewDoublyLinkedList.InsertToEnd(60)
# Display Data
NewDoublyLinkedList.Display()
# Delete elements from start
NewDoublyLinkedList.DeleteAtStart()
# Delete elements from end
NewDoublyLinkedList.DeleteAtStart()
# Display Data
NewDoublyLinkedList.Display()