1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

type Sorter struct {
    algorithm string // 选择用哪个算法："quick", "merge", "heap"
}

func (s *Sorter) Sort(data []int) {
    switch s.algorithm {
    case "quick":
        // 快速排序逻辑
    case "merge":
        // 归并排序逻辑
    case "heap":
        // 堆排序逻辑
    }
}

1
2
3
4
5
6
7
8

// ========== 第一步：定义策略接口 ==========

// SortStrategy 是排序策略的接口
// 所有排序算法都要实现这个接口
type SortStrategy interface {
    Sort(data []int) []int
    GetName() string
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

// ========== 第二步：实现各种排序策略 ==========

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

func (s *QuickSortStrategy) Sort(data []int) []int {
    fmt.Println("[QuickSort] 快速排序中...")
    if len(data) <= 1 {
        return data
    }

    // 简单实现：选第一个作为基准
    pivot := data[0]
    var left, right []int
    for _, v := range data[1:] {
        if v < pivot {
            left = append(left, v)
        } else {
            right = append(right, v)
        }
    }

    left = s.Sort(left)
    right = s.Sort(right)

    result := append(left, pivot)
    result = append(result, right...)
    return result
}

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

// MergeSortStrategy 归并排序策略
type MergeSortStrategy struct{}

func (s *MergeSortStrategy) Sort(data []int) []int {
    fmt.Println("[MergeSort] 归并排序中...")
    if len(data) <= 1 {
        return data
    }

    mid := len(data) / 2
    left := s.Sort(data[:mid])
    right := s.Sort(data[mid:])

    return s.merge(left, right)
}

func (s *MergeSortStrategy) merge(left, right []int) []int {
    result := make([]int, 0, len(left)+len(right))
    i, j := 0, 0
    for i < len(left) && j < len(right) {
        if left[i] < right[j] {
            result = append(result, left[i])
            i++
        } else {
            result = append(result, right[j])
            j++
        }
    }
    result = append(result, left[i:]...)
    result = append(result, right[j:]...)
    return result
}

func (s *MergeSortStrategy) GetName() string {
    return "归并排序"
}

// BubbleSortStrategy 冒泡排序策略（虽然慢，但简单易懂）
type BubbleSortStrategy struct{}

func (s *BubbleSortStrategy) Sort(data []int) []int {
    fmt.Println("[BubbleSort] 冒泡排序中...")
    result := make([]int, len(data))
    copy(result, data)

    n := len(result)
    for i := 0; i < n-1; 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 *BubbleSortStrategy) GetName() string {
    return "冒泡排序"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// ========== 第三步：定义上下文（使用策略的对象） ==========

// Sorter 是排序器的上下文
// 它持有一个排序策略，可以动态切换
type Sorter struct {
    strategy SortStrategy
}

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

// Sort 执行排序
func (s *Sorter) Sort(data []int) []int {
    fmt.Printf("使用策略: %s\n", s.strategy.GetName())
    return s.strategy.Sort(data)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

func main() {
    fmt.Println("=== 策略模式：排序算法选择 ===\n")

    // 待排序的数据
    data := []int{64, 34, 25, 12, 22, 11, 90}

    // 创建排序器（上下文）
    sorter := &Sorter{}

    // ===== 场景1：用快速排序 =====
    fmt.Println("--- 场景1: 快速排序 ---")
    sorter.SetStrategy(&QuickSortStrategy{})
    result := sorter.Sort(data)
    fmt.Printf("排序结果: %v\n\n", result)

    // ===== 场景2：用归并排序 =====
    fmt.Println("--- 场景2: 归并排序 ---")
    sorter.SetStrategy(&MergeSortStrategy{})
    result = sorter.Sort(data)
    fmt.Printf("排序结果: %v\n\n", result)

    // ===== 场景3：用冒泡排序 =====
    fmt.Println("--- 场景3: 冒泡排序 ---")
    sorter.SetStrategy(&BubbleSortStrategy{})
    result = sorter.Sort(data)
    fmt.Printf("排序结果: %v\n\n", result)

    // ===== 场景4：动态切换策略 =====
    fmt.Println("--- 场景4: 动态策略切换 ---")
    strategies := []SortStrategy{
        &QuickSortStrategy{},
        &BubbleSortStrategy{},
        &MergeSortStrategy{},
    }

    for i, strategy := range strategies {
        fmt.Printf("第%d轮: ", i+1)
        sorter.SetStrategy(strategy)
        fmt.Printf("结果: %v\n", sorter.Sort(data))
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// ========== 第一步：定义模板方法基类 ==========

// DailyRoutine 是每日生活模板
// 这是一个"骨架"，定义了每天的固定流程
type DailyRoutine struct {
    // 这个结构体定义了一个"模板方法"：MorningRoutine()
}

// MorningRoutine 是模板方法——它定义了算法的骨架
// 注意：这个方法是不可重写的（Go没有final关键字，这里用约定俗成）
func (r *DailyRoutine) MorningRoutine() {
    fmt.Println("=== 早晨例行流程 ===")

    r.wakeUp()        // 第一步：起床（固定）
    r.brushTeeth()    // 第二步：刷牙（固定）
    r.eatBreakfast()  // 第三步：吃早餐（可变）
    r.changeClothes() // 第四步：换衣服（可变）
    r.goOut()         // 第五步：出门（固定）

    fmt.Println("=== 流程结束 ===\n")
}

// WakeUp 起床——骨架的一部分，通常不需要变化
func (r *DailyRoutine) wakeUp() {
    fmt.Println("[骨架] 起床")
}

// BrushTeeth 刷牙洗脸——骨架的一部分
func (r *DailyRoutine) brushTeeth() {
    fmt.Println("[骨架] 刷牙洗脸")
}

// EatBreakfast 吃早餐——这是一个"钩子方法"，子类可以重写
func (r *DailyRoutine) eatBreakfast() {
    fmt.Println("[骨架] 吃早餐（默认：吃面包）")
}

// ChangeClothes 换衣服——这是一个"钩子方法"，子类可以重写
func (r *DailyRoutine) changeClothes() {
    fmt.Println("[骨架] 换衣服（默认：穿休闲装）")
}

// GoOut 出门——骨架的一部分，通常不需要变化
func (r *DailyRoutine) goOut() {
    fmt.Println("[骨架] 出门上班")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// ========== 第二步：定义具体的子类实现 ==========

// WorkdayRoutine 工作日的routine
type WorkdayRoutine struct {
    *DailyRoutine // 匿名嵌套，相当于"继承"
}

func NewWorkdayRoutine() *WorkdayRoutine {
    routine := &DailyRoutine{}
    return &WorkdayRoutine{DailyRoutine: routine}
}

// 重写吃早餐
func (r *WorkdayRoutine) eatBreakfast() {
    fmt.Println("[工作日] 快速吃个包子，边走边吃")
}

// 重写换衣服
func (r *WorkdayRoutine) changeClothes() {
    fmt.Println("[工作日] 穿正装，打领带")
}

// WeekendRoutine 周末的routine
type WeekendRoutine struct {
    *DailyRoutine
}

func NewWeekendRoutine() *WeekendRoutine {
    routine := &DailyRoutine{}
    return &WeekendRoutine{DailyRoutine: routine}
}

func (r *WeekendRoutine) eatBreakfast() {
    fmt.Println("[周末] 精心做个煎饼果子，加蛋加肠")
}

func (r *WeekendRoutine) changeClothes() {
    fmt.Println("[周末] 穿睡衣，舒服最重要")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// ========== 第三步：更灵活的钩子机制 ==========

// TravelRoutine 出差/旅行的routine，展示了更多钩子用法
type TravelRoutine struct {
    *DailyRoutine
}

func NewTravelRoutine() *TravelRoutine {
    routine := &DailyRoutine{}
    return &TravelRoutine{DailyRoutine: routine}
}

// 重写所有可变步骤
func (r *TravelRoutine) wakeUp() {
    fmt.Println("[旅行] 睡到自然醒，酒店真舒服")
}

func (r *TravelRoutine) eatBreakfast() {
    fmt.Println("[旅行] 酒店自助餐，吃个够")
}

func (r *TravelRoutine) changeClothes() {
    fmt.Println("[旅行] 穿旅游装，准备出发")
}

func (r *TravelRoutine) goOut() {
    fmt.Println("[旅行] 出发去景点！")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

func main() {
    fmt.Println("=== 模板方法模式 ===\n")

    // ===== 场景1：工作日 =====
    fmt.Println("--- 场景1: 工作日早晨 ---")
    workday := NewWorkdayRoutine()
    workday.MorningRoutine()

    // ===== 场景2：周末 =====
    fmt.Println("--- 场景2: 周末早晨 ---")
    weekend := NewWeekendRoutine()
    weekend.MorningRoutine()

    // ===== 场景3：旅行 =====
    fmt.Println("--- 场景3: 旅行早晨 ---")
    travel := NewTravelRoutine()
    travel.MorningRoutine()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// 钩子方法的经典用法：允许子类在某个步骤之前或之后添加额外逻辑

type AlgorithmWithHook struct{}

func (a *AlgorithmWithHook) TemplateMethod() {
    fmt.Println("步骤1：准备工作")

    // 钩子：子类可以选择性地在这里添加逻辑
    a.beforeMainStep()

    fmt.Println("步骤2：核心步骤")
    a.mainStep()

    // 钩子：另一个钩子
    a.afterMainStep()

    fmt.Println("步骤3：收尾工作")
}

// 默认实现的钩子（空实现）
func (a *AlgorithmWithHook) beforeMainStep() {
    // 默认什么都不做
}

// 默认实现的钩子（空实现）
func (a *AlgorithmWithHook) afterMainStep() {
    // 默认什么都不做
}

// 核心步骤——必须实现
func (a *AlgorithmWithHook) mainStep() {
    panic("子类必须实现 mainStep")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// 子类A：不需要额外逻辑
type ConcreteAlgorithmA struct {
    *AlgorithmWithHook
}

func NewConcreteAlgorithmA() *ConcreteAlgorithmA {
    return &ConcreteAlgorithmA{&AlgorithmWithHook{}}
}

func (a *ConcreteAlgorithmA) mainStep() {
    fmt.Println("算法A的核心步骤执行中...")
}

// 子类B：需要添加额外逻辑
type ConcreteAlgorithmB struct {
    *AlgorithmWithHook
}

func NewConcreteAlgorithmB() *ConcreteAlgorithmB {
    return &ConcreteAlgorithmB{&AlgorithmWithHook{}}
}

func (a *ConcreteAlgorithmB) mainStep() {
    fmt.Println("算法B的核心步骤执行中...")
}

// 重写钩子
func (a *ConcreteAlgorithmB) beforeMainStep() {
    fmt.Println("[钩子] 算法B：在核心步骤之前做一些准备工作")
}

func (a *ConcreteAlgorithmB) afterMainStep() {
    fmt.Println("[钩子] 算法B：在核心步骤之后做一些清理工作")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func main() {
    fmt.Println("--- 算法A（不使用钩子）---")
    algoA := NewConcreteAlgorithmA()
    algoA.TemplateMethod()

    fmt.Println()

    fmt.Println("--- 算法B（使用钩子）---")
    algoB := NewConcreteAlgorithmB()
    algoB.TemplateMethod()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// ========== 第一步：定义观察者接口 ==========

// Observer 是观察者的接口
// 所有观察者都要实现这个接口
type Observer interface {
    // Update 当被观察者状态改变时，这个方法会被调用
    Update(message string)
    // GetID 获取观察者的ID
    GetID() string
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// ========== 第二步：定义被观察者接口 ==========

// Subject 是被观察者（主题）的接口
type Subject interface {
    // Attach 添加观察者
    Attach(observer Observer)
    // Detach 移除观察者
    Detach(observer Observer)
    // Notify 通知所有观察者
    Notify(message string)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

// ========== 第三步：实现具体被观察者 ==========

// NewsAgency 是新闻机构（被观察者）
type NewsAgency struct {
    // 观察者列表
    observers []Observer
    // 新闻机构名称
    name string
}

// NewNewsAgency 创建新闻机构
func NewNewsAgency(name string) *NewsAgency {
    return &NewsAgency{
        name:     name,
        observers: make([]Observer, 0),
    }
}

// Attach 添加观察者
func (s *NewsAgency) Attach(observer Observer) {
    s.observers = append(s.observers, observer)
    fmt.Printf("[%s] 新观察者订阅: %s\n", s.name, observer.GetID())
}

// Detach 移除观察者
func (s *NewsAgency) Detach(observer Observer) {
    for i, o := range s.observers {
        if o.GetID() == observer.GetID() {
            // 删除这个观察者
            s.observers = append(s.observers[:i], s.observers[i+1:]...)
            fmt.Printf("[%s] 观察者取消订阅: %s\n", s.name, observer.GetID())
            return
        }
    }
}

// Notify 通知所有观察者
func (s *NewsAgency) Notify(message string) {
    fmt.Printf("\n[%s] 发布新闻: %s\n", s.name, message)
    fmt.Println("----------------------------------------")
    for _, observer := range s.observers {
        // 逐一通知每个观察者
        observer.Update(message)
    }
    fmt.Println("----------------------------------------\n")
}

// PublishNews 发布新闻的方法
func (s *NewsAgency) PublishNews(news string) {
    fmt.Printf("[%s]有新新闻发布！\n", s.name)
    s.Notify(news)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// ========== 第四步：实现具体观察者 ==========

// NewsChannel 是新闻频道（观察者）
type NewsChannel struct {
    id   string
    name string
}

// NewNewsChannel 创建新闻频道
func NewNewsChannel(id, name string) *NewsChannel {
    fmt.Printf("[%s] 新闻频道「%s」(ID: %s) 开通了！\n", name, name, id)
    return &NewsChannel{id: id, name: name}
}

func (c *NewsChannel) Update(message string) {
    // 收到通知后，新闻频道开始播报
    fmt.Printf("[%s] 🔔 收到推送：%s\n", c.name, message)
}

func (c *NewsChannel) GetID() string {
    return c.id
}

// WeChatUser 是微信公众号用户（观察者）
type WeChatUser struct {
    id   string
    name string
}

func NewWeChatUser(id, name string) *WeChatUser {
    fmt.Printf("[微信用户] %s 关注了公众号\n", name)
    return &WeChatUser{id: id, name: name}
}

func (u *WeChatUser) Update(message string) {
    fmt.Printf("[微信用户 %s] 📱 收到推送：%s\n", u.name, message)
}

func (u *WeChatUser) GetID() string {
    return u.id
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

func main() {
    fmt.Println("=== 观察者模式：新闻订阅系统 ===\n")

    // 创建被观察者：新闻机构
    agency := NewNewsAgency("新华社")

    // 创建观察者们
    channel1 := NewNewsChannel("CCTV-1", "央视一套")
    channel2 := NewNewsChannel("CCTV-2", "央视二套")
    user1 := NewWeChatUser("user001", "张三")
    user2 := NewWeChatUser("user002", "李四")
    user3 := NewWeChatUser("user003", "王五")

    fmt.Println()

    // ===== 开始订阅 =====
    fmt.Println("========== 开始订阅 ==========\n")

    agency.Attach(channel1)
    agency.Attach(channel2)
    agency.Attach(user1)
    agency.Attach(user2)
    agency.Attach(user3)

    fmt.Println()

    // ===== 发布新闻1 =====
    fmt.Println("========== 新闻一 ==========")
    agency.PublishNews("突发！程序员终于找到了写注释的理由！")

    // ===== 李四取消订阅 =====
    fmt.Println("--- 李四取消订阅 ---")
    agency.Detach(user2)

    // ===== 发布新闻2 =====
    fmt.Println("========== 新闻二 ==========")
    agency.PublishNews("重磅！研究表明，'明天再改'是拖延症的终极形态！")

    // ===== 新用户加入 =====
    fmt.Println("--- 新用户订阅 ---")
    user4 := NewWeChatUser("user004", "赵六")
    agency.Attach(user4)

    // ===== 发布新闻3 =====
    fmt.Println()
    fmt.Println("========== 新闻三 ==========")
    agency.PublishNews("震惊！这款代码居然没有bug！")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// EventHandler 是事件处理函数类型
type EventHandler func(message string)

// SimpleSubject 是一个简化版的主题，使用事件委托
type SimpleSubject struct {
    // 观察者列表，现在是一组函数
    handlers []EventHandler
}

func NewSimpleSubject() *SimpleSubject {
    return &SimpleSubject{
        handlers: make([]EventHandler, 0),
    }
}

func (s *SimpleSubject) Subscribe(handler EventHandler) {
    s.handlers = append(s.handlers, handler)
    fmt.Printf("[SimpleSubject] 新订阅者注册，当前共 %d 个订阅者\n", len(s.handlers))
}

func (s *SimpleSubject) Unsubscribe(handler EventHandler) {
    // 简化版：只是移除最后一个
    if len(s.handlers) > 0 {
        s.handlers = s.handlers[:len(s.handlers)-1]
    }
}

func (s *SimpleSubject) Notify(message string) {
    fmt.Printf("\n[SimpleSubject] 广播事件: %s\n", message)
    for _, handler := range s.handlers {
        handler(message)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

func main() {
    subject := NewSimpleSubject()

    // 使用函数作为观察者
    handler1 := func(msg string) {
        fmt.Printf("[观察者1] 收到消息: %s\n", msg)
    }

    handler2 := func(msg string) {
        fmt.Printf("[观察者2] 收到消息: %s\n", msg)
    }

    subject.Subscribe(handler1)
    subject.Subscribe(handler2)

    subject.Notify("Hello, Observer Pattern!")
}

1
2
3
4
5
6
7
8

// 数组
array := []int{1, 2, 3}

// 链表
list := []int{1, 2, 3} // 假设这是链表

// 树
tree := []int{1, 2, 3} // 假设这是树

1
2
3

遍历Array()
遍历List()
遍历Tree()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 遍历切片
nums := []int{1, 2, 3, 4, 5}
for i, v := range nums {
    fmt.Printf("索引: %d, 值: %d\n", i, v)
}

// 遍历map
m := map[string]int{"a": 1, "b": 2}
for k, v := range m {
    fmt.Printf("键: %s, 值: %d\n", k, v)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// ========== 第一步：定义节点 ==========

// Node 是链表节点
type Node struct {
    Value int
    Next  *Node
}

// ========== 第二步：定义迭代器接口 ==========

// Iterator 是迭代器接口
type Iterator interface {
    // HasNext 是否有下一个元素
    HasNext() bool
    // Next 获取下一个元素
    Next() *Node
    // Reset 重置迭代器到开头
    Reset()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// ========== 第三步：实现链表迭代器 ==========

// LinkedListIterator 是链表的迭代器
type LinkedListIterator struct {
    head   *Node
    current *Node
}

// NewLinkedListIterator 创建迭代器
func NewLinkedListIterator(head *Node) *LinkedListIterator {
    return &LinkedListIterator{
        head:    head,
        current: nil, // 初始时没有指向任何节点
    }
}

func (it *LinkedListIterator) HasNext() bool {
    if it.current == nil {
        // 第一次调用，指向head
        return it.head != nil
    }
    // 后续调用，看下一个是否为空
    return it.current.Next != nil
}

func (it *LinkedListIterator) Next() *Node {
    if it.current == nil {
        // 第一次调用，返回head
        it.current = it.head
    } else {
        // 后续调用，移动到下一个
        it.current = it.current.Next
    }
    return it.current
}

func (it *LinkedListIterator) Reset() {
    it.current = nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// ========== 第四步：定义链表容器 ==========

// LinkedList 是链表容器
type LinkedList struct {
    head *Node
    size int
}

// NewLinkedList 创建链表
func NewLinkedList() *LinkedList {
    return &LinkedList{}
}

// Add 添加节点
func (list *LinkedList) Add(value int) {
    newNode := &Node{Value: value}
    if list.head == nil {
        list.head = newNode
    } else {
        current := list.head
        for current.Next != nil {
            current = current.Next
        }
        current.Next = newNode
    }
    list.size++
}

// CreateIterator 创建迭代器
func (list *LinkedList) CreateIterator() Iterator {
    return NewLinkedListIterator(list.head)
}

// Size 获取链表大小
func (list *LinkedList) Size() int {
    return list.size
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

func main() {
    fmt.Println("=== 迭代器模式 ===\n")

    // 创建一个链表: 1 -> 2 -> 3 -> 4 -> 5
    list := NewLinkedList()
    list.Add(1)
    list.Add(2)
    list.Add(3)
    list.Add(4)
    list.Add(5)

    fmt.Printf("链表大小: %d\n\n", list.Size())

    // 使用迭代器遍历
    fmt.Println("--- 使用迭代器遍历链表 ---")
    iterator := list.CreateIterator()

    fmt.Println("正向遍历:")
    for iterator.HasNext() {
        node := iterator.Next()
        fmt.Printf("节点值: %d\n", node.Value)
    }

    fmt.Println()

    // 重置后再次遍历
    fmt.Println("再次遍历（重置后）:")
    iterator.Reset()
    for iterator.HasNext() {
        node := iterator.Next()
        fmt.Printf("节点值: %d\n", node.Value)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

// ========== 二叉树节点 ==========

type TreeNode struct {
    Value    int
    Left     *TreeNode
    Right    *TreeNode
}

// BinaryTreeIterator 是二叉树的中序遍历迭代器
type BinaryTreeIterator struct {
    root     *TreeNode
    stack    []*TreeNode
    current  *TreeNode
}

// NewBinaryTreeIterator 创建二叉树迭代器
func NewBinaryTreeIterator(root *TreeNode) *BinaryTreeIterator {
    return &BinaryTreeIterator{
        root:   root,
        stack:  make([]*TreeNode, 0),
        current: root,
    }
}

func (it *BinaryTreeIterator) HasNext() bool {
    return it.current != nil || len(it.stack) > 0
}

func (it *BinaryTreeIterator) Next() *TreeNode {
    // 中序遍历：左子树 -> 根节点 -> 右子树
    for it.current != nil {
        it.stack = append(it.stack, it.current)
        it.current = it.current.Left
    }

    // 弹出栈顶节点
    node := it.stack[len(it.stack)-1]
    it.stack = it.stack[:len(it.stack)-1]

    // 转向右子树
    it.current = node.Right

    return node
}

func (it *BinaryTreeIterator) Reset() {
    it.stack = make([]*TreeNode, 0)
    it.current = it.root
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

func main() {
    fmt.Println("=== 二叉树迭代器 ===\n")

    // 构建一棵二叉树：
    //       4
    //      / \
    //     2   6
    //    / \ / \
    //   1  3 5  7

    root := &TreeNode{
        Value: 4,
        Left: &TreeNode{
            Value: 2,
            Left:  &TreeNode{Value: 1},
            Right: &TreeNode{Value: 3},
        },
        Right: &TreeNode{
            Value: 6,
            Left:  &TreeNode{Value: 5},
            Right: &TreeNode{Value: 7},
        },
    }

    fmt.Println("中序遍历（递归结果应该是: 1 2 3 4 5 6 7）:")
    fmt.Println("迭代器遍历结果:")

    iterator := NewBinaryTreeIterator(root)
    for iterator.HasNext() {
        node := iterator.Next()
        fmt.Printf("%d ", node.Value)
    }
    fmt.Println()
}

1
2
3
4
5

// 包 container/list 中的迭代器
type Iterator interface {
    Next() bool
    Value() interface{}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import "container/list"

l := list.New()
l.PushBack(1)
l.PushBack(2)
l.PushBack(3)

for e := l.Front(); e != nil; e = e.Next() {
    fmt.Println(e.Value)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// ========== 第一步：定义请求结构 ==========

// LeaveRequest 请假申请
type LeaveRequest struct {
    EmployeeName string // 员工名
    Days        int    // 请假天数
    Reason      string // 请假原因
}

// LeaveRequest 的字符串描述
func (r *LeaveRequest) String() string {
    return fmt.Sprintf("员工[%s]申请请假%d天，原因: %s", r.EmployeeName, r.Days, r.Reason)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// ========== 第二步：定义处理者接口 ==========

// Approver 是审批者的接口
type Approver interface {
    // SetNext 设置下一个审批者
    SetNext(approver Approver)
    // HandleRequest 处理请求
    HandleRequest(request *LeaveRequest) bool
    // GetName 获取审批者名称
    GetName() string
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// ========== 第三步：实现基础处理者 ==========

// BaseApprover 是所有审批者的基类
type BaseApprover struct {
    name  string
    next  Approver // 指向下一个审批者
    maxDays int    // 能审批的最大天数
}

// SetNext 设置下一个审批者
func (b *BaseApprover) SetNext(approver Approver) {
    b.next = approver
    // 这里不打印，避免和实际审批流程混淆
}

// GetName 获取名称
func (b *BaseApprover) GetName() string {
    return b.name
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106

// ========== 第四步：实现具体的处理者 ==========

// TeamLeader 组长，只能审批1天以内的假
type TeamLeader struct {
    *BaseApprover
}

func NewTeamLeader() *TeamLeader {
    return &TeamLeader{
        BaseApprover: &BaseApprover{
            name:     "组长",
            maxDays:  1,
        },
    }
}

func (a *TeamLeader) HandleRequest(request *LeaveRequest) bool {
    if request.Days <= a.maxDays {
        fmt.Printf("[%s] ✅ 批准了申请: %s\n", a.name, request.String())
        return true
    }
    // 审批不了，传递给下一个
    fmt.Printf("[%s] ❌ 无法审批%d天以内的假，传递给下一个\n", a.name, request.Days)
    if a.next != nil {
        return a.next.HandleRequest(request)
    }
    fmt.Println("⚠️ 没有人能审批这个申请！")
    return false
}

// Manager 经理，可以审批3天以内的假
type Manager struct {
    *BaseApprover
}

func NewManager() *Manager {
    return &Manager{
        BaseApprover: &BaseApprover{
            name:     "经理",
            maxDays:  3,
        },
    }
}

func (m *Manager) HandleRequest(request *LeaveRequest) bool {
    if request.Days <= m.maxDays {
        fmt.Printf("[%s] ✅ 批准了申请: %s\n", m.name, request.String())
        return true
    }
    fmt.Printf("[%s] ❌ 无法审批%d天以内的假，传递给下一个\n", m.name, request.Days)
    if m.next != nil {
        return m.next.HandleRequest(request)
    }
    fmt.Println("⚠️ 没有人能审批这个申请！")
    return false
}

// Director 总监，可以审批7天以内的假
type Director struct {
    *BaseApprover
}

func NewDirector() *Director {
    return &Director{
        BaseApprover: &BaseApprover{
            name:     "总监",
            maxDays:  7,
        },
    }
}

func (d *Director) HandleRequest(request *LeaveRequest) bool {
    if request.Days <= d.maxDays {
        fmt.Printf("[%s] ✅ 批准了申请: %s\n", d.name, request.String())
        return true
    }
    fmt.Printf("[%s] ❌ 无法审批%d天以内的假，传递给下一个\n", d.name, request.Days)
    if d.next != nil {
        return d.next.HandleRequest(request)
    }
    fmt.Println("⚠️ 没有人能审批这个申请！")
    return false
}

// HR 人力资源，可以审批所有假期
type HR struct {
    *BaseApprover
}

func NewHR() *HR {
    return &HR{
        BaseApprover: &BaseApprover{
            name:     "HR",
            maxDays:  999, // HR可以审批任意天数
        },
    }
}

func (h *HR) HandleRequest(request *LeaveRequest) bool {
    if request.Days <= h.maxDays {
        fmt.Printf("[%s] ✅ 批准了申请（顺便存档）: %s\n", h.name, request.String())
        return true
    }
    fmt.Println("⚠️ 没有人能审批这个申请！")
    return false
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// ========== 第五步：构建责任链 ==========

// BuildApprovalChain 构建审批链（注意：这里只是构建链式结构，不会触发审批）
func BuildApprovalChain() *TeamLeader {
    // 从链头开始
    leader := NewTeamLeader()
    manager := NewManager()
    director := NewDirector()
    hr := NewHR()

    // 设置责任链的传递顺序：组长 -> 经理 -> 总监 -> HR
    leader.SetNext(manager)
    manager.SetNext(director)
    director.SetNext(hr)

    return leader
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

func main() {
    fmt.Println("=== 责任链模式：请假审批流程 ===\n")

    // 构建审批链（静默构建，不打印）
    leader := &SilentApprover{name: "组长", maxDays: 1}
    manager := &SilentApprover{name: "经理", maxDays: 3}
    director := &SilentApprover{name: "总监", maxDays: 7}
    hr := &SilentApprover{name: "HR", maxDays: 999}

    leader.next = manager
    manager.next = director
    director.next = hr

    // ===== 场景1：请假1天 =====
    fmt.Println("\n--- 场景1: 请假1天 ---")
    request1 := &LeaveRequest{EmployeeName: "张三", Days: 1, Reason: "感冒"}
    leader.HandleRequest(request1)

    // ===== 场景2：请假3天 =====
    fmt.Println("\n--- 场景2: 请假3天 ---")
    request2 := &LeaveRequest{EmployeeName: "李四", Days: 3, Reason: "老家有事"}
    leader.HandleRequest(request2)

    // ===== 场景3：请假7天 =====
    fmt.Println("\n--- 场景3: 请假7天 ---")
    request3 := &LeaveRequest{EmployeeName: "王五", Days: 7, Reason: "出国旅游"}
    leader.HandleRequest(request3)

    // ===== 场景4：请假15天 =====
    fmt.Println("\n--- 场景4: 请假15天 ---")
    request4 := &LeaveRequest{EmployeeName: "赵六", Days: 15, Reason: "创业"}
    leader.HandleRequest(request4)
}

// SilentApprover 是静默版的审批者，用于优化输出
type SilentApprover struct {
    name    string
    maxDays int
    next    *SilentApprover
}

func (a *SilentApprover) HandleRequest(request *LeaveRequest) bool {
    if request.Days <= a.maxDays {
        fmt.Printf("[%s] ✅ 批准了申请: %s\n", a.name, request.String())
        return true
    }
    if a.next != nil {
        fmt.Printf("[%s] ❌ 无法审批%d天以内的假，传递给下一个\n", a.name, request.Days)
        return a.next.HandleRequest(request)
    }
    fmt.Println("⚠️ 没有人能审批这个申请！")
    return false
}