Question

Python
Implement a class named BubbleStringList. In this class implement a method called add, that when given a string, it adds it to an internal list object.
You can use the list object from the standard python library for the internal list. Next, implement a sort method that uses a BubbleSort to sort the list when called.
Create another class called MergeStringList, that implements the same methods but uses a Merge Sort as the sorting algorithm.
Create another class called QuickStringList that implements the same methods but used a QuickSort algorithm.
Write a test class for each and use timeit to getting the run times and compare the results.

Answer 1

Hello,

Please find the below code:

class BubbleStringList:
    def __init__(self):
        self.list = []

    def add(self, input):
        self.list.append(input)

    def sort(self, lst):
        for i in range(len(lst)):
            for j in range(i + 1, len(lst)):
                if lst[j] < lst[i]:
                    lst[j], lst[i] = lst[i], lst[j]
        return lst


class MergeStringList:
    def __init__(self):
        self.list = []

    def add(self, input):
        self.list.append(input)

    def merge(self, left, right):
        result = []
        i, j = 0, 0
        while i < len(left) and j < len(right):
            if len(left[i]) <= len(right[j]):
                result.append(left[i])
                i = i + 1
            else:
                result.append(right[j])
                j = j + 1

        result += left[i:]
        result += right[j:]
        return result

    def sort(self, nlist):
        if len(nlist) > 1:
            mid = len(nlist) // 2
            lefthalf = nlist[:mid]
            righthalf = nlist[mid:]

            self.sort(lefthalf)
            self.sort(righthalf)
            i = j = k = 0
            while i < len(lefthalf) and j < len(righthalf):
                if lefthalf[i] < righthalf[j]:
                    nlist[k] = lefthalf[i]
                    i = i + 1
                else:
                    nlist[k] = righthalf[j]
                    j = j + 1
                k = k + 1

            while i < len(lefthalf):
                nlist[k] = lefthalf[i]
                i = i + 1
                k = k + 1

            while j < len(righthalf):
                nlist[k] = righthalf[j]
                j = j + 1
                k = k + 1
        return nlist


class QuickStringList:
    def __init__(self):
        self.list = []

    def add(self, input):
        self.list.append(input)

    def sort(self, array):
        """Sort the array by using quicksort."""

        less = []
        equal = []
        greater = []

        if len(array) > 1:
            pivot = array[0]
            for x in array:
                if x < pivot:
                    less.append(x)
                elif x == pivot:
                    equal.append(x)
                elif x > pivot:
                    greater.append(x)
            # Don't forget to return something!
            return self.sort(less) + equal + self.sort(greater)  # Just use the + operator to join lists
        # Note that you want equal ^^^^^ not pivot
        else:  # You need to handle the part at the end of the recursion - when you only have one element in your array, just return the array.
            return array


if __name__ == '__main__':
    b = BubbleStringList()
    b.add("Sumit")
    b.add("Amit")
    b.add("Kumit")
    b.add("Pul")
    b.add("Kul")
    b.sort(b.list)
    print(b.list)

    c =MergeStringList()
    c.add("Sumit")
    c.add("Amit")
    c.add("Kumit")
    c.add("Pul")
    c.add("Kul")
    c.sort(c.list)
    print(c.list)

    q = QuickStringList()
    q.add("Sumit")
    q.add("Amit")
    q.add("Kumit")
    q.add("Pul")
    q.add("Kul")
    print(q.sort(q.list))

Test_Quick_Sort.py:

import timeit


def test1(array=["Kul","Pul","dul"]):
    less = []
    equal = []
    greater = []

    if len(array) > 1:
        pivot = array[0]
        for x in array:
            if x < pivot:
                less.append(x)
            elif x == pivot:
                equal.append(x)
            elif x > pivot:
                greater.append(x)
        return test1(less) + equal + test1(greater)
    else:
        return array


if __name__ == '__main__':
    print(timeit.timeit("test1()", setup="from __main__ import test1"))

Test_Merge_Sort.py:

import timeit


def merge(left, right):
    result = []
    i, j = 0, 0
    while i < len(left) and j < len(right):
        if len(left[i]) <= len(right[j]):
            result.append(left[i])
            i = i + 1
        else:
            result.append(right[j])
            j = j + 1

    result += left[i:]
    result += right[j:]
    return result


def test1(nlist=["Kul","Pul","dul"]):
    if len(nlist) > 1:
        mid = len(nlist) // 2
        lefthalf = nlist[:mid]
        righthalf = nlist[mid:]

        test1(lefthalf)
        test1(righthalf)
        i = j = k = 0
        while i < len(lefthalf) and j < len(righthalf):
            if lefthalf[i] < righthalf[j]:
                nlist[k] = lefthalf[i]
                i = i + 1
            else:
                nlist[k] = righthalf[j]
                j = j + 1
            k = k + 1

        while i < len(lefthalf):
            nlist[k] = lefthalf[i]
            i = i + 1
            k = k + 1

        while j < len(righthalf):
            nlist[k] = righthalf[j]
            j = j + 1
            k = k + 1
        return nlist


if __name__ == '__main__':
    print(timeit.timeit("test1()", setup="from __main__ import test1"))

Test_bubble_sort.py:

import timeit

def test1(lst=["Kul","Pul","dul"]):
    for i in range(len(lst)):
        for j in range(i + 1, len(lst)):
            if lst[j] < lst[i]:
                lst[j], lst[i] = lst[i], lst[j]
    return lst


if __name__ == '__main__':
    print(timeit.timeit("test1()", setup="from __main__ import test1"))

Test Cases Using timeit:

Test Case Results:

Let me know if you have anything in comments sections.

Thanks