设计模式之策略模式

个人认为策略模式最大的好处就是可以在运行时改变计算使用的算法。策略模式UML类图还是比较好理解的。

以归并排序和快速排序为例，上代码。

其核心在基类中的接口函数sort()，这是运行时算法替换的基础。

import numpy as np
from abc import ABCMeta, abstractmethod

class algorithm(metaclass=ABCMeta):
    """
    sort base
    """
    def __init__(self, data):
        self._array = data

    @abstractmethod
    def sort(self):
        pass


class MergeSort(algorithm):
    """
    merge sort
    """
    def __init__(self, data):
        super().__init__(data)
        self.__aux = [0 for i in range(len(data))]

    def merge(self, src, aux, lo, mid, hi):
        for i in range(lo, hi + 1):
            aux[i] = src[i]

        i, j = lo, mid + 1
        for k in range(lo, hi + 1):
            if(i > mid):
                src[k], j = aux[j], j + 1
            elif(j > hi):
                src[k], i = aux[i], i + 1
            elif(aux[i] > aux[j]):
                src[k], j = aux[j], j + 1
            else:
                src[k], i = aux[i], i + 1

    def sortCore(self, src, aux, lo, hi):
        if hi <= lo:
            return
        mid = lo + (hi - lo) // 2
        self.sortCore(src, aux, lo, mid)
        self.sortCore(src, aux, mid + 1, hi)
        self.merge(src, aux, lo, mid, hi)

    def sort(self):
        self.sortCore(self._array, self.__aux, 0, len(self._array) - 1)


class QuickSort(algorithm):
    """
    quick sort
    """
    def __init__(self, data):
        super().__init__(data)

    def __partition(self, array, lo, hi):
        i, j, mid = lo + 1, hi, array[lo]
        while True:
            while array[i] < mid:
                if i == hi:
                    break
                i += 1
            while array[j] > mid:
                if j == lo:
                    break
                j -= 1
            if i >= j:
                break
            array[i], array[j] = array[j], array[i]
        array[lo], array[j] = array[j], array[lo]
        return j

    def __sortCore(self, array, lo, hi):
        if hi <= lo:
            return
        j = self.__partition(array, lo, hi)
        self.__sortCore(array, lo, j - 1)
        self.__sortCore(array, j + 1, hi)

    def sort(self):
        self.__sortCore(self._array, 0, len(self._array) - 1)


if __name__ == "__main__":
    lens = np.random.randint(0, 200, 1)
    src = np.random.randint(0, 999, lens)
    print(src)
    src = list(src)

    #当长度大于100时采用快速排序
    if lens > 100:
        sortMethod = QuickSort(src)
    else:
        sortMethod = MergeSort(src)
    sortMethod.sort()
    print(src)