a new method, _delete_subtree(p), that removes the entire subtree rooted at position p, making sure to maintain the count on the size of the tree. What is the running time of your implementation? _delete_subtree (p) function with root at position p in a binary tree deletes an entire sub-tree, and updates the total number of nodes in the tree. Deleted nodes belonging to the subtree are set as an (array) "array" to be used again later. In accordance with the binary-tree data structure, a list type variable that is a member of the LinkedBinaryTree class (_store_deleted_subtree) is stored by appending (append). Write _delete_subtree (p) function member to LinkedBinaryTree class structure. It What is the experimental and theoretical working time of the function, calculate and (discuss) explain it. and i can use these python code

Implement a new method, _delete_subtree(p), that removes the entire subtree rooted at position p, making sure to maintain the count on the size of the tree. What is the running time of your implementation?

_delete_subtree (p) function with root at position p in a binary tree
deletes an entire sub-tree, and updates the total number of nodes in the tree. Deleted
nodes belonging to the subtree are set as an (array) "array" to be used again later.
In accordance with the binary-tree data structure, a list type variable that is a member of the LinkedBinaryTree class
(_store_deleted_subtree) is stored by appending (append).
Write _delete_subtree (p) function member to LinkedBinaryTree class structure. It
What is the experimental and theoretical working time of the function, calculate and (discuss) explain it.

and i can use these python code

class LinkedBinaryTree(BinaryTree):
"""Linked representation of a binary tree structure."""

#-------------------------- nested _Node class --------------------------
class _Node:
"""Lightweight, nonpublic class for storing a node."""
__slots__ = '_element', '_parent', '_left', '_right' # streamline memory usage

def __init__(self, element, parent=None, left=None, right=None):
self._element = element
self._parent = parent
self._left = left
self._right = right

#-------------------------- nested Position class --------------------------
class Position(BinaryTree.Position):
"""An abstraction representing the location of a single element."""

def __init__(self, container, node):
"""Constructor should not be invoked by user."""
self._container = container
self._node = node

def element(self):
"""Return the element stored at this Position."""
return self._node._element

def __eq__(self, other):
"""Return True if other is a Position representing the same location."""
return type(other) is type(self) and other._node is self._node

#------------------------------- utility methods -------------------------------
def _validate(self, p):
"""Return associated node, if position is valid."""
if not isinstance(p, self.Position):
raise TypeError('p must be proper Position type')
if p._container is not self:
raise ValueError('p does not belong to this container')
if p._node._parent is p._node: # convention for deprecated nodes
raise ValueError('p is no longer valid')
return p._node

def _make_position(self, node):
"""Return Position instance for given node (or None if no node)."""
return self.Position(self, node) if node is not None else None

#-------------------------- binary tree constructor --------------------------
def __init__(self):
"""Create an initially empty binary tree."""
self._root = None
self._size = 0

#-------------------------- public accessors --------------------------
def __len__(self):
"""Return the total number of elements in the tree."""
return self._size
  
def root(self):
"""Return the root Position of the tree (or None if tree is empty)."""
return self._make_position(self._root)

def parent(self, p):
"""Return the Position of p's parent (or None if p is root)."""
node = self._validate(p)
return self._make_position(node._parent)

def left(self, p):
"""Return the Position of p's left child (or None if no left child)."""
node = self._validate(p)
return self._make_position(node._left)

def right(self, p):
"""Return the Position of p's right child (or None if no right child)."""
node = self._validate(p)
return self._make_position(node._right)

def num_children(self, p):
"""Return the number of children of Position p."""
node = self._validate(p)
count = 0
if node._left is not None: # left child exists
count += 1
if node._right is not None: # right child exists
count += 1
return count

#-------------------------- nonpublic mutators --------------------------
def _add_root(self, e):
"""Place element e at the root of an empty tree and return new Position.

Raise ValueError if tree nonempty.

  
def _attach(self, p, t1, t2):
"""Attach trees t1 and t2, respectively, as the left and right subtrees of the external Position p.

As a side effect, set t1 and t2 to empty.
Raise TypeError if trees t1 and t2 do not match type of this tree.
Raise ValueError if Position p is invalid or not external.
"""
node = self._validate(p)
if not self.is_leaf(p):
raise ValueError('position must be leaf')
if not type(self) is type(t1) is type(t2): # all 3 trees must be same type
raise TypeError('Tree types must match')
self._size += len(t1) + len(t2)
if not t1.is_empty(): # attached t1 as left subtree of node
t1._root._parent = node
node._left = t1._root
t1._root = None # set t1 instance to empty
t1._size = 0
if not t2.is_empty(): # attached t2 as right subtree of node
t2._root._parent = node
node._right = t2._root
t2._root = None # set t2 instance to empty
t2._size = 0

please help me