def copy(self, node_cpy):
if node_cpy:
nd = Node(node_cpy.getData())
nd.setNext(node_cpy.getNext())
return nd
else:
return None
def enqueue(self, data):
new_node = Node(data)
if self.head:
curr = self.head
prev = None
while curr:
prev = curr
curr = curr.getNext()
prev.setNext(new_node)
else:
self.head = Node(data)
def push(self, item):
"""
:type value: item [int, string .. etc]
:rtype: void Do not return anything, just add node in the first of list
"""
# if not isinstance(item, Node):
item = Node(item)
item.setNext(self.head)
self.head = item
return
def insertBefore(self, pos, item):
"""
:param pos: int, to specify the pos of new element
:param item: data, the new node data value
:return: Bolean, True if insertion succeded False otherwise
"""
item = Node(item)
current = self.head
prev = None
current_pos = 1
while current:
if current_pos == pos:
if prev:
prev.setNext(item)
item.setPrev(prev)
item.setNext(current)
current.setPrev(item)
else:
self.head.setPrev(item)
item.setNext(self.head)
item.setPrev(None)
self.head = item
return True
prev = current
current = current.getNext()
current_pos += 1
return False
def append(self, item):
"""
:param item: it's an new node data
:return: void doesn't return anything
"""
current = self.head
while current:
if not current.getNext():
break
current = current.getNext()
if not self.head:
item = Node(item)
self.head = item
else:
item = Node(item)
current.setNext(item)
item.setPrev(current)
item.setNext(None)
def sum_lists(num1, num2):
node1, node2 = num1.head, num2.head
carry = 0
result_head, result_node = None, None
while node1 or node2 or carry:
value = carry
if node1:
value += node1.getData()
node1 = node1.getNext()
if node2:
value += node2.getData()
node2 = node2.getNext()
if result_node:
result_node.setNext(Node(value % 10))
result_node = result_node.getNext()
else:
result_node = Node(value % 10)
result_head = result_node
carry = value // 10
return result_head
def push(self, item):
"""
:param item: it's an new node data
:return: void doesn't return anything
"""
item = Node(item)
if self.head:
self.head.setPrev(item)
item.setNext(self.head)
item.setPrev(None)
self.head = item
def append(self, item):
"""
:type value: item [int, string .. etc]
:rtype: void Do not return anything, just add node in the end of list
"""
item = Node(item)
current = self.head
while current:
if not current.getNext():
break
current = current.getNext()
if current:
current.setNext(item)
else:
self.head = item
item.setNext(None)
return
def push(self, data):
if self._min and (self._min.getData() < data):
old_min = self._min
self._min = Node ( self._min.getData() )
self._min.setNext( old_min )
else:
old_min = self._min
self._min = Node ( data )
self._min.setNext( old_min )
old_h = self.head
self.head = Node ( data )
self.head.setNext( old_h )
def insertAfter(self, pos, item):
"""
:param pos: int, to specify the pos of new element
:param item: data, the new node data value
:return: Bolean, True if insertion succeded False otherwise
"""
if pos <= 1:
return "Pos must be greater than or equal to one"
item = Node(item)
current = self.head
nxt = current.getNext()
current_pos = 1
while current:
if current_pos == pos:
if nxt:
nxt.setPrev(item)
current.setNext(item)
item.setNext(nxt)
item.setPrev(current)
else:
if current_pos > 1:
item.setPrev(current)
item.setNext(nxt)
current.setNext(item)
else:
item.setNext(self.head.getNext())
item.setPrev(self.head.getPrev())
self.head.setPrev(item)
self.head = item
return True
current = current.getNext()
nxt = current.getNext()
current_pos += 1
return False
def add(self, item):
"""
:type value: item [int, string .. etc]
:rtype: void Do not return anything, just add node in its sutiable position
"""
current = self.head
prev = None
# stop = False
while current:
if current.getData() > item:
break
else:
prev = current
current = current.getNext()
new_node = Node(item)
if not prev:
new_node.setNext(self.head)
self.head = new_node
else:
new_node.setNext(current)
prev.setNext(new_node)
return
class LQueue:
def __init__(self):
self.head = None
# This to enqueue element in the first of queue
def enqueue(self, data):
new_node = Node(data)
if self.head:
curr = self.head
prev = None
while curr:
prev = curr
curr = curr.getNext()
prev.setNext(new_node)
else:
self.head = Node(data)
# remove the first elemen in queue
def dequeue(self):
if self.isEmpty():
return "Queue is already empty"
removed_data = self.head.getData()
if not self.head.getNext():
self.head = None
else:
self.head = self.head.getNext()
return removed_data
# check if queue is empty
def isEmpty(self):
return not self.head
# traverse all elements in queue
def traverse(self):
elements = []
curr = self.head
while curr:
elements.append(curr.getData())
curr = curr.getNext()
return elements
# this to reverse the list
def reverse(self):
"""
:return: void, doesn't return anything it reverse list in-place
"""
current = self.head
prev = None
nex = current.getNext()
while current:
current.setNext(prev)
prev = current
current = nex
if nex:
nex = nex.getNext()
self.head = prev
# this to find the size of queue
def size(self):
"""
:rtype: return the length of list
"""
current = self.head
count = 0
while current:
count += 1
current = current.getNext()
return count
# This to search for specific item and return True if exist False otherwise
def search(self, item):
"""
:type value: item [int, string .. etc]
:rtype: Boolean, return True if item exist otherwise return False
"""
# if not isinstance(item, Node):
# item = Node(item)
current = self.head
while current:
if current.getData() == item:
return True
current = current.getNext()
return False
def push(self, data):
new_node = Node(data)
new_node.setNext(self.head)
self.head = new_node
class Stack:
def __init__(self):
self._min = None
self.head = None
def push(self, data):
if self._min and (self._min.getData() < data):
old_min = self._min
self._min = Node ( self._min.getData() )
self._min.setNext( old_min )
else:
old_min = self._min
self._min = Node ( data )
self._min.setNext( old_min )
old_h = self.head
self.head = Node ( data )
self.head.setNext( old_h )
def pop(self):
if not self.head:
return "Stack is already empty!"
self._min = self._min.getNext()
item = self.head.getData()
self.head = self.head.getNext()
return item
def min(self):
if not self._min:
return None
return self._min.getData()