设计模式之 Strategy 策略模式：Swift 实现

Strategy Mode 策略模式

做同一件事情，可以有不同的策略来实现，我们使用策略模式使得在切换不同策略的时候更加方便。

对于策略模式，我们这样描述：
Strategy mode set some solution class, and each solution can be substituted by other solution easily. When we face different problem, we choose different solution to solve problem. The Problem class hold a reference of Strategy interface to use different strategy.

策略模式设定了一些算法类，每个算法类可以被其它算法类所替换。当我们面对不同的问题时，我们选择不同的策略来解决问题。“问题” 类持有 “策略”接口， 以便使用不同的策略。

protocol Strategy {
    func sort(_ nums: inout [Int]) -> [Int]
}

// Strategy A
class SelectedSort: Strategy {
    func sort(_ nums: inout [Int]) -> [Int] {
        print("Selected sort")
        var len = nums.count
        if len <= 1 {
            return nums
        }
        for i in 0..<len {
            var minIndex = i
            for j in (i + 1)..<len {
                if nums[j] < nums[minIndex] {
                    minIndex = j
                }
            }
            var tmp = nums[i]
            nums[i] = nums[minIndex]
            nums[minIndex] = tmp
        }
        return nums
    }
}

// Strategy B
class InsertSort: Strategy {
    func sort(_ nums: inout [Int]) -> [Int] {
        print("Insert sort")
        var len = nums.count
        if len <= 1 {
            return nums
        }
        for i in 1..<len {   
            var left = i - 1
            while true {
                if left < 0 || nums[i] > nums[left] {
                    var cover = i - 1
                    var t = nums[i]
                    while cover > left {
                        nums[cover + 1] = nums[cover] 
                        cover -= 1
                    } 
                    nums[left + 1] = t
                    break
                } else {
                    left -= 1
                }
            }
        }
        return nums
    }
}

class Problem {
    private var strategy: Strategy
    init(strategy: Strategy) {
        self.strategy = strategy
    }
    func solve(_ nums: inout [Int]) -> [Int] {
        strategy.sort(&nums)
    }
    
    func changeStrategy(strategy: Strategy) {
        self.strategy = strategy
    }
}

var nums = [2, 6, 1, 5, 0, 3]

var a = SelectedSort()
var b = InsertSort()
var problem = Problem(strategy: a)
problem.solve(&nums)
print(nums)

nums.shuffle()
print(nums)

problem.changeStrategy(strategy: b)
problem.solve(&nums)
print(nums)

以上代码中，problem 持有一个 strategy 引用，需要解决问题时就使用这个引用所指的策略对象来解决问题，对于同一个排序问题，可以使用不同策略来完成，这里有 a、b 两种策略可选。