4、策略模式

策略模式（Strategy）定义了一系列算法，并使它们可以互相替换。在Go中，可以使用接口实现策略模式：

定义

package strategy

import (
    "fmt"
    "sort"
)

// 定义排序策略接口
type SortStrategy interface {
    Sort([]int) []int
    GetName() string
}

// 冒泡排序策略
type BubbleSort struct{}

func (s BubbleSort) Sort(data []int) []int {
    fmt.Println("使用冒泡排序...")
    result := make([]int, len(data))
    copy(result, data)
    
    n := len(result)
    for i := 0; i < n; i++ {
        for j := 0; j < n-i-1; j++ {
            if result[j] > result[j+1] {
                result[j], result[j+1] = result[j+1], result[j]
            }
        }
    }
    
    return result
}

func (s BubbleSort) GetName() string {
    return "冒泡排序"
}

// 快速排序策略
type QuickSort struct{}

func (s QuickSort) Sort(data []int) []int {
    fmt.Println("使用快速排序...")
    result := make([]int, len(data))
    copy(result, data)
    
    sort.Ints(result) // 使用Go标准库的排序（实际为快排）
    return result
}

func (s QuickSort) GetName() string {
    return "快速排序"
}

// 上下文
type SortContext struct {
    strategy SortStrategy
}

// 设置排序策略
func (c *SortContext) SetStrategy(strategy SortStrategy) {
    c.strategy = strategy
}

// 执行排序
func (c *SortContext) ExecuteSort(data []int) []int {
    return c.strategy.Sort(data)
}

使用

// main.go
package main

import (
    "fmt"
    "myapp/strategy"
    "time"
)

func main() {
    // 创建上下文
    ctx := &strategy.SortContext{}
    
    // 准备数据
    data := []int{9, 3, 7, 5, 1, 8, 2, 6, 4}
    
    // 使用冒泡排序
    ctx.SetStrategy(strategy.BubbleSort{})
    start := time.Now()
    result1 := ctx.ExecuteSort(data)
    elapsed1 := time.Since(start)
    fmt.Printf("排序结果: %v (耗时: %v)\n", result1, elapsed1)
    
    // 使用快速排序
    ctx.SetStrategy(strategy.QuickSort{})
    start = time.Now()
    result2 := ctx.ExecuteSort(data)
    elapsed2 := time.Since(start)
    fmt.Printf("排序结果: %v (耗时: %v)\n", result2, elapsed2)
}