头图

手撸golang 行为型设计模式 策略模式

ioly

手撸golang 行为型设计模式 策略模式

缘起

最近复习设计模式
拜读谭勇德的<<设计模式就该这样学>>
本系列笔记拟采用golang练习之

策略模式

策略模式(Strategy Pattern)又叫作政策模式(Policy Pattern),
它将定义的算法家族分别封装起来,
让它们之间可以互相替换,
从而让算法的变化不会影响到使用算法的用户,
属于行为型设计模式。

(摘自 谭勇德 <<设计模式就该这样学>>)

场景

  • 某学员成绩管理系统, 需要对学员成绩进行排序
  • 码农王二狗根据<<我的第一本算法书>>里的描述, 使用冒泡排序算法实现了成绩排序功能
  • Leader审查代码时, 认为王二狗的实现虽然完成了功能, 但不够sexy, 要求改进
  • 于是王二狗继续翻查算法书, 又加上了选择排序和快速排序算法.
  • 为兼容性和可扩展性考虑, 王二狗根据策略模式, 把排序算法都抽象成统一接口, 等Leader说哪个好, 就用那个.

设计

  • ISortPolicy: 排序算法接口
  • tBubbleSortPolicy: 冒泡排序算法, 实现ISortPolicy接口
  • tSelectSortPolicy: 选择排序算法, 实现ISortPolicy接口
  • tQuickSortPolicy: 快速排序算法, 实现ISortPolicy接口. 内部顺便实现了一个LIFO栈 - tIntStack.

单元测试

policy_pattern_test.go, 生成若干随机整数, 然后分别使用冒泡, 选择, 快速排序算法进行排序

package behavioral_patterns

import (
    plc "learning/gooop/behavioral_patterns/policy"
    "math/rand"
    "testing"
    "time"
)

func Test_PolicyPattern(t *testing.T) {
    size := 20
    data := make([]int, size)
    r := rand.New(rand.NewSource(time.Now().Unix()))
    for i, _ := range data {
        data[i] = r.Intn(100)
    }
    t.Logf("UnsortedData \t= %v", data)

    fnMakeCopy := func() []int{
        copies := make([]int, size)
        for i,v := range data {
            copies[i] = v
        }
        return copies
    }

    fnTestPolicy := func(policy plc.ISortPolicy) {
        sorted := policy.Sort(fnMakeCopy())
        t.Logf("%s \t= %v", policy.Name(), sorted)
    }

    fnTestPolicy(plc.NewBubbleSortPolicy())
    fnTestPolicy(plc.NewSelectSortPolicy())
    fnTestPolicy(plc.NewQuickSortPolicy())
}

测试输出

$ go test -v policy_pattern_test.go 
=== RUN   Test_PolicyPattern
    policy_pattern_test.go:17: UnsortedData     = [19 17 28 36 80 84 70 7 80 68 2 96 94 26 22 31 80 49 49 69]
    policy_pattern_test.go:29: BubbleSort       = [2 7 17 19 22 26 28 31 36 49 49 68 69 70 80 80 80 84 94 96]
    policy_pattern_test.go:29: SelectSort       = [2 7 17 19 22 26 28 31 36 49 49 68 69 70 80 80 80 84 94 96]
    policy_pattern_test.go:29: QuickSort        = [2 7 17 19 22 26 28 31 36 49 49 68 69 70 80 80 80 84 94 96]
--- PASS: Test_PolicyPattern (0.00s)
PASS
ok      command-line-arguments  0.002s

ISortPolicy.go

排序算法接口

package policy

type ISortPolicy interface {
    Name() string
    Sort(data []int) []int
}

tBubbleSortPolicy.go

冒泡排序算法, 实现ISortPolicy接口

package policy

// 冒泡排序
type tBubbleSortPolicy struct {
}

func NewBubbleSortPolicy() ISortPolicy {
    return &tBubbleSortPolicy{}
}

func (self *tBubbleSortPolicy) Name() string {
    return "BubbleSort"
}

func (self *tBubbleSortPolicy) Sort(data []int) []int {
    if data == nil {
        return nil
    }

    size := len(data)
    if size <= 1 {
        return data
    }

    for {
        i := size - 1
        changed := false

        for {
            if i <= 0 {
                break
            }
            j := i - 1

            if data[j] > data[i] {
                data[i],data[j] = data[j],data[i]
                changed = true
            }

            i--
        }

        if !changed {
            break
        }
    }

    return data
}

