def _multiplyWithSingleDigit(the_list: LinkedList, num: int) -> LinkedList:
if num == 0:
return LinkedList(Node(0))
else:
result = LinkedList()
node_pointer = the_list.head_node
tmp = node_pointer.getData() * num
result.app_end(Node(tmp % 10))
if tmp > 9:
carry = tmp // 10
else:
carry = 0
node_pointer = node_pointer.getNextNode()
while True:
if not node_pointer:
if carry > 0:
result.app_end(Node(carry))
break
else:
tmp = node_pointer.getData() * num + carry
result.app_end(Node(tmp % 10))
if tmp > 9:
carry = tmp // 10
else:
carry = 0
if node_pointer:
node_pointer = node_pointer.getNextNode()
return result
def _fullAdder(node_pointer1: Node, node_pointer2: Node, carry: int, result_list: LinkedList) -> int:
summary = 0
if node_pointer1:
summary += node_pointer1.getData()
if node_pointer2:
summary += node_pointer2.getData()
summary += carry
result_list.app_end(Node(summary % 10))
if summary > 9:
carry = 1
else:
carry = 0
return carry
def getFragment(my_linked_list: LinkedList, index1: int, index2: int) -> LinkedList:
if not my_linked_list.is_empty():
if index1 == index2:
return LinkedList(Node(my_linked_list.getNode(index1).getData()))
if index2 < index1:
index1, index2 = index2, index1
node_pointer = my_linked_list.getNode(index1)
fragment = LinkedList()
while node_pointer is not my_linked_list.getNode(index2):
fragment.app_end(Node(node_pointer.getData()))
if node_pointer is my_linked_list.getNode(index2):
break
node_pointer = node_pointer.getNextNode()
fragment.app_end(Node(node_pointer.getData()))
return fragment
else:
return LinkedList()
def quickSort(my_linked_list, index_left, index_right):
if index_left >= index_right:
return
node_pointer = my_linked_list.getNode(index_left)
mid_node = Node(node_pointer.getData())
left = index_left
right = index_right
while left < right:
while my_linked_list.getNode(right).getData() >= mid_node.getData() and left < right:
right -= 1
if left < right:
changeNode(my_linked_list, left, right)
else:
break
while my_linked_list.getNode(left).getData() < mid_node.getData() and left < right:
left += 1
if left == right:
mid_node = node_pointer
if left < right:
changeNode(my_linked_list, left, right)
else:
break
if my_linked_list.getNode(left) is my_linked_list.head_node:
my_linked_list.pop(0)
my_linked_list.app_start(mid_node)
my_linked_list.head_node = mid_node
elif my_linked_list.getNode(left) is my_linked_list.last_node:
my_linked_list.pop(-1)
my_linked_list.app_end(mid_node)
my_linked_list.last_node = mid_node
else:
my_linked_list.pop(left)
my_linked_list.insert(left, mid_node)
if index_left < index_right:
quickSort(my_linked_list, index_left, left - 1)
quickSort(my_linked_list, left + 1, index_right)
def multiplyLinkedList(the_list1: LinkedList, the_list2: LinkedList) -> LinkedList:
if the_list1.length() < the_list2.length():
my_list1 = the_list2
my_list2 = getFragment(the_list1, 0, the_list1.length() - 1)
else:
my_list1 = the_list1
my_list2 = getFragment(the_list2, 0, the_list2.length() - 1)
node_pointer2 = my_list2.head_node
result = _multiplyWithSingleDigit(my_list1, node_pointer2.getData())
index = 0
while node_pointer2.getNextNode():
node_pointer2 = node_pointer2.getNextNode()
index += 1
temp = _multiplyWithSingleDigit(my_list1, node_pointer2.getData())
for i in range(0, index):
temp.app_start(Node(0))
result = plusLinkedList(result, temp)
return result
def initializeLinkedList(num=0):
linked_list = LinkedList()
for i in range(0, num):
linked_list.app_end(Node(random.randint(0, num)))
return linked_list
def initList(nodes: List[int] or None):
linked_list = LinkedList()
for node in nodes:
linked_list.app_end(Node(node))
return linked_list
def __init__(self, node: Node or None):
self.init = node
self.cur = node
def getCur(self):
return self.cur
def __iter__(self):
return self
def __next__(self):
tmp = self.cur
if tmp:
self.cur = self.cur.getNextNode()
return tmp
self.cur = self.init
raise StopIteration
if __name__ == "__main__":
nodes1 = [10, 6, 9, 1, 3, 7]
l1 = LinkedList()
for num in nodes1:
l1.app_end(Node(num))
print(l1)
print(l1.getNode(2))
print(l1.getNode(3))
print(l1.getIndex(Node(1)))
for mem in l1:
print(mem)
print("# head")
if self.is_empty():
print("# end")
else:
node_pointer = self.head_node
count = 1
while node_pointer is not None:
print("#{0}: {1}".format(count, node_pointer))
node_pointer = node_pointer.getNextNode()
count += 1
print("# end")
print("------------------------")
if __name__ == "__main__":
node1 = Node(15)
node2 = Node(7)
node3 = Node(22)
node4 = Node(30)
node5 = Node(88)
node6 = Node(94)
queue = myQueue(node1)
queue.app(node2)
queue.app(node3)
queue.app(node4)
queue.app(node5)
queue.app(node6)
queue.printAll()
print(queue.getNode(1), queue.getNode(3))
queue.pop()
queue.pop()
print("whole stack:", end=" ")
print(self)
print("node's number = {0}".format(self.length()))
print("nodes:")
print("# head")
if self.is_empty():
print("# end")
else:
node_pointer = self.head_node
count = 1
while node_pointer is not None:
print("#{0}: {1}".format(count, node_pointer))
node_pointer = node_pointer.getNextNode()
count += 1
print("# end")
print("------------------------")
if __name__ == "__main__":
stack1 = myStack()
stack2 = myStack()
for i in range(0, 30):
stack1.push(Node(random.randint(0, 50)))
print(stack1)
sleep(0.5)
for j in range(0, 30):
stack2.push(stack1.pop())
print(stack1)
sleep(0.5)
stack2.printAll()