예제 #1
0
"""
file: heapSort.py
version: python3
author: Sean Strout
author: <<< YOUR NAME HERE >>
purpose: Implementation of the heapsort algorithm, not
    in-place, (lst is unmodified and a new sorted one is returned)
"""

import arrayHeap    # mkHeap (for adding/removing from heap)
import testSorts    # run (for individual test run)

def heapSort(lst):
    """
    heapSort(List(Orderable)) -> List(Ordered)
        performs a heapsort on 'lst' returning a new sorted list
    Postcondition: the argument lst is not modified
    """
    return []

if __name__ == "__main__":
    testSorts.run('heapSort')
예제 #2
0
    the first, middle and last values.
    """
    return median([lst[0], lst[len(lst) // 2], lst[len(lst) - 1]])


def quickSort(lst):
    """
    quickSort: List(lst) -> List(result)
        Where the return 'result' is a totally ordered 'lst'.
        It uses the median-of-3 to select the pivot

    e.g.  quickSort([1,8,5,3,4]) == [1,3,4,5,8]
    """
    if len(lst) == 1 or lst == []:
        return lst
    pivot = [medianOf3(lst)]
    lst2 = []
    lst3 = []
    for i in lst:
        if i < pivot[0]:
            lst2.append(i)
        elif i > pivot[0]:
            lst3.append(i)
        else:
            pivot.append(i)
    return quickSort(lst2) + pivot + quickSort(lst3)


if __name__ == "__main__":
    testSorts.run('qsPivotMedian3')
예제 #3
0
    else:
        pivot = lst[0]  # here we select the first element as the pivot
        less, same, more = partition(pivot, lst)
        return quickSort(less) + same + quickSort(more)


def partition(pivot, lst):
    """
   partition: pivot (element in lst) * List(lst) -> 
        tuple(List(less), List(same, List(more))).  
   Where:
        List(Less) has values less than the pivot
        List(same) has pivot value/s, and
        List(more) has values greater than the pivot
        
   e.g. partition(5, [11,4,7,2,5,9,3]) == [4,2,3], [5], [11,7,9]
   """
    less, same, more = list(), list(), list()
    for val in lst:
        if val < pivot:
            less.append(val)
        elif val > pivot:
            more.append(val)
        else:
            same.append(val)
    return less, same, more


if __name__ == "__main__":
    testSorts.run('qsPivotFirst')
예제 #4
0
    """
    A non in-place, depth limited quickSort, using median-of-3 pivot.
    Once the limit drops to 0, it uses heapSort instead.
    """
    if len(lst) == 1 or lst == []:
        return lst
    if limit <= 0:
        return heapSort.heapSort(lst)
    pivot = [median([lst[0], lst[len(lst) // 2], lst[len(lst) - 1]])]
    lst2 = []
    lst3 = []
    for i in lst:
        if i < pivot[0]:
            lst2.append(i)
        elif i > pivot[0]:
            lst3.append(i)
        else:
            pivot.append(i)
    return quipSortRec(lst2, limit - 1) + pivot + quipSortRec(lst3, limit - 1)

def quipSort(lst):
    """
    The main routine called to do the sort.  It should call the
    recursive routine with the correct values in order to perform
    the sort
    """
    quipSortRec(lst, log2(len(lst)))

if __name__ == "__main__":
    testSorts.run('quipSort')
예제 #5
0
    """
    From a lst of unordered data, find and return the the median value from
    the first, middle and last values.
    """
    return median([lst[0], lst[len(lst) // 2], lst[len(lst) - 1]])
    
def quickSort(lst):
    """
    quickSort: List(lst) -> List(result)
        Where the return 'result' is a totally ordered 'lst'.
        It uses the median-of-3 to select the pivot

    e.g.  quickSort([1,8,5,3,4]) == [1,3,4,5,8]
    """
    if len(lst) == 1 or lst == []:
        return lst
    pivot = [medianOf3(lst)]
    lst2 = []
    lst3 = []
    for i in lst:
        if i < pivot[0]:
            lst2.append(i)
        elif i > pivot[0]:
            lst3.append(i)
        else:
            pivot.append(i)
    return quickSort(lst2) + pivot + quickSort(lst3)
   
if __name__ == "__main__":
    testSorts.run('qsPivotMedian3')
예제 #6
0
    Once the limit drops to 0, it uses heapSort instead.
    """
    if lst == []:
        return lst

    if limit == 0:
        return heapSort.heapSort(lst)
    else:
        pivot = qsPivotMedian3.medianOf3(
            lst)  #  select the first element as the pivot
        less, same, more = qsPivotFirst.partition(pivot, lst)
        return quicheSortRec(less, limit - 1) + same + quicheSortRec(
            more, limit - 1)


def quicheSort(lst):
    """
    The main routine called to do the sort.  It should call the
    recursive routine with the correct values in order to perform
    the sort
    """
    if len(lst) == 0:
        return list()
    else:
        limit = int(math.log(len(lst), 2))
        return quicheSortRec(lst, limit)


if __name__ == "__main__":
    testSorts.run('quicheSort')
예제 #7
0
    Once the limit drops to 0, it uses heapSort instead.
    """
    if len(lst) == 1 or lst == []:
        return lst
    if limit <= 0:
        return heapSort.heapSort(lst)
    pivot = [median([lst[0], lst[len(lst) // 2], lst[len(lst) - 1]])]
    lst2 = []
    lst3 = []
    for i in lst:
        if i < pivot[0]:
            lst2.append(i)
        elif i > pivot[0]:
            lst3.append(i)
        else:
            pivot.append(i)
    return quipSortRec(lst2, limit - 1) + pivot + quipSortRec(lst3, limit - 1)


def quipSort(lst):
    """
    The main routine called to do the sort.  It should call the
    recursive routine with the correct values in order to perform
    the sort
    """
    quipSortRec(lst, log2(len(lst)))


if __name__ == "__main__":
    testSorts.run('quipSort')
예제 #8
0
   if len(lst) == 0:
      return list()
   else:
      pivot = lst[0]        # here we select the first element as the pivot
      less, same, more = partition(pivot, lst)
      return quickSort(less) + same + quickSort(more)

def partition( pivot, lst ):
   """
   partition: pivot (element in lst) * List(lst) -> 
        tuple(List(less), List(same, List(more))).  
   Where:
        List(Less) has values less than the pivot
        List(same) has pivot value/s, and
        List(more) has values greater than the pivot
        
   e.g. partition(5, [11,4,7,2,5,9,3]) == [4,2,3], [5], [11,7,9]
   """
   less, same, more = list(), list(), list()
   for val in lst:
      if val < pivot:
         less.append(val)
      elif val > pivot:
         more.append(val)
      else:
         same.append(val)
   return less, same, more

if __name__ == "__main__":
    testSorts.run('qsPivotFirst')
예제 #9
0
    Once the limit drops to 0, it uses heapSort instead.
    """
    if lst == []:
        return lst
    
    if limit==0:
        return heapSort.heapSort(lst)
    else:
        pivot= qsPivotMedian3.medianOf3(lst)        #  select the first element as the pivot
        less, same, more = qsPivotFirst.partition(pivot, lst)
        return quicheSortRec(less,limit-1) + same + quicheSortRec(more,limit-1)           
   

def quicheSort(lst):
    """
    The main routine called to do the sort.  It should call the
    recursive routine with the correct values in order to perform
    the sort
    """
    if len(lst)== 0:
        return list()
    else:
        limit = int (math.log(len(lst),2))
        return quicheSortRec(lst,limit)
    
       
if __name__ == "__main__":
     testSorts.run('quicheSort')