tSelectSortPolicy.go

选择排序算法, 实现ISortPolicy接口

package policy

// 选择排序
type tSelectSortPolicy struct {
}

func NewSelectSortPolicy() ISortPolicy {
    return &tSelectSortPolicy{}
}

func (self *tSelectSortPolicy) Name() string {
    return "SelectSort"
}

func (self *tSelectSortPolicy) Sort(data []int) []int {
    if data == nil {
        return nil
    }

    size := len(data)
    if size <= 1 {
        return data
    }

    i := 0
    for {
        if i >= size - 1 {
            break
        }

        p, m := self.min(data, i + 1, size - 1)
        if m < data[i] {
            data[p], data[i] = data[i], data[p]
        }

        i++
    }

    return data
}

func (self *tSelectSortPolicy) min(data []int, from int, to int) (p int, v int) {
    i := from
    p = from
    v = data[from]

    if to <= from {
        return p, v
    }

    for {
        i++
        if i > to {
            break
        }

        if data[i] < v {
            p = i
            v = data[i]
        }
    }

    return p, v
}

tQuickSortPolicy.go

快速排序算法, 实现ISortPolicy接口. 内部顺便实现了一个LIFO栈.

package policy

import "errors"

// 快速排序
type tQuickSortPolicy struct {
    mLeftStack *tIntStack
    mRightStack *tIntStack
}

func NewQuickSortPolicy() ISortPolicy {
    return &tQuickSortPolicy{
        newIntStack(),newIntStack(),
    }
}

// LIFO栈
type tIntStack struct {
    tail *tIntNode
    size int
}

type tIntNode struct {
    Value int
    Prev *tIntNode
}

func newIntNode(value int) *tIntNode {
    return &tIntNode {
        value, nil,
    }
}

func newIntStack() *tIntStack {
    return &tIntStack{
        nil,
        0,
    }
}

func (self *tIntStack) Push(i int) {
    node := newIntNode(i)
    node.Prev = self.tail
    self.tail = node
    self.size++
}

func (self *tIntStack) Pop() (error,int) {
    if self.size > 0 {
        self.size--
        node := self.tail
        self.tail = self.tail.Prev
        return nil, node.Value

    } else {
        return errors.New("empty stack"), 0
    }
}

func (self *tIntStack) Size() int {
    return self.size
}

func (self *tQuickSortPolicy) Name() string {
    return "QuickSort"
}

func (self *tQuickSortPolicy) Sort(data []int) []int {
    self.qsort(data, 0, len(data) - 1)
    return data
}


func (self *tQuickSortPolicy) qsort(data []int, from int, to int)  {
    if to <= from {
        return
    }

    // only two
    if to == from + 1 {
        if data[to] < data[from] {
            data[from], data[to] = data[to], data[from]
        }
        return
    }

    // get pivot
    iPivot := (from + to) / 2
    vPivot := data[iPivot]

    // split left and right
    left := 0
    right := 0
    for i := from; i <= to; i++ {
        if i == iPivot {
            continue
        }

        v := data[i]
        if v <= vPivot {
            self.mLeftStack.Push(v)
            left++
        } else {
            self.mRightStack.Push(v)
            right++
        }
    }

    // pop right stack
    p := to
    for i := right; i > 0; i-- {
        e,v := self.mRightStack.Pop()
        if e != nil {
            panic(e)
        }
        data[p] = v
        p--
    }

    // pop pivot
    data[p] = vPivot
    p--

    // pop left stack
    for i := left; i > 0; i-- {
        e,v := self.mLeftStack.Pop()
        if e != nil {
            panic(e)
        }
        data[p] = v
        p--
    }

    // qsort left and right
    self.qsort(data, from, from + left - 1)
    self.qsort(data, to - right + 1, to)
}

策略模式小结

策略模式的优点
(1)策略模式符合开闭原则。
(2)避免使用多重条件转移语句,如if...else语句、switch...case语句
(3)使用策略模式可以提高算法的保密性和安全性。

策略模式的缺点
(1)客户端必须知道所有的策略,并且自行决定使用哪一个策略类。
(2)代码中会产生非常多策略类,增加维护难度。

(摘自 谭勇德 <<设计模式就该这样学>>)

(end)

阅读 262

想当将军 首先要肯打

39 声望
9 粉丝
0 条评论

想当将军 首先要肯打

39 声望
9 粉丝
宣传栏