1、分而治之（divide and conquer，D&C）

（1）步驟：①找到簡單的基線條件（可能是空陣列貨只包含一個元素的陣列）；②不斷分解問題/縮小規模，直至符合基線條件。

（2）不是用於解決問題的演算法，而是一種解決問題的思路。

（3）原理：將問題逐步分解。

2、歐幾里得演算法：gcd(a,b)=gcd(b,a mod b)

def gcd(a,b):
    while a!=0:
        #a=b%a;b=a
        a,b=b%a,a
    return b

3、 快速排序

（1）基準值（pivot）、分割槽（partitioning）

（2）code medo

def quicksort(array):
    if len(array)<2:
        # 基線條件：為空貨只包含一個元素的陣列是有序的
          return array
    else:
        # 遞迴條件
        pivot=array[0]
        print(array[1:])
        # 由所有小於基準值的元素組成的子陣列
        less=[i for i in array[1:] if i<=pivot]    
        # 由所有大於基準值的元素組成的子陣列
        greater=[i for
 
 i in array[1:] if i>pivot]

        return quicksort(less)+[pivot]+quicksort(greater)

print(quicksort([10,5,2,3,4]))    

 （3）實現快速排序的時候，請隨機地選擇基準值的元素。

4、收納證明步驟：基線條件和歸納條件 

5、大O表示法

（1）O(n log n)：快速排序在平均情況下執行時間 / 合併排序，快速查詢的常量要比合並查詢小。

（2）c*n：c為演算法所需要的的固定時間量，成為常量。

（3）平均情況（最佳情況）：每層時間*層數即呼叫棧的高度=O(n)*O(log n)=O(n log n)

　　  最糟糕情況：每層時間*層數即呼叫棧的高度=O(n)*O(n)=O(n^2)

（4）比較簡單查詢和二分查詢時，常量幾乎無關緊要，由於列表很長是，O(log n)的速度比O(n)快得多。但是在比較快速排序於合併排序的時候又是事關緊要的。

 答案：

4.1 CODE

# 例子1
arr=[2,4,6]
def sum1(arr):
    total=0
    for i in range(0,len(arr)):
        total+=arr[i]
    return total

print(sum1(arr))

# 例子2
def sum2(arr):
    total=0
    for x in arr:
        total+=x
    return total

print(sum2([2,4,6]))

4.2 CODE

arr=[1,2,3,4,5,6]
print(len(arr))
def count(arr):
    if len()

4.3 CODE

def maxArr(arr):
    max=arr[0]
    for i in range(len(arr)):
        if arr[i]>max:
            max=arr[i]
    return max

arr=[-10,-1,-5,-2,-8,-3]
print(maxArr(arr))

 4.4 CODE

def binary_search(list,item):
    low=0
    high=len(list)-1
    # 基線條件
    while low<=high:
        mid=(low+high)//2
        guess=list[mid]
        # 遞迴條件
        if guess==item:
            return mid
        elif guess>item:
            high=mid-1
        else:
            low=mid+1
    return None

list=[1,2,3,1,5,6]
print(binary_search(list,4))

4.5 O(c*n)

4.6 O(c*n)

4.7 O(1)

4.8 O(c*n^2)