168 lines
3.9 KiB
Python
168 lines
3.9 KiB
Python
from dataclasses import dataclass
|
|
from typing import Any, Union
|
|
|
|
|
|
@dataclass
|
|
class Node:
|
|
value: Any
|
|
next: 'Node' = None
|
|
prev: 'Node' = None
|
|
|
|
|
|
class Stack:
|
|
_tail: Node = None
|
|
size: int = 0
|
|
|
|
def push(self, obj: Any):
|
|
self._tail = Node(obj, self._tail)
|
|
self.size += 1
|
|
|
|
def pop(self) -> Any:
|
|
if self._tail is None:
|
|
raise ValueError('No more objects on stack')
|
|
|
|
res = self._tail.value
|
|
self._tail = self._tail.next
|
|
self.size -= 1
|
|
return res
|
|
|
|
def peek(self) -> Any:
|
|
if self._tail is None:
|
|
raise ValueError('No more objects on stack')
|
|
|
|
return self._tail.value
|
|
|
|
def __contains__(self, obj: Any) -> bool:
|
|
x = self._tail
|
|
while x.value != obj and x.next is not None:
|
|
x = x.next
|
|
|
|
return x.value == obj
|
|
|
|
|
|
class Queue:
|
|
pass
|
|
|
|
|
|
class LinkedList:
|
|
_head: Union[Node, None] = None
|
|
_tail: Union[Node, None] = None
|
|
size: int = 0
|
|
|
|
def _append(self, obj: Any):
|
|
node = Node(obj)
|
|
if self._head is None:
|
|
self._head = node
|
|
|
|
if self._tail is None:
|
|
self._tail = node
|
|
else:
|
|
self._tail.next = node
|
|
node.prev = self._tail
|
|
self._tail = node
|
|
|
|
self.size += 1
|
|
|
|
def _insert(self, index: int, obj: Any):
|
|
i_node = Node(obj)
|
|
node = self._get_node(index)
|
|
|
|
i_node.prev, i_node.next = node.prev, node
|
|
node.prev = i_node
|
|
if node.prev is not None:
|
|
node.prev.next = i_node
|
|
|
|
if index == 0:
|
|
self._head = i_node
|
|
|
|
if index == self.size - 1:
|
|
self._tail = i_node
|
|
|
|
self.size += 1
|
|
|
|
def _get_node(self, index: int) -> Node:
|
|
if abs(index) >= self.size:
|
|
raise IndexError("index out of bounds")
|
|
|
|
if index < 0:
|
|
index = self.size + index
|
|
|
|
if index <= self.size // 2:
|
|
x = 0
|
|
node = self._head
|
|
while x < index:
|
|
x += 1
|
|
node = node.next
|
|
else:
|
|
x = self.size - 1
|
|
node = self._tail
|
|
while x > index:
|
|
x -= 1
|
|
node = node.prev
|
|
|
|
return node
|
|
|
|
def _get(self, index: int) -> Any:
|
|
return self._get_node(index).value
|
|
|
|
def _pop(self, index: int = None) -> Any:
|
|
if self.size == 0:
|
|
raise IndexError("pop from empty list")
|
|
|
|
if index is None: # pop from the tail
|
|
node = self._tail
|
|
if self.size > 1:
|
|
self._tail = self._tail.prev
|
|
self._tail.next = None
|
|
else:
|
|
self._head = None
|
|
self._tail = None
|
|
|
|
ret = node.value
|
|
elif index == 0: # pop from the head
|
|
node = self._head
|
|
if self.size > 1:
|
|
self._head = self._head.next
|
|
self._head.prev = None
|
|
else:
|
|
self._head = None
|
|
self._tail = None
|
|
|
|
ret = node.value
|
|
else:
|
|
node = self._get_node(index)
|
|
if node.prev is not None:
|
|
node.prev.next = node.next
|
|
if node.next is not None:
|
|
node.next.prev = node.prev
|
|
node.prev = None
|
|
node.next = None
|
|
ret = node.value
|
|
|
|
self.size -= 1
|
|
return ret
|
|
|
|
def append(self, obj: Any):
|
|
self._append(obj)
|
|
|
|
def insert(self, index: int, obj: Any):
|
|
self._insert(index, obj)
|
|
|
|
def get(self, index: int) -> Any:
|
|
return self._get(index)
|
|
|
|
def pop(self, index: int = None) -> Any:
|
|
return self._pop(index)
|
|
|
|
def debug(self):
|
|
print("head:", self._head)
|
|
print("tail:", self._tail)
|
|
if self.size > 0:
|
|
x = 0
|
|
o = self._head
|
|
print(x, o.value)
|
|
while o.next is not None:
|
|
x += 1
|
|
o = o.next
|
|
print(x, o.value)
|