Go基础学习06-Golang标准库container/list(双向链表)深入讲解;延迟初始化技术;Element;List;Ring

基础介绍

单向链表中的每个节点包含数据和指向下一个节点的指针。其特点是每个节点只知道下一个节点的位置,使得数据只能单向遍历。

示意图如下:
在这里插入图片描述

双向链表中的每个节点都包含指向前一个节点和后一个节点的指针。这使得在双向链表中可以从前向后或从后向前遍历。

示意图如下:
在这里插入图片描述

结合上面的图就很容易明白单、双链表的定义。其中双向链表可以从前向后,也可以从后向前遍历,操作起来也更加方便。

接下来我们看看官方给的例子:

import ("container/list""fmt"
)func Example() {// Create a new list and put some numbers in it.l := list.New()e4 := l.PushBack(4)e1 := l.PushFront(1)l.InsertBefore(3, e4)l.InsertAfter(2, e1)// Iterate through list and print its contents.for e := l.Front(); e != nil; e = e.Next() {fmt.Println(e.Value)}// Output:// 1// 2// 3// 4
}

首先调用list.New()创建一个双向链表,然后添加元素Element,最后从头遍历链表,打印每个元素的值。

从上可以看出,container/list提供了两个结构 List、Element。

  • List
  • Element

在Java中实现的双向链表也是这样做的,只是元素一般命名为Node而已。

container/list源码分析

Element

// Element is an element of a linked list.
type Element struct {// Next and previous pointers in the doubly-linked list of elements.// To simplify the implementation, internally a list l is implemented// as a ring, such that &l.root is both the next element of the last// list element (l.Back()) and the previous element of the first list// element (l.Front()).next, prev *Element// The list to which this element belongs.list *List// The value stored with this element.Value any
}

Element 一共定义了四个字段,分别是指向前一个节点的 prev,指向下一个节点的 next,存储值的 Value,以及 此元素属于哪个list。

平常自己在定义双向链表 Node 的结构的时候,一般是不会有 list 这个元素的,为什么官方给的有这个元素呢?

  • Element 的 list 字段是小写的,那意味着外部使用者是无法获取和定义此字段的,也就是说外部使用者无法通过 Element 来操作 链表。在通篇读过源码后,发现 Element.list 是用于判断插入、移动、删除等操作的元素是否属于此链表,所以我认为增加 list 字段的原因主要是安全性。
    比如防止在多维链表操作的时候,错误的加入了不属于此链表的节点,有了 list 字段后,就可以做判断,防止这类情况产生。
  • 对于Element的扩展字段list可以将其理解为与链表的跟节点root绑定的一个值,通过Element.list可以获取这个链表,从而获取root值,用于一些判断,主要在源码中使用,有链表基础的建议查阅源码学习

Element 只有两个方法,即 Next()、Prev(),源代码如下:

// Next returns the next list element or nil.
func (e *Element) Next() *Element {if p := e.next; e.list != nil && p != &e.list.root {return p}return nil
}// Prev returns the previous list element or nil.
func (e *Element) Prev() *Element {if p := e.prev; e.list != nil && p != &e.list.root {return p}return nil
}

看到这里,官方给的实现方式,并不是简单的 e.prev、e.next,而是多了p != &e.list.root的判断,为什么会有这个判断呢?

因为container/list起始是一个环形链表,那么就需要有一个特殊的节点切断这种环形关系,root就是用来做这个标识的节点。

这样做有什么好处呢?

root 字段是链表的根节点,它并不直接存储数据,而是一个空节点(Element 类型)。这个空节点被用作链表的哨兵节点(Sentinel Node)或者叫做标志节点(Dummy Node)。

这个哨兵节点的作用是为了简化链表的操作。通过将哨兵节点作为链表的根节点,在实际的链表操作中,就无需考虑头节点为空的情况,即空链表和非空链表的操作逻辑变得更加统一和简化。

  • 简化逻辑: 哨兵节点的引入避免了对空链表的特殊处理。无论链表是否为空,头节点(哨兵节点之后的第一个节点)始终存在,这样在操作链表时就无需针对空链表做额外的判断。
  • 边界条件更清晰: 有了哨兵节点,链表的头部和尾部都有了固定的节点作为标志,使得链表操作时边界条件更加清晰。
  • 提高代码的一致性: 通过哨兵节点,链表的操作逻辑更加统一,减少了特殊情况下的代码分支,提高了代码的一致性和可读性。

