def add(self, data):
newNode = Node(data)
if self.isEmpty():
self.__head = newNode
else:
newNode.setNext(self.__head)
self.__head.setPrev(newNode)
self.__head = newNode
def append(self, data):
newNode = Node(data)
if self.isEmpty():
self.__head = newNode
else:
currentHead = self.__head
while currentHead.getNext() is not None:
currentHead = currentHead.getNext()
currentHead.setNext(newNode)
newNode.setPrev(currentHead)
def insert(self, toAdd):
#Setting variables
key = toAdd.key
objectToAdd = toAdd.myObject
#If hash is bigger than allowed max_size, modulo it
if self.hash(key) > self.max_size:
newToAdd = MapObject(key % self.max_size, objectToAdd)
return insert(newToAdd)
#Separate chaining
if self.myType == 3:
if self.v[self.hash(key)] == None:
l = List()
node = Node(toAdd)
l.append(node)
else:
l = self.v[self.hash(key)]
node = Node(toAdd)
l.append(node)
self.v[self.hash(key)] = l
return True
#Probing
if self.v[self.hash(key)] != None:
i = self.hash(key)
#Linear probing
if self.myType == 1:
while (self.v[i] != None):
i += 1
self.v[i] = toAdd
#Quadratic probing
if self.myType == 2:
while (self.v[i] != None):
i += 1
i = i**2 % self.max_size
self.v[i] = toAdd
return True
#No probing or chaining needed, normal insert
self.v[self.hash(key)] = toAdd
return True
def enqueue(self, data):
new_node = Node(data)
if self.isEmpty(): # no data present
self.frontPtr = new_node
self.backPtr = self.frontPtr
else: # some nodes exists
self.backPtr.setNext(new_node)
self.backPtr = new_node
def append(self, data):
new_node = Node(data)
if self.head is None: # no data present
self.head = new_node
self.tail = self.head
else: # data present
new_node.setPrev(self.tail)
self.tail.setNext(new_node)
self.tail = new_node
def append(self, data):
newNode = Node(data)
if self.isEmpty():
self.add(data)
else:
newNode.setNext(self.__head)
# head的前驱就是链表尾部
newNode.setPrev(self.__head.getPrev())
self.__head.getPrev().setNext(newNode)
self.__head.setPrev(newNode)
def insert(self, index, item):
length = self.getLength()
if index < 0 or index > length:
return False
elif index == length:
self.append(item)
return True
elif index == 0:
self.__insertFront(item)
return True
new_node = Node(item)
count = 0
current_node = self.head
while count != index:
count += 1
current_node = current_node.getNext()
parent = current_node.prev
parent.next = new_node
new_node.prev = parent
new_node.next = current_node
current_node.prev = new_node
return True
def insert(self, data, pos=0):
if pos <= 0:
self.add(data)
elif pos > self.size() - 1:
self.append(data)
else:
newNode = Node(data)
preHead = self.__head
count = 0
# preHead指向指定位置前一个位置pos-1
while count < pos - 1:
count += 1
preHead = preHead.getNext()
newNode.setPrev(preHead)
newNode.setNext(preHead.getNext())
preHead.getNext().setPrev(newNode)
preHead.setNext(newNode)
def createList(self, data):
new_node = Node(data)
self.head = new_node
self.tail = self.head
def __insertFront(self, data):
new_node = Node(data)
new_node.setNext(self.head)
self.head.setPrev(new_node)
self.head = new_node