Question

Write an implementation similar to the Priority Queue method (from chapter 26) to the linked list using node. (from chapter 24). Your code should utilize the selectionsort method from attached and create another method call selectionsort in linkedlist class. To demonstrate the usage of the selection sort method, you should manually create a link list of random integer (say of 5 numbers), and you need to demonstrate the use the selection sort to sorted the link list. Please submit your code and screenshots of your result by the due dates

class LinkedList:
    def __init__(self):
        self.length = 0
        self.head = None
    def add_first(self, cargo):
        node = Node(cargo)
        node.next = self.head
        self.head = node
        self.length += 1
    def print_backward(self):
        print("[", end=" ")
        if self.head is not None:
            self.head.print_backward()


class Node:
    def __init__(self, cargo=None, next=None):
        self.cargo = cargo
        self.next  = next

    def __str__(self):
        return str(self.cargo)

    def print_backward(self):
        if self.next is not None:
            tail = self.next
            tail.print_backward()

class LinkedList:
    def __init__(self):
        self.length = 0
        self.head = None

    def print_backward(self):
        print("[", end=" ")
        if self.head is not None:
            self.head.print_backward()

    def __str__(self):
        #need to complete here
        
    def add_first(self, cargo):
        node = Node(cargo)
        node.next = self.head
        self.head = node
        self.length += 1

    def selectionsort(self):
       #adjust the code below to make it work
       for i in range(0, len(self.items)):
           positionOfMin=i
           for j in range(i+1,len(self.items)):
               if self.items[j]

I'm almost done can you help modify the selection sort and write a def __str__

Answer 1

Here is the completed code for this problem. Comments are included, go through it, learn how things work and let me know if you have any doubts or if you need anything to change. If you are satisfied with the solution, please rate the answer. If not, PLEASE let me know before you rate, I’ll help you fix whatever issues. Thanks

Note: Please maintain proper code spacing (indentation), just copy the code part and paste it in your compiler/IDE directly, no modifications required. Also, you cannot directly use the selection sort method using indexing, because we are not dealing with an array, but a linked list, it cannot be accessed using indices unless we implement __getitem__ and __setitem__ methods. But there is another way to implement the selection sort without indicing, which I did below. The algorithm is same, only the implementation is different.

#code

class Node:
    def __init__(self, cargo=None, next=None):
        self.cargo = cargo
        self.next = next

    def __str__(self):
        return str(self.cargo)

    # there was errors in this method, fixed it
    def print_backward(self):
        if self.next is not None:
            self.next.print_backward()
            print(", ", end="")
        print(self.cargo, end="")


class LinkedList:
    def __init__(self):
        self.length = 0
        self.head = None

    # completed this method also
    def print_backward(self):
        print("[", end="")
        if self.head is not None:
            self.head.print_backward()
        print("]")

    def __str__(self):
        data = '['
        # taking reference to head node
        node = self.head
        # looping until the last node
        while node != None:
            # appending cargo of current node to data
            data += str(node.cargo)
            # if there is a next node, appending ", "
            if node.next != None:
                data += ", "
            # advancing to next node
            node = node.next
        # closing "] and returning string
        data += "]"
        return data

    def add_first(self, cargo):
        node = Node(cargo)
        node.next = self.head
        self.head = node
        self.length += 1

    def selectionsort(self):
        # taking a reference to head node
        node = self.head
        # looping for length number of times (i=0 to length-1)
        for i in range(self.length):
            # storing this node as node with min value
            min_node = node
            # also storing as current node under check
            current = node
            # looping for length-i times
            for j in range(self.length - i):
                # if cargo of current node is less than that of min_node
                if current.cargo < min_node.cargo:
                    # setting current as new min_node
                    min_node = current
                # advancing to next node
                current = current.next
            # swapping cargo values of node and min_node
            temp = node.cargo
            node.cargo = min_node.cargo
            min_node.cargo = temp
            # advancing to next node
            node = node.next


# code for testing
import random

# creating a linked list
l = LinkedList()
# adding 10 random numbers to the list
for i in range(10):
    l.add_first(random.randint(1, 50))
# printing the list
print(l)
# sorting contents
l.selectionsort()
# printing the sorted list
print(l)

#output (random)

[3, 29, 25, 9, 47, 27, 3, 16, 31, 47]
[3, 3, 9, 16, 25, 27, 29, 31, 47, 47]