List

List结构

// List represents a doubly linked list.
// The zero value for List is an empty list ready to use.
type List struct {root Element // sentinel list element, only &root, root.prev, and root.next are usedlen  int     // current list length excluding (this) sentinel element
}// Init initializes or clears list l.
func (l *List) Init() *List {l.root.next = &l.rootl.root.prev = &l.rootl.len = 0return l
}// New returns an initialized list.
func New() *List { return new(List).Init() }// Len returns the number of elements of list l.
// The complexity is O(1).
func (l *List) Len() int { return l.len }

因为container/list 是一个环形链表,所以只用提供一个节点就可以了。

注意:刚初始化时,即调用New生成的链表对象,此时的 root.next、root.prev 都是指向root 自己的 。当使用 PushBack或者PushFront方法后,root.next 表示 Head Node,root.prev 表示 Tail Node。注意 List.len 的长度是不包含 root 节点的。方法后,root.next 表示 Head Node,root.prev 表示 Tail Node。注意 List.len 的长度是不包含 root 节点的。
在这里插入图片描述

获取头尾节点

// Front returns the first element of list l or nil if the list is empty.
func (l *List) Front() *Element {if l.len == 0 {return nil}return l.root.next
}// Back returns the last element of list l or nil if the list is empty.
func (l *List) Back() *Element {if l.len == 0 {return nil}return l.root.prev
}

root.next 表示 Head Node,root.prev 表示 Tail Node。

Go中链表的延迟初始化机制

示例代码:

	// 声明一个链表但未初始化,随后使用链表的延迟初始化技术在插入元素时进行初始化(lazyInit)l2 := list.List{}fmt.Println(l2)l2.PushBack(3)fmt.Println(l2)

运行结果:

{{<nil> <nil> <nil> <nil>} 0}
{{0xc0000b62a0 0xc0000b62a0 <nil> <nil>} 1}

使用l2 := list.List{}声明的链表l2,可以正常使用,但仅仅凭借l2这个链表是无法正常使用的,需要结果Go中链表的延迟初始化 机制才可以使用。
查看Go中container/list的源码中的PushBack()方法:

// PushBack inserts a new element e with value v at the back of list l and returns e.
func (l *List) PushBack(v any) *Element {l.lazyInit()return l.insertValue(v, l.root.prev)
}// lazyInit lazily initializes a zero List value.
func (l *List) lazyInit() {if l.root.next == nil {l.Init()}
}// Init initializes or clears list l.
func (l *List) Init() *List {l.root.next = &l.rootl.root.prev = &l.rootl.len = 0return l
}

通过上述源码可以看到lazeInit()这个函数,这个函数就是链表的延迟初始化技术,只有在使用到的时候才对链表进行初始化。

  • 延迟初始化:把初始化操作延后,仅在实际需要的时候才进行。延迟初始化的优点在于“延后”,它可以分散初始化操作带来的计算量和存储空间消耗。

例如,如果我们需要集中声明非常多的大容量切片的话,那么那时的 CPU 和内存空间的使用量肯定都会一个激增,并且,只有设法让其中的切片及其底层数组被回收,内存使用量才会有所降低。
如果数组是可以被延迟初始化的,那么计算量和存储空间的压力就可以被分散到实际使用它们的时候。这些数组被实际使用的时间越分散,延迟初始化带来的优势就会越明显。可以对照Java中的数组的扩容,以及Go中切片的扩容都是延迟化思想的体现。

  • 延迟初始化是否有缺点以及Go是如何减小延迟初始化对链表操作的影响

延迟初始化的缺点恰恰也在于“延后”,如果我在调用链表的每个方法的时候,它们都需要先去判断链表是否已经被初始化,那这也会是一个计算量上的浪费。在这些方法被非常频繁地调用的情况下,这种浪费的影响就开始显现了,程序的性能将会降低。
>在Go语言链表设计中只对插入操作如:PushFront方法、PushBack方法、PushBackList方法以及PushFrontList方法在执行时总是会先判断链表的状态,并在必要时进行初始化,一旦初始化后,后续在执行这些方法的时候就无需进行初始化,可以直接使用。

  • 此外在Go语言设计中对于删除元素、移动元素,以及一些用于插入元素的方法中,只要判断一下传入的元素中指向所属链表的指针,是否与当前链表的指针相等就可以了。如果不相等,就一定说明传入的元素不是这个链表中的,后续的操作就不用做了。反之,就一定
    说明这个链表已经被初始化了。
    此时使用到Element元素的list属性,这个操作是内部源码调用的。
