Question

PYTHON 3 node Node ADT Question.

$print (chain1 after: to_string (chain 1)) print (chain2 after:, to_string (chain2 )) print (merged_chain after:\n, to.str$

Question 3 (18 points): Purpose: To practice working with node chains created using the Node ADT to implement slightly harder functionality Degree of Difficulty: Moderate to Tricky In this question you'll implement merge sort for node chains! Recall, merge sort is a divide-and-conquer technique that uses recursion to sort a given sequence (in this case a node chain). A overview of the algorithm is given below. Algorithm mergeSort (NC) Borts node chain NC using merge sort a node chain of data items NC sorted node chain of NC # return nev if NC contains 0 or 1 data items NC return divide = first half of NC NC1 NC2 second half of NC recursively sort NC1 and NC2 mergeSort (NC1) mergeSort (NC2) NC1 NC2 conquer !!! NC merge (NC1, NC2) return NC In order to implement merge sort, you are going to write three functions that will make your job easier. On Moodle, you can find a starter file call ed a5q3. py, with all the functions and doc-strings in place, your job is to write the bodies of the functions. You will also find a test script named a5q3_testing . py. It has a bunch of test cases pre-witten for you. Read it carefully! Use to string) from Q1 to help you test and debug your functions. (a) (5 points) Implement the function aplit_chain (). The interface for the function is: def split chain ( node_chain) : Purpose Splits the given node chain in half, returning the second half. the extra node is part of If the given chain has an odd length, the second half of the chain. Pre-conditiona: param node_chain: a node -chain, possibly empty Post-conditions: the original node chain is cut in half! Return : return: A tuple (nc1, nc2) where nc1 and nc2 are node- chains each containing about half of the nodes in node- chain This function should not create any nodes, and should retum a tuple of references to the two halves of the chain The tricky part of this is only to remember to put a None at the right place. to terminate the original node-chain about half way through A demonstration of the application of the function is as follows chain5 node . create (3 , node. create (1, node. create (4, node. create (1, node. create (5) )) )) print ('chain5 Before: to.string (chain5 )) a, b split. chain ( ch ain 5 ) print ('chain5 After: to_string (a) print ('Second half: tostring (b )) The output from the demonstration is as follows: chain5 Before: [ 3 I]t 1 1--> 4 3 -> 1/ 4 1 | 5I 1 I s/ chain5 After: Second half Notice how the second half of the list is a little bit larger Hint You may use count_chain() from A5Q2, and integer division (b) (5 points) Implement the function merge (). The interface for the function is def merge (nc1, nc2): Purpose: a single Combine the tvo sorted node-chains ncl and nc2 into Borted node- chain. Pre-conditions: : param nc1: a node-chain, possi bly empty. containing values sorted in ascending order. param nc2: a node-ch ain, possi bly empty containing values sorted in ascending order Post-condition: None Return: : return: a sorted node chain (nc) that contains the values from nc1 and nc2. If both node-chains are empty an empty node - chain will be returned This one is tricky. as there are a few special cases A demonstration of the application of the function is as follows no de. create (1. node. create (1 node. create (9))) no de. create (2, node. create (7, node. create ( 15))) print ('chain 1 before : ', to_atring (chain1 ) print ('chain2 before:. to.string (chain2)) merged.chainmerge (chaini, chain 2) chaini chain2 print ('chain1 after: to_string (chain 1)) print ('chain2 after:, to_string (chain2 )) print ('merged_chain after:\n', to.string (mer ged_ chain)) The output from the demonstration is as follows: chaini before: 1 > 1 1 9 chain2 before: [ 2 -] 7 -- 15 I 1 chainl after: 1 -] -> 1 -] >[ 9 /1 chain2 after: 2 --> 7 I--> 15I1 merged_chain after: (11 1-1 2 -] - > 7 1->[91-1- 15 (c) (3 points) Imple ment the function mer ge_sort (). The interface for the function is def merge sort (node_ chain) : www Purpose: Sorts the given node chain in ascending order using the merge sort algorithm . Pre-conditions: param node_chain: a no de - chain, possibly empty, containing only numbers Post condition: the node - cha in will be sorted in ascending order Return return: the node - chain sorted in ascend ing order Ex: 45->1->21->5. Becomes 1->5->21->45 This one might be a little difficult, since it uses recursion. A demonstration of the application of the function is as follows chain node. create (10 node. create (9 , node.create (12, node. create (7. node. create (11 node. create (8) )) )) ) print ('chain before :\n, to_string ( chain) sorted_node_chain mer ge _s or t ( chain) print ('merge_sort results :\n ' , to_string ( sorted_node_chain)) The output from the demonstration is as follows: chain before: [10 I- >[91-->[ 12 I-]- > 7 -->[ 11|-]--> 8 I merge_sort results 71.-1 8 -1 9] > 10 --> 11 1 12 I d) (5 points) Before you submit your work, review it, and edit it for programm ing style. Make sure your variables are named well, and that you have appropriate (not excessive) internal documentation (do not change the doc-string which we have given you.

Answer 1

# CMPT 145: Assignment 5 Question 3

import node as node
import a5q2 as a5q2


def split_chain(node_chain):
        """
        Purpose:
                Splits the given node chain in half, returning the second half.
                If the given chain has an odd length, the extra node is part of
                the second half of the chain.
        Pre-conditions:
                :param node_chain: a node-chain, possibly empty
        Post-conditions:
                the original node chain is cut in half!
        Return:
                :return: A tuple (nc1, nc2) where nc1 and nc2 are node-chains
                 each containing about half of the nodes in node-chain
        """
        size = a5q2.count_chain(node_chain)
        
        # if the chain is empty
        if size == 0:
                return (None, None)
                
        # if there is just one node, then second list contain more elements
        if size == 1:
                return (None, node_chain)
        
        ###
        # Algorithm: We will run 2 walkers parallely, but in each iteration
        # first walker moves 1 step, while the second walker moves 2 steps.
        # When second walker reach to the end of the list, then we will stop
        # this process. At that time, first walker will be pointing to the 
        # node after which we should split the list
        ####
        # in case chain has odd number of nodes, we will put a blank node
        # at the start, so that we get to see the list length as even number
        # and then we will do our regular algorithm as stated above
        # So if, List is: 1 -> 2 -> 3 -> 4 -> 5-> 6 -> 7 -> 8
        # walker1 start from node 1, and walker 2 starts from node 2
        # when walker2 reaches to node 8, then walker1 will be at node 4.
        # we will stop at this point and break complete chain after
        # node 4.
        start = node_chain
        if size % 2 != 0:
                start = node.create(None, node_chain)
        
        walker1 = start
        walker2 = node.get_next(start)
        
        # keep moving till walker2 reaches last node
        while node.get_next(walker2) is not None:
                # move walker1 1 step at a time
                walker1 = node.get_next(walker1)
                
                # walker2 will walk 2 step at a time
                walker2 = node.get_next(node.get_next(walker2))
        
        # now break the list after walker1
        second_list = node.get_next(walker1)
        node.set_next(walker1, None)
                
        return (node_chain, second_list)

Answered first part.. Please ask separate questions for each part.. also, give the copyable code.. because we can not write everything after seeing the image.. i tried to help you to the max extent, which i could do in the given time limit. Thanks!