书中源码 第3章 算法分析

"""
返回Python列表最大值的函数
"""
def find_max(data):
    """
    Return the maximum element from a nonempty Python list.
    :param data:
    :return:
    """
    biggest = data[0]       # The initial value to beat
    for val in data:        # For each value:
        if val > biggest:   # if it is greater than the best so far.
            biggest = val
        return biggest      # When loop ends. biggest is the max.

时间复杂度为$O(n)$。
如果基于随机序列，该算法的最大值被更新的预期次数是$O(logn)$

---

3-2 前缀平均值

"""
前缀平均值，算法prefix_average1
"""
import time

def prefix_average1(S):
    """
    Return list such that, for all j, A[j] equals average of S[0],...,S[j]
    :param S:
    :return:
    """
    n = len(S)
    A = [0] * n   # create new list of n zeros
    for j in range(n):
        total = 0
        for i in range(j + 1):
            total += S[i]
        A[j] = total / (j + 1)
    return A

if __name__ == '__main__':
    data = [x for x in range(10000)]
    print(data)
    curr = time.time()
    prefix_data = prefix_average1(data)
    print(time.time() - curr)
    print(prefix_data)

时间复杂度为$O(n^2)$，运行时间为2.5133016109466553秒。

---

3-3 前缀平均值

"""
前缀平均值，算法prefix_average2
"""
import time

def prefix_average2(S):
    """
    Return list such that, for all j, A[j] equals average of S[0],...S[j].
    :param S:
    :return:
    """
    n = len(S)
    A = [0] * n                             # create new list of n zeros
    for j in range(n):
        A[j] = sum(S[0: j+1]) / (j + 1)     # record the average
    return A

if __name__ == '__main__':
    data = [x for x in range(10000)]
    print(data)
    curr = time.time()
    prefix_data = prefix_average2(data)
    print(time.time() - curr)
    print(prefix_data)

时间复杂度为$O(n^2)$，运行时间为0.4189138412475586秒。

---

3-4 前缀平均值

"""
前缀平均值，算法prefix_average3
"""
import time

def prefix_average3(S):
    """
    Return list such that, for all j, A[j] equals average of S[0],...S[j].
    :param S:
    :return:
    """
    n = len(S)
    A = [0] * n                             # create new list of n zeros
    total = 0                               # compute prefix sum as S[0] + S[1],...
    for j in range(n):
        total += S[j]                       # update prefix sum to include S[j]
        A[j] = total / (j + 1)              # compute average based on current sum
    return A

if __name__ == '__main__':
    data = [x for x in range(10000)]
    print(data)
    curr = time.time()
    prefix_data = prefix_average3(data)
    print(time.time() - curr)
    print(prefix_data)

时间复杂度为$O(n)$，运行时间为0.001027822494506836秒。

---

3-5 三集不相交，算法disjoint1测试三集不相交

def disjoint1(A, B, C):
    """
    Return True if there is no element common to all three lists.
    :param A: 
    :param B: 
    :param C: 
    :return: 
    """
    for a in A:
        for b in B:
            for c in C:
                if a == b == c:
                    return False    # we found a common value
    return True                     # if we reach this, sets are disjoint

时间复杂度为$O(n^3)$

---

3-6 三集不相交，算法disjoint1测试三集不相交

def disjoint(A, B, C):
    """
    Return True if there is no element common to all three lists.
    :param A: 
    :param B: 
    :param C: 
    :return: 
    """
    for a in A:
        for b in B:
            if a == b:                  # only check C if we found match from A and B
                for c in C:
                    if a == c:          # (and thus a == b == c)
                        return False    # we found a common value
    return True                         # if we reach this, sets are disjoint.

时间复杂度为$O(n^2)$

---

3-7 用于测试元素唯一性的算法unique1

def unique1(S):
    """
    Return True if there are no duplicate elements in sequence S.
    :param S:
    :return:
    """
    for j in range(len(S)):
        for k in range(j + 1, len(S)):
            if S[j] == S[k]:
                return False    # found duplicate pair
    return True                 # if we reach this, elements are unique

时间复杂度为$O(n^2)$

---

3-8 用于测试元素唯一性的算法unique2

def unique2(S):
    """
    Return True if there are no duplicate elements in sequence S. 
    :param S: 
    :return: 
    """
    temp = sorted(S)                # create a sorted copy of S
    for j in range(1, len(S)):      
        if temp[j - 1] == temp[j]:
            return False            # found duplicate pair
    return True                     # if we reach this, elements were unique

时间复杂度为$O(nlogn)$

---

3-9 寻找一个给定的元素在Python列表中出现的第一个索引值的算法

def find(S, val):
    """
    Return index j such that S[j] == val, or -1 if no such element.
    :param S: 
    :param val: 
    :return: 
    """
    n = len(S)
    j = 0
    while j < n:
        if S[j] == val:
            return True     # a match was found at index j
        j += 1
    return -1

---