// Remove removes e from l if e is an element of list l.
// It returns the element value e.Value.
// The element must not be nil.
func (l *List) Remove(e *Element) any {if e.list == l {// if e.list == l, l must have been initialized when e was inserted// in l or l == nil (e is a zero Element) and l.remove will crashl.remove(e)}return e.Value
}
  • 对于Front方法和Back方法,只需对链表的长度进行判断即可,一旦发现链表的长度为0直接返回nil就好了。

container包中的list和ring包中的List和Ring的区别

container/ring包中的Ring类型实现的是一个循环链表,也就是我们俗称的环。其实List在内部就是一个循环链表。它的根元素永远不会持有任何实际的元素值,而该元素的存在,就是为了连接这个循环链表的首尾两端。
所以也可以说,List的零值是一个只包含了根元素,但不包含任何实际元素值的空链表。那么,既然Ring和List在本质上都是循环链表,那它们到底有什么不同呢?最主要的不同有下面几种。

  1. Ring类型的数据结构仅由它自身即可代表,而List类型则需要由它以及Element类型联合表示。这是表示方式上的不同,也是结构复杂度上的不同。
  2. 一个Ring类型的值严格来讲,只代表了其所属的循环链表中的一个元素,而一个List类型的值则代表了一个完整的链表。这是表示维度上的不同。
  3. 在创建并初始化一个Ring值的时候,我们可以指定它包含的元素的数量,但是对于一个List值来说,却不能这样做(也没有必要这样做)。循环链表一旦被创建,其长度是不可变的。这是两个代码包中的New函数在功能上的不同,也是两个类型在初始化值方面的第一个不同。
  4. 仅通过var r ring.Ring语句声明的r将会是一个长度为1的循环链表,而List类型的零值则是一个长度为0的链表。别忘了List中的根元素不会持有实际元素值,因此计算长度时不会包含它。这是两个类型在初始化值方面的第二个不同。
  5. Ring值的Len方法的算法复杂度是 O(N) 的,而List值的Len方法的算法复杂度则是 O(1)的。这是两者在性能方面最显而易见的差别。其他的不同基本上都是方法方面的了。比如,循环链表也有用于插入、移动或删除元素的方法,不过用起来都显得更抽象一些,等等。
    上述内容参考极客时间Go语言核心36讲

Go语言提供的链表常用API

// Remove removes e from l if e is an element of list l.
// It returns the element value e.Value.
// The element must not be nil.
func (l *List) Remove(e *Element) any {if e.list == l {// if e.list == l, l must have been initialized when e was inserted// in l or l == nil (e is a zero Element) and l.remove will crashl.remove(e)}return e.Value
}// PushFront inserts a new element e with value v at the front of list l and returns e.
func (l *List) PushFront(v any) *Element {l.lazyInit()return l.insertValue(v, &l.root)
}// PushBack inserts a new element e with value v at the back of list l and returns e.
func (l *List) PushBack(v any) *Element {l.lazyInit()return l.insertValue(v, l.root.prev)
}// InsertBefore inserts a new element e with value v immediately before mark and returns e.
// If mark is not an element of l, the list is not modified.
// The mark must not be nil.
func (l *List) InsertBefore(v any, mark *Element) *Element {if mark.list != l {return nil}// see comment in List.Remove about initialization of lreturn l.insertValue(v, mark.prev)
}// InsertAfter inserts a new element e with value v immediately after mark and returns e.
// If mark is not an element of l, the list is not modified.
// The mark must not be nil.
func (l *List) InsertAfter(v any, mark *Element) *Element {if mark.list != l {return nil}// see comment in List.Remove about initialization of lreturn l.insertValue(v, mark)
}// MoveToFront moves element e to the front of list l.
// If e is not an element of l, the list is not modified.
// The element must not be nil.
func (l *List) MoveToFront(e *Element) {if e.list != l || l.root.next == e {return}// see comment in List.Remove about initialization of ll.move(e, &l.root)
}// MoveToBack moves element e to the back of list l.
// If e is not an element of l, the list is not modified.
// The element must not be nil.
func (l *List) MoveToBack(e *Element) {if e.list != l || l.root.prev == e {return}// see comment in List.Remove about initialization of ll.move(e, l.root.prev)
}// MoveBefore moves element e to its new position before mark.
// If e or mark is not an element of l, or e == mark, the list is not modified.
// The element and mark must not be nil.
func (l *List) MoveBefore(e, mark *Element) {if e.list != l || e == mark || mark.list != l {return}l.move(e, mark.prev)
}// MoveAfter moves element e to its new position after mark.
// If e or mark is not an element of l, or e == mark, the list is not modified.
// The element and mark must not be nil.
func (l *List) MoveAfter(e, mark *Element) {if e.list != l || e == mark || mark.list != l {return}l.move(e, mark)
}// PushBackList inserts a copy of another list at the back of list l.
// The lists l and other may be the same. They must not be nil.
func (l *List) PushBackList(other *List) {l.lazyInit()for i, e := other.Len(), other.Front(); i > 0; i, e = i-1, e.Next() {l.insertValue(e.Value, l.root.prev)}
}// PushFrontList inserts a copy of another list at the front of list l.
// The lists l and other may be the same. They must not be nil.
func (l *List) PushFrontList(other *List) {l.lazyInit()for i, e := other.Len(), other.Back(); i > 0; i, e = i-1, e.Prev() {l.insertValue(e.Value, &l.root)}
}

贴一个其他博主使用Go中的container/list实现的一个二维链表

有了上面的基础后,我们再来实战下。

需求:实现一个二维链表,要求第一维以价格从低到高排序,第二维以时间从小到大排序。

package mainimport ("container/list""fmt""sort""strings""time"
)type Order struct {Price       float64CreatedTime time.Time
}// TwoDList 二维链表,要求第一维以价格从低到高排序,第二维以时间从小到大排序。
type TwoDList struct {// 索引相同,即表示价格相同,同一索引的链表节点,越靠后时间越大// 索引越大,价格越高Rows []*list.List
}func NewTwoDList() *TwoDList {return &TwoDList{Rows: make([]*list.List, 0),}
}func (tdl *TwoDList) AddNode(price float64, createdTime time.Time) {order := &Order{Price: price, CreatedTime: createdTime}// 1、index := sort.Search(len(tdl.Rows), func(i int) bool {return tdl.Rows[i].Front().Value.(*Order).Price >= order.Price})if index == len(tdl.Rows) {// 此价格不存在 tdl 中, 新增newList := list.New()newList.PushFront(order)tdl.Rows = append(tdl.Rows, newList)return}// 判断 index 处的价格是否和 order.Price 相等,// 相等, 则往链表添加// 不相等, 则需要先将 index 之后的往后移一位if order.Price != tdl.Rows[index].Front().Value.(*Order).Price {newList := list.New()newList.PushFront(order)// 插入元素 newListtdl.Rows = append(tdl.Rows[:index], append([]*list.List{newList}, tdl.Rows[index:]...)...)return}// 时间从小到大排curRow := tdl.Rows[index]insertPosition := curRow.Front()for insertPosition != nil && order.CreatedTime.After(insertPosition.Value.(*Order).CreatedTime) {insertPosition = insertPosition.Next()}if insertPosition == nil {curRow.PushBack(order)} else {curRow.InsertBefore(order, insertPosition)}
}func (tdl *TwoDList) Print() {for i, row := range tdl.Rows {fmt.Printf("index: %d\n", i)for node := row.Front(); node != nil; node = node.Next() {order := node.Value.(*Order)fmt.Printf("order price: %f, time: %v \n", order.Price, order.CreatedTime)}fmt.Println(strings.Repeat("-", 20))}
}func main() {// 创建一个新的二维链表myTwoDList := NewTwoDList()// 向二维链表添加节点myTwoDList.AddNode(100, time.Now())myTwoDList.AddNode(75, time.Now().Add(time.Hour))myTwoDList.AddNode(75, time.Now().Add(time.Hour))myTwoDList.AddNode(150, time.Now().Add(2*time.Hour))myTwoDList.AddNode(75, time.Now().Add(3*time.Hour))myTwoDList.AddNode(200, time.Now().Add(4*time.Hour))// 打印二维链表myTwoDList.Print()
}

参考链接

博客园-点击

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/880801.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

无人机之数据提取篇

一、无人机平台与传感器 无人机是进行数据采集的基础设施&#xff0c;其稳定性、可靠性、灵活性和负载能力直接影响到数据采集的效果。根据实际需求&#xff0c;需选择适合的无人机类型&#xff0c;如固定翼无人机适合大范围、长时间的数据采集&#xff0c;而多旋翼无人机则更适…

HTML基础用法介绍一

VS code 如何快速生成HTML骨架注释是什么&#xff1f;为什么要写注释&#xff1f;注释的标签是什么&#xff1f;标题标签段落标签换行标签与水平线标签 (都是单标签&#xff09;文本格式化标签图片标签超链接标签音频标签视频标签 &#x1f698;正片开始 VS code 如何快速生成…

基于Spring框架的分层解耦详解

博客主页&#xff1a;誓则盟约系列专栏&#xff1a;Java Web关注博主&#xff0c;后期持续更新系列文章如果有错误感谢请大家批评指出&#xff0c;及时修改感谢大家点赞&#x1f44d;收藏⭐评论✍ Java Web 三层架构&#xff1a; Java Web可以大致被分为三层架构&#xff1a;…

成都睿明智科技有限公司抖音电商服务靠谱吗?

在这个电商风起云涌的时代&#xff0c;抖音作为短视频直播的超级流量池&#xff0c;正深刻改变着人们的购物习惯。无数商家蜂拥而至&#xff0c;渴望在这片蓝海中找到属于自己的岛屿。而提及抖音电商服务&#xff0c;成都睿明智科技有限公司无疑是一个备受瞩目的名字。那么&…

Linux 进程的基本概念及描述

目录 0.前言 1. 什么是进程 1.1 进程的定义与特性 1.2 进程与线程的区别 2.描述进程 2.1 PCB (进程控制块) 2.2 task_struct 3.查看进程 3.1 查看进程信息 3.1.1 /proc 文件系统 3.1.2 ps 命令 3.1.2 top 和 htop 命令 3.2 获取进程标识符 3.2.1使用命令获取PID 3.2.2 使用C语言…

加密与安全_HTOP 一次性密码生成算法

文章目录 HOTP 的基础原理HOTP 的工作流程HOTP 的应用场景HOTP 的安全性安全性增强措施Code生成HOTP可配置项校验HOTP可拓展功能计数器&#xff08;counter&#xff09;计数器在客户端和服务端的作用计数器的同步机制客户端和服务端中的计数器表现服务端如何处理计数器不同步计…

AIGC学习笔记—minimind详解+训练+推理

前言 这个开源项目是带我的一个导师&#xff0c;推荐我看的&#xff0c;记录一下整个过程&#xff0c;总结一下收获。这个项目的slogan是“大道至简”&#xff0c;确实很简。作者说是这个项目为了帮助初学者快速入门大语言模型&#xff08;LLM&#xff09;&#xff0c;通过从零…

vue3学习记录-computed

vue3学习记录-computed 1.为什么要用computed2.使用方法2.1 基本实例2.2 可写计算属性 1.为什么要用computed 写个购物车的案例 <script setup> import { ref, reactive,computed } from "vue" const tableData reactive([{ name: 商品1, price: 10, num: 1…

3. 轴指令(omron 机器自动化控制器)——>MC_MoveRelative

机器自动化控制器——第三章 轴指令 5 MC_MoveRelative变量▶输入变量▶输出变量▶输入输出变量 功能说明▶指令详情▶时序图▶重启运动指令▶多重启动运动指令▶异常 MC_MoveRelative 指定自指令当前位置起的移动距离&#xff0c;进行定位。 指令名称FB/FUN图形表现ST表现MC…

JVM(HotSpot):字符串常量池(StringTable)

文章目录 一、内存结构图二、案例讲解三、总结 一、内存结构图 JDK1.6 JDK1.8 我们发现&#xff0c;StringTable移入了Heap里面。所以&#xff0c;应该想到&#xff0c;StringTable将受到GC管理。 其实&#xff0c;1.6中&#xff0c;在方法区中的时候&#xff0c;也是受GC管…

从底层理解为什么常量区中的代码不能被修改?

目录 前言&#xff1a;一、了解虚拟地址二、页表映射三、常量区不能被修改的原理四、常量区不可修改的意义 前言&#xff1a; 平时我们在编写代码时都会用到或遇到所谓的常量区或者不可修改的代码&#xff0c;比如说用双引号包起来字符串&#xff08;“Hello World”&#xff…

微服务SpringSession解析部署使用全流程

目录 1、SpringSession简介 2、实现session共享的三种方式 1、修改Tomcat配置文件 2、Nginx负载均衡策略 3、redis统一存储 0、准备工作 1、本地服务添加依赖 2、修改本地服务配置文件 3、添加application.properties文件 4、添加nacos - redis配置 5、修改本地项目…

Linux启动mysql报错

甲方公司意外停电&#xff0c;所有服务器重启后&#xff0c;发现部署在Linux上的mysql数据库启动失败.再加上老员工离职&#xff0c;新接手项目&#xff0c;对Linux系统了解不多&#xff0c;解决起来用时较多&#xff0c;特此记录。 1.启动及报错 1.1 启动语句1 启动语句1&a…

全站最详细的Python环境配置步骤

1、官网下载IDE JetBrains下载 2、IDE下载、安装步骤 这里展示的是如何在Windows上下载、安装Pycharm工具&#xff0c;Linux的步骤类似。 2.1、选择开发者工具 选择开发者工具 2.2、选择Pycharm 选择Pycharm 2.3、选择下载 选择下载 2.4、选择社区版 一般而言&#xff…

基于SpringBoot+Vue的留守儿童爱心网站系统

作者&#xff1a;计算机学姐 开发技术&#xff1a;SpringBoot、SSM、Vue、MySQL、JSP、ElementUI、Python、小程序等&#xff0c;“文末源码”。 专栏推荐&#xff1a;前后端分离项目源码、SpringBoot项目源码、Vue项目源码、SSM项目源码、微信小程序源码 精品专栏&#xff1a;…

MyBatis的注入问题

对之前文章的补充&#xff1a;MyBatis中的#{}与${}注入问题----原文链接 前言&#xff1a; MyBatis是一个流行的Java持久层框架&#xff0c;用于将对象与数据库中的数据进行映射。然而&#xff0c;如果不当使用&#xff0c;MyBatis也可能受到诸如SQL注入这类的安全问题的影响。…

解决VRM格式模型在Unity中运行出现头发乱飞等问题

1、问题 通过VRoidStudio制作导出的vrm格式的模型&#xff0c;放在unity中使用时&#xff0c;一运行就会出现头发乱飞&#xff0c;没有自然下垂的问题 2、解决方法 将模型下的secondary中的所有VRM Spring Bone脚本中的Drag Force改为1&#xff0c;Hit Radius改为0 修改后…

JAVA笔记 | 实际上用到的策略模式(可直接套用)

自己开发中用到了策略模式&#xff0c;这样写不一定是最好的&#xff0c;但是满足了业务场景跟使用要求&#xff0c;做个笔记&#xff0c;下次有用到可以快速复习跟套用 假设使用场景&#xff1a;有几只宠物&#xff0c;猫跟狗等&#xff0c;要求他们做各种动作&#xff0c;比如…

828华为云征文 | 华为云Flexus云服务器X实例搭建Zabbix网络设备监视系统(Ubuntu服务器运维)

前言 Flexus X实例内嵌智能应用调优算法&#xff0c;性能强悍&#xff0c;基础模式GeekBench单核及多核跑分可达同规格独享型实例的1.6倍&#xff0c;性能模式更是超越多系列旗舰型云主机&#xff0c;为企业业务提供强劲动力。 &#x1f4bc; Flexus X Zabbix&#xff1a;打造…

PWM驱动LED呼吸灯

背景知识&#xff1a;TIM输出比较-CSDN博客 stm32f10x_tim.h函数 // *** OC是Output Compare输出比较函数 void TIM_OC1Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct); void TIM_OC2Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct); void TI…