def __init__(self, iterable=[]):
"""
attributes:
length--> length of the doubly linked list
head--> starting node of the doubly linked list
"""
self.head = None
self.end = None
self.length = 0
self.iter = None
#Checking if argument is iterable or not
try:
iter(iterable)
except TypeError:
error.error_message(
"TypeError",
"__init__(): Argument passed is not an iterable. Empty DLL created"
)
return
for iterator in iterable:
if isinstance(iterable, doublyLinkedList):
iterator = iterator.data
if self.length == 0:
self.head = Node.Node(iterator)
self.end = self.head
else:
self.end.next = Node.Node(iterator)
self.end.next.prev = self.end
self.end = self.end.next
self.length += 1
def remove_all(self, ele):
"""
Removes all the occurences of Element.
"""
try:
if self.length == 0:
raise ValueError
except ValueError:
error.error_message("ValueError", "remove_all(ele): empty DLL")
presentFlag = False
iter = self.head
for i in range(self.length):
if iter.data == ele:
self._remove_node(iter)
presentFlag = True
iter = iter.next
try:
if presentFlag is False:
raise ValueError
else:
pass
except ValueError:
error.error_message(
"ValueError", "remove_all(ele): Element not found in the DLL")
return
def insort(self, ele, sortCheck=True):
"""
If DLL is sorted, insert ele such that it remains sorted.
"""
#Checking if the DLL is sorted
if sortCheck:
try:
if self.issorted() is False:
raise ValueError
else:
pass
except ValueError:
error.error_message("ValueError",
"insort(ele): Self DLL is not sorted")
return
else:
pass
iterable = self.head
while iterable:
if iterable.data > ele:
break
iterable = iterable.next
self._insert_before_node(iterable, Node.Node(ele))
return
def remove(self, ele):
"""
Removes the first occurence of the element
"""
try:
if self.head is None:
raise IndexError
else:
pass
except IndexError:
error.error_message("IndexError", "remove(ele): empty DLL")
return
self.end.next = Node.Node(ele)
iter = self.head
while iter.data != ele:
iter = iter.next
try:
if self.end.next == iter:
raise ValueError
else:
pass
except ValueError:
error.error_message("ValueError",
"remove(ele): Element not found in the DLL")
self.end.next = None
return
self.end.next = None
self._remove_node(iter)
return
def remove_last(self, ele):
"""
Removes the last occurence of element.
"""
try:
if self.length == 0:
raise IndexError
else:
pass
except IndexError:
error.error_message("IndexError", "remove_last(ele): empty DLL")
iter = self.end
self.head.prev = Node.Node(ele)
while iter.data != ele:
iter = iter.prev
try:
if iter == self.head.prev:
raise ValueError
else:
pass
except ValueError:
error.error_message(
"ValueError", "remove_last(ele): Element not found in the DLL")
self.head.prev = None
return
self.head.prev = None
self._remove_node(iter)
return
def insert(self, ele, index=0):
"""
Inserts ele at specified index. Float value of index will be floored.
If index is not specified, inserts at the head. Indexing starts from 0.
Returns NoneType
"""
try:
index = int(index)
except ValueError:
error.error_message(
"ValueError",
"insert(ele,index): Index should be of type int or float")
return
if self.head is None:
self.head = Node.Node(ele)
self.end = self.head
self.length += 1
else:
index = min(index, self.length)
index = index + self.length if index < 0 else index
index = max(0, index)
node = Node.Node(ele)
iter = self.head
while index > 0:
iter = iter.next
index -= 1
self._insert_before_node(iter, node)
return
def delete(self, index):
"""
Deletes element at index passed as an argument. Index must not exceed the length limits.
returns NoneType
"""
try:
index = int(index)
if index >= self.length or index < self.length * -1:
raise IndexError
except ValueError:
error.error_message("ValueError",
"delete(index): index must be int or float")
return
except IndexError:
error.error_message(
"IndexError", "delete(index): index must be within [-len,len)")
return
index = index + self.length if index < 0 else index
iter = self.head
while index > 0:
iter = iter.next
index -= 1
self._remove_node(iter)
return
def __init__(self, size):
"""
attributes:
size -> Max size of the stack before stack overflow.
"""
self.__stack = []
try:
self.__max_size = int(size)
except ValueError:
error.error_message("TypeError",
"__init__(): Size argument passed invalid")
def __init__(self, size):
"""
attributes:
size -> Max size of the queue
"""
try:
self.__max_size = int(size)
except ValueError:
error.error_message("TypeError",
"__init__(): Size argument passed invalid")
return
self.__queue = deque(maxlen=self.__max_size)
def pop(self):
"""
Deletes the last element in the DLL and returns it.
"""
try:
if self.length == 0:
raise IndexError
else:
pass
except:
error.error_message("IndexError", "pop(): empty DLL")
val = self.end.data
self.delete(-1)
return val
def read_line(file_name, line):
"""
Read a particular line in a file
:param file_name: Name of file
:param line: Line Number
:return: Data string in that line
"""
try:
with open(file_name) as f:
for i, data in enumerate(f):
if i + 1 == line:
return data
return error_message("LineError",
"read_line(): Invalid line number")
except FileNotFoundError:
return error_message("FileNotFoundError",
"file_len(): Invalid file name")
def peek(self):
"""
Peek an element without actually removing it from the queue
:return: The element at the front of the queue
"""
if self.__empty():
return error.error_message("Underflow Error",
"peek(): queue empty, cannot peek")
return self.__queue[0]
def extend(self, iterable):
"""
Extends the iterable's elements to the DLL.
Iterable need not be a DLL.
Returns NoneType
"""
try:
iter(iterable)
except TypeError:
error.error_message("TypeError",
"Argument passed is not an iterable")
return
for i in iterable:
if isinstance(iterable, doublyLinkedList):
i = i.data
self.push(i)
return
def peek(self):
"""
Peeks at the element at the top of the stack. It doesn't remove the element
:return: Element
"""
try:
return self.__stack[-1]
except IndexError:
return error.error_message("Underflow Error",
"peek(): stack empty, cannot peek")
def deque(self):
"""
Removes an element from the front of the queue
:return: Element removed
"""
if self.__empty():
return error.error_message(
"Underflow Error",
"dequeue(): queue empty, cannot remove element")
return self.__queue.popleft()
def pop(self):
"""
Pop an element from the top of the stack
:return: Element
"""
try:
return self.__stack.pop()
except IndexError:
return error.error_message("Underflow Error",
"pop(): stack empty, cannot pop")
def __add__(self, dll):
"""
Addition of two dll gives an concatenated dll. Returns a dll.
"""
try:
if isinstance(dll, doublyLinkedList) is False:
raise TypeError
else:
pass
except:
error.error_message(
"TypeError", "__add__(dll): cannot concatenate " +
str(type(dll)) + " to a DLL")
return
new_dll = doublyLinkedList(self)
for i in dll:
new_dll.push(i.data)
return new_dll
def random_number_generator(lower_limit, upper_limit):
"""
Generates a random number between the lower and upper limit
:param lower_limit
:param upper_limit
:return: Generated random number
"""
try:
return randint(lower_limit, upper_limit)
except ValueError:
return error_message("LimitError", "random_number_generator(): Range argument passed invalid")
def push(self, element):
"""
Pushes element to the top of the stack
:param element: Element to be pushed on the top of the stack
:return: None
"""
if len(self.__stack) == self.__max_size:
return error.error_message(
"Overflow Error",
"push(): stack full, cannot push {}".format(element))
self.__stack.append(element)
def enqueue(self, element):
"""
Inserts element to the rear of the queue
:param element: Element to be inserted
:return: None
"""
if self.__full():
return error.error_message(
"Overflow Error",
"enqueue(): stack full, cannot insert {}".format(element))
self.__queue.append(element)
def file_len(file_name):
"""
Count number of files in a line
:param file_name: Name of file
:return: Number of lines -> int
"""
try:
with open(file_name) as f:
for i, line in enumerate(f):
pass
return i + 1
except FileNotFoundError:
return error_message("FileNotFoundError",
"file_len(): Invalid file name")
def merge_sort(self, iterable):
"""
If a sorted iterable is passed, then the values are added to the present DLL in such a way
that resulting DLL is also sorted.
"""
try:
iter(iterable)
except TypeError:
error.error_message(
"TypeError",
"merge_sort(iterable): Argument passed is not an iterable")
return
#Checking if the argument is sorted
new_dll = doublyLinkedList(iterable)
try:
if new_dll.issorted() is False:
raise ValueError
else:
pass
except ValueError:
error.error_message(
"ValueError",
"merge_sort(iterable): Iterable passed should be sorted")
return
#Checking if the DLL is sorted
try:
if self.issorted() is False:
raise ValueError
else:
pass
except ValueError:
error.error_message(
"ValueError", "merge_sort(iterable): Self DLL is not sorted")
return
iterator = self.head
while iterator and new_dll.length != 0:
dll_data = new_dll.head.data
iterdata = iterator.data
if dll_data < iterdata:
new_node = Node.Node(dll_data)
self._insert_before_node(iterator, new_node)
new_dll.delete(0)
else:
iterator = iterator.next
if iterator is None and new_dll.length != 0:
print(type(new_dll.head.data))
self.extend(new_dll)
return
