Scribd
Upload
58 views

Introduction To Computation and Programming Using Python, Revised - Guttag, John v..149

This document discusses selection sort and merge sort algorithms. Selection sort works by iterating through a list and swapping elements to put the minimum element at the front, with each pass sorting more of the list, resulting in quadratic time complexity. Merge sort is a divide and conquer algorithm that works by splitting the list, sorting the halves, and then merging the sorted halves together.

Uploaded by

ZhichaoWang
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
58 views

Introduction To Computation and Programming Using Python, Revised - Guttag, John v..149

This document discusses selection sort and merge sort algorithms. Selection sort works by iterating through a list and swapping elements to put the minimum element at the front, with each pass sorting more of the list, resulting in quadratic time complexity. Merge sort is a divide and conquer algorithm that works by splitting the list, sorting the halves, and then merging the sorted halves together.

Uploaded by

ZhichaoWang
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 1

132

Chapter 10. Some Simple Algorithms and Data Structures


We use induction to reason about loop invariants.

Base case: At the start of the first iteration, the prefix is empty, i.e., the
suffix is the entire list. The invariant is (trivially) true.

Induction step: At each step of the algorithm, we move one element from
the suffix to the prefix. We do this by appending a minimum element of
the suffix to the end of the prefix. Because the invariant held before we
moved the element, we know that after we append the element the prefix
is still sorted. We also know that since we removed the smallest element
in the suffix, no element in the prefix is larger than the smallest element
in the suffix.

When the loop is exited, the prefix includes the entire list, and the suffix
is empty. Therefore, the entire list is now sorted in ascending order.

def selSort(L):
"""Assumes that L is a list of elements that can be
compared using >.
Sorts L in ascending order"""
suffixStart = 0
while suffixStart != len(L):
#look at each element in suffix
for i in range(suffixStart, len(L)):
if L[i] < L[suffixStart]:
#swap position of elements
L[suffixStart], L[i] = L[i], L[suffixStart]
suffixStart += 1

Figure 10.3 Selection sort


Its hard to imagine a simpler or more obviously correct sorting algorithm.
Unfortunately, it is rather inefficient.52 The complexity of the inner loop is
O(len(L)). The complexity of the outer loop is also O(len(L)). So, the complexity of
the entire function is O(len(L)2). I.e., it is quadratic in the length of L.

10.2.1 Merge Sort


Fortunately, we can do a lot better than quadratic time using a divide-andconquer algorithm. The basic idea is to combine solutions of simpler instances
of the original problem. In general, a divide-and-conquer algorithm is
characterized by
1. A threshold input size, below which the problem is not subdivided,
2. The size and number of sub-instances into which an instance is split,
and
3. The algorithm used to combine sub-solutions.
The threshold is sometimes called the recursive base. For item 2 it is usual to
consider the ratio of initial problem size to sub-instance size. In most of the
examples weve seen so far, the ratio was 2.
52 But not the most inefficient of sorting algorithms, as suggested by a successful
candidate for the U.S. Presidency. See http://www.youtube.com/watch?v=k4RRi_ntQc8.

You might also like