数据结构与算法分析_python_C5

Chapter 5 搜索和排序
5-1 无序列表的顺序搜索

def sequentialSearch(alist,item):
    pos = 0
    found = False
    
    while pos < len(alist) and not found:
        if alist[pos] == item:
            found = True
        else:
            pos = pos + 1
            
    return found

5-2 有序列表的顺序搜索

def orderedSequentialSearch(alist, item):
    pos = 0
    found = False
    stop = False
    while pos < len(alist) and not found and not stop:
        if alist[pos] == item:
            found = True
        else:
            if alist[pos] > item:
                stop = True
            else:
                pos = pos + 1
                
    return found

5-3 有序列表的二分搜索

 def binarySearch(alist, item):
    first = 0
    last = len(alist) - 1
    found = False
    
    while first <= last and not found:
        midpoint = (first + last) // 2
        if alist[midpoint] == item:
            found = True
        else:
            if item < alist[midpoint]:
                last = midpoint - 1
            else:
                first = midpoint + 1
                
    return found

5-4 二分搜索的递归版本

def binarySearch(alist, item):
    if len(alist) == 0:
        return False
    else:
        midpoint = len(alist) // 2
        if alist[midpoint] == item:
            return True
        else:
            if item < alist[midpoint]:
                return binarySearch(alist[:midpoint], item)
            else:
                return binarySearch(alist[midpoint+1:], item)

5-5 为字符串构建简单的散列函数

def hash(astring, tablesize):
    sum = 0
    for pos in range(len(astring)):
        sum = sum + ord(astring[pos])
        
    return sum%tablesize

5-6 HashTable类的构造方法

class HashTable:
    def __init__(self):
        self.size = 11
        self.slots = [None] * self.size
        self.data = [None] * self.size

5-7 put函数

def put(self, key, data):
    hashvalue = self.hashfunction(key, len(self.slots))
    
    if self.slots[hashvalue] == None:
        self.slots[hashvalue] = key
        self.data[hashvalue] = data
        
    else:
        if self.slots[hashvalue] == key:
            self.data[hashvalue] = data
        else:
            nextslot = self.rehash(hashvalue, len(self.slots))
            while self.slots[nextslot] != None and \
                        self.slots[nextslot] != key:
                nextslot = self.rehash(nextslot, len(self.slots))
                
            if self.slots[nextslot] == None:
                self.slots[nextslot] = key
                self.data[nextslot] = data
                
            else:
                self.data[nextslot] = data
                
def hashfunction(self, key, size):
    return key%size

def rehash(self, oldhash, size):
    return (oldhash + 1)%size

5-8 get函数

def get(self, key):
    startslot = self.hashfunction(key, len(self.slots))
    
    data = None
    stop = False
    found = False
    position = startslot
    while self.slots[position] != None and \
                not found and not stop:
        if self.slots[position] == key:
            found = True
            data = self.data[position]
        else:
            position = self.rehash(position, len(self.slots))
            if position == startslot:
                stop = True
                
    return data

def __getitem__(self, key):
    return self.get(key)

def __setitem__(self, key, data):
    self.put(key, data)

H = HashTable()
H[54] = "dog"
H[26] = "dog"
H[93] = "lion"
H[17] = "tiger"
H[77] = "bird"
H[31] = "goat"
H[44] = "cow"
H[55] = "pig"
H[20] = "popo"
H.slots       

5-9 冒泡排序函数bubbleSort

def bubbleSort(alist):
    for passnum in range(len(alist)-1, 0, -1):
        for i in range (passnum):
            if alist[i] > alist[i+1]:
                temp = alist[i]
                alist[i] = alist[i+1]
                alist[i+1] = temp         

5-10 修改后的冒泡排序函数

def shortBubbleSort(alist):
    exchanges = True
    passnum = len(alist) - 1
    while passnum > 0 and exchanges:
        exchanges = False
        for i in range(passnum):
            if alist[i] > alist[i+1]:
                exchanges = True
                temp = alist[i+1]
                alist[i+1] = temp
        passnum = passnum - 1

5-11 选择排序函数selectionSort

def selectionSort(alist):
    for fillsort in range(len(alist)-1, 0, -1):
        positionOfMax = 0
        for location in range(1, fillslot+1):
            if alist[location] > alist[positionOfMax]:
                positionOfMax = location
                
        temp = alist[fillslot]
        alist[fillslot] = alist[positionOfMax]
        alist[positionOfMax] = temp  

5-12 插入排序函数insertionSort

def insertionSort(alist):
    for index in range(1, len(alist)):
        
        cuurentvalue = alist[index]
        position = index
        
        while position > 0 and alist[position - 1] > currentvalue:
            alist[position] = alist[position - 1]
            
        alist[position] = currentvalue            

5-13 希尔排序函数shellSort

def shellSort(alist):
    sublistcount = len(alist) // 2
    while sublistcount > 0:
        for startposition in range(sublistcount):
            gapInsertionSort(alist, startposition, sublistcount)
            
        print("After increments of size", sublistcount, "The list is ", alist)
        
        sublistcount = sublistcount // 2
        
def gapInsertionSort(alist, start, gap):
    for i in range(start+gap, len(alist), gap):
        
        currentvalue = alist[i]
        position = i
        
        while position >= gap and \
                    alist[position-gap] > currentvalue:
            alist[position] = alist[position - gap]
            position = position - gap
            
        alist[position] = currentvalue 

alist = [54,26, 93, 17, 77, 31, 44, 55, 20]
shellSort(alist)

5-14 并归排序函数mergeSort

def mergeSort(alist):
    print("Splitting", alist)
    if len(alist) > 1:
        mid = len(alist) // 2
        lefthalf = alist[:mid]
        righthalf = alist[mid:]
        
        mergeSort(lefthalf)
        mergeSort(righthalf)
        
        i = 0
        j = 0
        k = 0
        while i < len(lefthalf) and j < len(righthalf):
            if lefthalf[i] < righthalf[j]:
                alist[k] = lefthalf[i]
                i = i+1
            else:
                alist[k] = righthalf[j]
                j = j+1
            k = k + 1
            
            
        while i < len(lefthalf):
            alist[k] = lefthalf[i]
            i = i+1
            k = k+1
            
        while j < len(righthalf):
            alist[k] = righthalf[j]
            j = j+1
            k = k+1    
        
    print("Merging ", alist)

m = [54,26, 93, 17, 77, 31, 44, 55, 20]
mergeSort(m)        

5-15 快速排序函数quickSort

def quickSort(alist):
    quickSortHelper(alist, 0, len(alist-1))
    
def quickSortHelper(alist, first, last):
    if firts < last:
        
        splitpoint = partition(alist, first, last)
        
        quickSortHelper(alist, first, splitpoint-1)
        quickSortHelper(alist, splitpoint+1,last )
        
def partition(alist, first, last):
    pivotvalue = alist[first]
    
    leftmark = first + 1
    rightmark = last
    done = False
    while not done:
        
        while leftmark <= rightmark and \
                    alist[leftmark] <= pivotvalue:
            leftmark = leftmark + 1
            
        while alist[rightmark] >= pivotvalue and \
                    rightmark >= leftmark:
            rightmark = rightmark - 1
            
        if rightmark < leftmark:
            done = True
        else:
            temp = alist[leftmark]
            alist[leftmark] = alist[rightmark]
            alist[rightmark] = temp
            
    temp = alist[first]
    alist[first] = alist[rightmark]
    alist[rightmark] = temp
    
    
    return rightmark