Python implements a single-linked list

# Coding:utf-8


Class Node:
def __init__ (self, value):
Self.data = value
Self.next = None


Class linklist:
def __init__ (self, data=[0]):
Self.head = None
Self.init_link_list (data)

# Initialize linked list
# Data Array
def init_link_list (self, data):
If Len (data) = = 0:
Print ("Initialization data is null")
Return
Self.head = Node (data[0])
Current = Self.head
For index in DATA[1:]:
Current.next = Node (index)
Current = Current.next

# Get current node
def get_node (self, Index):
If Self.is_empty ():
Print ("link is empty")
Return
If index > Self.get_length () or index <= 0:
Print ("Node is not exist")
Return
Current = Self.head
i = 0
While I < index:
if i = = index-1:
Return current
Current = Current.next
i + = 1

# Gets the value of the current element
def get_data (self, Index):
Current = Self.get_node (index)
If current is None:
Return "node is not exist"
Return Current.data

# Print linked list
def print_link (self):
If Self.is_empty ():
Return
list = []
Current = Self.head
While Current.next are not None:
List.append (Current.data)
Current = Current.next
Else
List.append (Current.data)
Print (list)

# Get linked list length
def get_length (self):
If Self.is_empty ():
return 0
Current = Self.head
Count = 0
While Current.next are not None:
Count + = 1
Current = Current.next
Else
Count + = 1
return count

# Determine if the linked list is empty
# If empty, returns True
# If not empty, return false
def is_empty (self):
Return Self.head is None

# Inserts an element after the current element
# index Element Indexes
# Value inserted by data
def add_after (self, Index, data):
Current = Self.get_node (index)
If current is None:
Return "node is not exist"
Current_next = Current.next
Current.next = Node (data)
Current = Current.next
Current.next = Current_next

# Insert an element before the current element
def add_before (self, Index, data):
If index = = 1:
Current = Self.get_node (index)
Self.head = Node (data)
Self.head.next = Current
Return
Pre = Self.get_pre_node (index)
Current = Pre.next
Pre.next = Node (data)
Pre = Pre.next
Pre.next = Current

# Gets the previous element of the current element
def get_pre_node (self, Index):
If Self.is_empty ():
Print ("link is empty")
Return
If index > Self.get_length () or index <= 1:
Print ("Node is not exist")
Return
Pre = Self.head
i = 0
While I < index:
if i = = index-2:
return pre
Pre = Pre.next
i + = 1

# deletes the specified element and returns the value of the deleted element
def remove (self, index):
If index = = 1 and not Self.is_empty ():
data = Self.head.data
Self.head = Self.head.next
Return data
Pre_node = Self.get_pre_node (index)
Current = Self.get_node (index)
If Pre_node is None or current is none:
Print ("Data is not exist")
Pre_node.next = Current.next
Return Current.data

# Modify the value of the current node
def update (self, Index, data):
Current = Self.get_node (index)
If current is None:
Return "Current node is none"
Current.data = Data

# merge new linked list into current linked list
def merge (self, data):
Size = Self.get_length ()
Last_node = Self.get_node (size)
Last_node.next = Data.head
return self

# test
y = (1,2,3,4)
s = ["A", "B", "C", "D"]
linklist = linklist (y)
# linklist.init_link_list (["A", "B", "C", "D"])
# second = linklist ()
# second.init_link_list (["X", "Y", "Z"])
# Linklist.add_after ( -1, "X")
# Linklist.add_after (1, "Y")
# linklist.init_link_list ([])
# Linklist.add_before (1, "X")
# Linklist.print_link ()
# Print ("Item:", Linklist.get_data (2))
# print ("Length:", Linklist.get_length ())
# print ("is Empty", Linklist.is_empty ())
# Print (Linklist.get_pre_node (3). Data)
# Print ("Remove node:", Linklist.remove (2))
# Linklist.merge (second)


Linklist.print_link ()

