題目要求： You must complete and implement the following functions in Recursion.py. Take note of the specified return values and input parameters. Do not change the function signatures.

In addition to the Mimir testing, you will also be graded on the run time performance of your functions. See below what is expected for each function.

insert(value, node=None) Insert the given value into the linked list that has head node The value should be inserted such that the list remains in ascending order Return the starting node of the linked list Worst case: O(n) string(node) Generate and return a string representation of the list, starting at node The values should be separated by a comma and a single space, with no leading or trailing comma Worst case: O(n) reversed_string(node) Generate and return a string representation of the list with head node, in reverse order The values should be separated by a comma and a single space, with no leading or trailing comma Worst case: O(n) remove(value, node) Remove the first node in the list with the given value starting at head node Return the starting node of the linked list Worst case: O(n) remove_all(value, node) Remove all nodes in the list with the given value starting at head node Return the starting node of the linked list Worst case: O(n) search(value, node) Looks for value in list starting with head node Returns True if the value is in the list and False if it is not in the list Worst case: O(n) length(node) Calculates and returns the length of the list starting with head node Worst case: O(n) sum_all(node) Calculates and returns the sum of the list starting with head node Worst case: O(n) count(value, node) Counts how many times the given value occurs in the list starting at head node Worst case: O(n)

class LinkedNode:
    # DO NOT MODIFY THIS CLASS #
    __slots__ = 'value', 'next_node'

    def __init__(self, value, next_node):
        """
        DO NOT EDIT
        Initialize a node
        :param value: value of the node
        :param next_node: pointer to the next node
        """
        self.
 
value = value  # element at the node
        self.next_node = next_node  # reference to next node

    def __str__(self):
        """
        DO NOT EDIT
        String representation of a node
        :return: string of value
        """
        return str(self.value)

    __repr__ = __str__

from LinkedNode import LinkedNode


def insert(value, node=None):
    """
    Insert the given value into the linked list that has head node
    :param value: value to insert
    :param node: head node for the the remaining list
    :return: head node
    """
    if node:
        if node.value >= value:
            node = LinkedNode(value, node)
        elif node.next_node:
            if node.next_node.value >= value:
                tmp = LinkedNode(value, node.next_node)
                node.next_node = tmp
            else:
                # Recursively find the nodes that meet the criteria
                insert(value, node.next_node)
        else:
            tmp = LinkedNode(value, None)
            node.next_node = tmp
    else:
        node = LinkedNode(value, None)
        return node
    return node


def string(node):
    """
    Generate and return a string representation of the list, starting at node
    :param node: head node for the the remaining list
    :return: string of all nodes
    """
    if node:
        if node.next_node:
            tmp_words = string(node.next_node)
            # Composite string
            return str(node.value) + ', ' + tmp_words
        else:
            return str(node.value)
    else:
        return ''


def reversed_string(node):
    """
    Generate and return a string representation of the list with head node, in reverse order
    :param node: head node for the the remaining list
    :return: string of all nodes in reverse order
    """
    if node:
        if node.next_node:
            tmp_words = reversed_string(node.next_node)
            # Composite string
            return tmp_words + ', ' + str(node.value)
        else:
            return str(node.value)
    else:
        return ''


def remove(value, node):
    """
    Remove the first node in the list with the given value starting at head node
    :param value:
    :param node: head node for the the remaining list
    :return: head node
    """
    if node:
        if node.value == value:
            if node.next_node:
                node.value = node.next_node.value
                node.next_node = node.next_node.next_node
            else:
                return None
        elif node.next_node:
            if node.next_node.value == value:
                node.next_node = node.next_node.next_node
            else:
                # Recursively find the value to delete
                remove(value, node.next_node)
        return node
    else:
        return None


def remove_all(value, node):
    """
    Remove all nodes in the list with the given value starting at head node
    :param value:
    :param node: head node for the the remaining list
    :return: head node
    """
    if node:
        if node.value == value:
            if node.next_node:
                node.value = node.next_node.value
                node.next_node = node.next_node.next_node
                remove_all(value, node)
                if node.next_node:
                    remove_all(value, node.next_node)
            else:
                return None
        elif node.next_node:
            if node.next_node.value == value:
                if node.next_node.next_node:
                    node.next_node = node.next_node.next_node
                else:
                    node.next_node = None
                # Recursively the remained nodes to find the value to delete
                remove_all(value, node)
            # Recursively the remained nodes to find the value to delete
            remove_all(value, node.next_node)
        return node
    return None


def search(value, node):
    """
    Looks for value in list starting with head node
    :param value:
    :param node: head node for the the remaining list
    :return: Return True if have the value in LinkList or return False
    """
    if node:
        if node.value == value:
            return True
        else:
            # Recursively look for the remaining nodes and find the matching nodes
            return search(value, node.next_node)
    else:
        return False


def length(node):
    """
    Calculates and returns the length of the list starting with head node
    :param node: head node for the the remaining list
    :return: The length of the LinkList
    """
    if node:
        # The length is computed recursively and each new node is incremented by 1
        return length(node.next_node) + 1
    else:
        return 0


def sum_all(node):
    """
    Calculates and returns the sum of the list starting with head node
    :param node: head node for the the remaining list
    :return: The sum value
    """
    if node:
        # The value is computed recursively and each new node is incremented by its value
        return sum_all(node.next_node) + node.value
    else:
        return 0


def count(value, node):
    """
    Counts how many times the given value occurs in the list starting at head node
    :param value:
    :param node: head node for the the remaining list
    :return: the number of nodes who's value is the value searched
    """
    if node:
        if node.value == value:
            # add 1 if the node is needed
            return count(value, node.next_node) + 1
        else:
            # Recurse to the next node
            return count(value, node.next_node)
    else:
        return 0