Question

Finish each function
python 3

LList.py

class node(object):

""" A version of the Node class with public attributes.

This makes the use of node objects a bit more convenient for

implementing LList class.

  

Since there are no setters and getters, we use the attributes directly.

  

This is safe because the node class is defined in this module.

No one else will use this version of the class.
'''

def __init__(self, data, next=None):
"""
Create a new node for the given data.
Pre-conditions:
data: Any data value to be stored in the node
next: Another node (or None, by default)
"""
self.data = data
self.next = next
  
# Note: use the attributes directly; no setters or getters!

class LList(object):
def __init__(self):
"""
Purpose
creates an empty list
"""
self._size = 0 # how many elements in the stack
self._head = None # the node chain starts here; initially empty
self._tail = None # the last node in the node chain; initially empty

############
def retrieve_data_at_index(self,idx):
"""
Purpose
Return the value stored at the index idx
Preconditions:
:param idx: a non-negative integer
Post-conditions:
none
Return:
:return (True, val) if val is stored at index idx and idx is valid
:return (False, None) if the idx is not valid for the list
"""
pass

######
def set_data_at_index(self, idx, val):
"""
Purpose
Store val into alist at the index idx
Preconditions:
:param val: a value of any kind
:param idx: a non-negative integer
Post-conditions:
The value stored at index idx changes to val
Return:
:return True if the index was valid, False otherwise
"""
pass

############
def insert_value_at_index(self, val, idx):
"""
Purpose
Insert val into alist at index idx
Preconditions:
:param val: a value of any kind
:param idx: a valid index for the list
Post-conditions:
The list increases in size.
The new value is at index idx.
The values previously in the list at idx or later appear after the new value.
Return:
:return If the index is valid, insert_value_at_index returns True.
:return If the index is not valid, insert_value_at_index returns False.
"""
pass

############
def delete_item_at_index(self, idx):
"""
Purpose
Delete the value at given index .
Preconditions:
:param idx: a non-negative integer
Post-conditions:
The list decreases in size if the index is valid
The value at idx is no longer in the list.
Return:
:return True if index was valid, False otherwise
"""
pass

Answer 1

Code:

class node(object):
    def __init__(self, data, next=None):
    """
    Create a new node for the given data.
    Pre-conditions:
    data: Any data value to be stored in the node
    next: Another node (or None, by default)
    """
        self.data = data
        self.next = next
      
    # Note: use the attributes directly; no setters or getters!

class LList(object):
    
    def __init__(self):
    """
    Purpose
    creates an empty list
    """
        self._size = 0 # how many elements in the stack
        self._head = None # the node chain starts here; initially empty
        self._tail = None # the last node in the node chain; initially empty

    ############
    def retrieve_data_at_index(self,idx):
    """
    Purpose
    Return the value stored at the index idx
    Preconditions:
    :param idx: a non-negative integer
    Post-conditions:
    none
    Return:
    :return (True, val) if val is stored at index idx and idx is valid
    :return (False, None) if the idx is not valid for the list
    """
        if not 0<=idx<self._size:
            return (False, None)
        itr = self._head
        for i in range(idx):
            itr = itr.next
        val = itr.data
        return (True, val)

    ######
    def set_data_at_index(self, idx, val):
    """
    Purpose
    Store val into alist at the index idx
    Preconditions:
    :param val: a value of any kind
    :param idx: a non-negative integer
    Post-conditions:
    The value stored at index idx changes to val
    Return:
    :return True if the index was valid, False otherwise
    """
        if not 0<=id<self._size:
            return False
        itr = self._head
        for i in range(idx):
            itr = itr.next
        itr.data = val
        return True
    
    ############
    def insert_value_at_index(self, val, idx):
    """
    Purpose
    Insert val into alist at index idx
    Preconditions:
    :param val: a value of any kind
    :param idx: a valid index for the list
    Post-conditions:
    The list increases in size.
    The new value is at index idx.
    The values previously in the list at idx or later appear after the new value.
    Return:
    :return If the index is valid, insert_value_at_index returns True.
    :return If the index is not valid, insert_value_at_index returns False.
    """
        if not 0<=idx<self._size:
            return False
        if idx==0:
            tmp = self._head
            self._head = node(val, tmp)
            self._size += 1
            return True
        itr = self._head
        for i in range(idx-1):
            itr = itr.next
        tmp = node(val, itr.next)
        itr.next = tmp
        self._size += 1
        return True
    

    ############
    def delete_item_at_index(self, idx):
    """
    Purpose
    Delete the value at given index .
    Preconditions:
    :param idx: a non-negative integer
    Post-conditions:
    The list decreases in size if the index is valid
    The value at idx is no longer in the list.
    Return:
    :return True if index was valid, False otherwise
    """
        if not 0<=idx<self._size:
            return False
        if idx==0:
            tmp = self._head
            self._head = tmp.next
            del tmp
            self._size -= 1
            return True
        itr = self._head
        for i in range(idx-1):
            itr = itr.next
        tmp = itr.next
        itr.next = tmp.next
        del tmp
        if idx == self._size - 1:
            self._last = itr
        self._size -= 1
        return True
    
    def append_item(self, val): #i have added this method extra to make this class complete
        if self._head is None:
            self._head = node(val)
            self._last = self._head
        else:
            self._last = node(val)
        self._size += 1

Code Screenshots:

itr = self._head for i in range (idx-1): itr = itr.next tmp = node (val, itr.next) itr.next = tmp self. size += 1 return True def delete_item_at_index (self, idx): TT TT TI Purpose Delete the value at given index. Preconditions: :param idx: a non-negative integer Post-conditions: The list decreases in size if the index is valid The value at idx is no longer in the list. Return: :return True if index was valid, False otherwise""" if not 0<=idx<self. size: return false if idx==0: tmp = self. head self. head = tmp.next del tmp self. size -= 1 return True itr = self._head for i in range (idx-1): itr = itr.next tmp = itr.next itr.next = tmp.next del tmp if idx == self. size - 1: self. last = itr self._size -= 1 return True def append_item(self, val): #i have added this method extra to make this class complete if self. head is None: self._head = node (val) self. las self._head else: self. last = node (val) self._size += 11 Activate Windows Go to Settings to activate Windows.

As per the given methods I've completed them but LList class isn't completed without append method because using insert we cannot insert elements into an empty list.

Thank you! Hit like if you like my work.