数据结构和算法(Golang实现)(14)常见数据结构-栈和队列
栈和队列
一、栈 Stack 和队列 Queue
我们日常生活中,都需要将物品排列,或者安排事情的先后顺序。更通俗地讲,我们买东西时,人太多的情况下,我们要排队,排队也有先后顺序,有些人早了点来,排完队就离开了,有些人晚一点,才刚刚进去人群排队。
数据是有顺序的,从数据1
到数据2
,再到数据3
,和日常生活一样,我们需要放数据,也需要排列数据。
在计算机的世界里,会经常听见两种结构,栈(stack)
和队列 (queue)
。它们是一种收集数据的有序集合(Collection
),只不过删除和访问数据的顺序不同。
- 栈:先进后出,先进队的数据最后才出来。在英文的意思里,
stack
可以作为一叠的意思,这个排列是垂直的,你将一张纸放在另外一张纸上面,先放的纸肯定是最后才会被拿走,因为上面有一张纸挡住了它。 - 队列:先进先出,先进队的数据先出来。在英文的意思里,
queue
和现实世界的排队意思一样,这个排列是水平的,先排先得。
我们可以用数据结构:链表
(可连续或不连续的将数据与数据关联起来的结构),或数组
(连续的内存空间,按索引取值) 来实现栈(stack)
和队列 (queue)
。
数组实现:能快速随机访问存储的元素,通过下标index
访问,支持随机访问,查询速度快,但存在元素在数组空间中大量移动的操作,增删效率低。
链表实现:只支持顺序访问,在某些遍历操作中查询速度慢,但增删元素快。
二、实现数组栈 ArrayStack
数组形式的下压栈,后进先出:
主要使用可变长数组来实现。
// 数组栈,后进先出
type ArrayStack struct {
array []string // 底层切片
size int // 栈的元素数量
lock sync.Mutex // 为了并发安全使用的锁
}
我们来分析它的各操作。
2.1.入栈
// 入栈
func (stack *ArrayStack) Push(v string) {
stack.lock.Lock()
defer stack.lock.Unlock()
// 放入切片中,后进的元素放在数组最后面
stack.array = append(stack.array, v)
// 栈中元素数量+1
stack.size = stack.size + 1
}
将元素入栈,会先加锁实现并发安全。
入栈时直接把元素放在数组的最后面,然后元素数量加 1。性能损耗主要花在切片追加元素上,切片如果容量不够会自动扩容,底层损耗的复杂度我们这里不计,所以时间复杂度为O(1)
。
2.2.出栈
func (stack *ArrayStack) Pop() string {
stack.lock.Lock()
defer stack.lock.Unlock()
// 栈中元素已空
if stack.size == 0 {
panic("empty")
}
// 栈顶元素
v := stack.array[stack.size-1]
// 切片收缩,但可能占用空间越来越大
//stack.array = stack.array[0 : stack.size-1]
// 创建新的数组,空间占用不会越来越大,但可能移动元素次数过多
newArray := make([]string, stack.size-1, stack.size-1)
for i := 0; i < stack.size-1; i++ {
newArray[i] = stack.array[i]
}
stack.array = newArray
// 栈中元素数量-1
stack.size = stack.size - 1
return v
}
元素出栈,会先加锁实现并发安全。
如果栈大小为0,那么不允许出栈,否则从数组的最后面拿出元素。
元素取出后:
- 如果切片偏移量向前移动
stack.array[0 : stack.size-1]
,表明最后的元素已经不属于该数组了,数组变相的缩容了。此时,切片被缩容的部分并不会被回收,仍然占用着空间,所以空间复杂度较高,但操作的时间复杂度为:O(1)
。 - 如果我们创建新的数组
newArray
,然后把老数组的元素复制到新数组,就不会占用多余的空间,但移动次数过多,时间复杂度为:O(n)
。
最后元素数量减一,并返回值。
2.3.获取栈顶元素
// 获取栈顶元素
func (stack *ArrayStack) Peek() string {
// 栈中元素已空
if stack.size == 0 {
panic("empty")
}
// 栈顶元素值
v := stack.array[stack.size-1]
return v
}
获取栈顶元素,但不出栈。和出栈一样,时间复杂度为:O(1)
。
2.4.获取栈大小和判定是否为空
// 栈大小
func (stack *ArrayStack) Size() int {
return stack.size
}
// 栈是否为空
func (stack *ArrayStack) IsEmpty() bool {
return stack.size == 0
}
一目了然,时间复杂度都是:O(1)
。
2.5.示例
func main() {
arrayStack := new(ArrayStack)
arrayStack.Push("cat")
arrayStack.Push("dog")
arrayStack.Push("hen")
fmt.Println("size:", arrayStack.Size())
fmt.Println("pop:", arrayStack.Pop())
fmt.Println("pop:", arrayStack.Pop())
fmt.Println("size:", arrayStack.Size())
arrayStack.Push("drag")
fmt.Println("pop:", arrayStack.Pop())
}
输出:
size: 3
pop: hen
pop: dog
size: 1
pop: drag
三、实现链表栈 LinkStack
链表形式的下压栈,后进先出:
// 链表栈,后进先出
type LinkStack struct {
root *LinkNode // 链表起点
size int // 栈的元素数量
lock sync.Mutex // 为了并发安全使用的锁
}
// 链表节点
type LinkNode struct {
Next *LinkNode
Value string
}
我们来分析它的各操作。
3.1.入栈
// 入栈
func (stack *LinkStack) Push(v string) {
stack.lock.Lock()
defer stack.lock.Unlock()
// 如果栈顶为空,那么增加节点
if stack.root == nil {
stack.root = new(LinkNode)
stack.root.Value = v
} else {
// 否则新元素插入链表的头部
// 原来的链表
preNode := stack.root
// 新节点
newNode := new(LinkNode)
newNode.Value = v
// 原来的链表链接到新元素后面
newNode.Next = preNode
// 将新节点放在头部
stack.root = newNode
}
// 栈中元素数量+1
stack.size = stack.size + 1
}
将元素入栈,会先加锁实现并发安全。
如果栈里面的底层链表为空,表明没有元素,那么新建节点并设置为链表起点:stack.root = new(LinkNode)
。
否则取出老的节点:preNode := stack.root
,新建节点:newNode := new(LinkNode)
,然后将原来的老节点链接在新节点后面:newNode.Next = preNode
,最后将新节点设置为链表起点stack.root = newNode
。
时间复杂度为:O(1)
。
3.2.出栈
// 出栈
func (stack *LinkStack) Pop() string {
stack.lock.Lock()
defer stack.lock.Unlock()
// 栈中元素已空
if stack.size == 0 {
panic("empty")
}
// 顶部元素要出栈
topNode := stack.root
v := topNode.Value
// 将顶部元素的后继链接链上
stack.root = topNode.Next
// 栈中元素数量-1
stack.size = stack.size - 1
return v
}
元素出栈。如果栈大小为0,那么不允许出栈。
直接将链表的第一个节点topNode := stack.root
的值取出,然后将表头设置为链表的下一个节点:stack.root = topNode.Next
,相当于移除了链表的第一个节点。
时间复杂度为:O(1)
。
3.3.获取栈顶元素
// 获取栈顶元素
func (stack *LinkStack) Peek() string {
// 栈中元素已空
if stack.size == 0 {
panic("empty")
}
// 顶部元素值
v := stack.root.Value
return v
}
获取栈顶元素,但不出栈。和出栈一样,时间复杂度为:O(1)
。
3.4.获取栈大小和判定是否为空
// 栈大小
func (stack *LinkStack) Size() int {
return stack.size
}
// 栈是否为空
func (stack *LinkStack) IsEmpty() bool {
return stack.size == 0
}
3.5.示例
func main() {
linkStack := new(LinkStack)
linkStack.Push("cat")
linkStack.Push("dog")
linkStack.Push("hen")
fmt.Println("size:", linkStack.Size())
fmt.Println("pop:", linkStack.Pop())
fmt.Println("pop:", linkStack.Pop())
fmt.Println("size:", linkStack.Size())
linkStack.Push("drag")
fmt.Println("pop:", linkStack.Pop())
}
输出:
size: 3
pop: hen
pop: dog
size: 1
pop: drag
四、实现数组队列 ArrayQueue
队列先进先出,和栈操作顺序相反,我们这里只实现入队,和出队操作,其他操作和栈一样。
// 数组队列,先进先出
type ArrayQueue struct {
array []string // 底层切片
size int // 队列的元素数量
lock sync.Mutex // 为了并发安全使用的锁
}
4.1.入队
// 入队
func (queue *ArrayQueue) Add(v string) {
queue.lock.Lock()
defer queue.lock.Unlock()
// 放入切片中,后进的元素放在数组最后面
queue.array = append(queue.array, v)
// 队中元素数量+1
queue.size = queue.size + 1
}
直接将元素放在数组最后面即可,和栈一样,时间复杂度为:O(n)
。
4.2.出队
// 出队
func (queue *ArrayQueue) Remove() string {
queue.lock.Lock()
defer queue.lock.Unlock()
// 队中元素已空
if queue.size == 0 {
panic("empty")
}
// 队列最前面元素
v := queue.array[0]
/* 直接原位移动,但缩容后继的空间不会被释放
for i := 1; i < queue.size; i++ {
// 从第一位开始进行数据移动
queue.array[i-1] = queue.array[i]
}
// 原数组缩容
queue.array = queue.array[0 : queue.size-1]
*/
// 创建新的数组,移动次数过多
newArray := make([]string, queue.size-1, queue.size-1)
for i := 1; i < queue.size; i++ {
// 从老数组的第一位开始进行数据移动
newArray[i-1] = queue.array[i]
}
queue.array = newArray
// 队中元素数量-1
queue.size = queue.size - 1
return v
}
出队,把数组的第一个元素的值返回,并对数据进行空间挪位,挪位有两种:
- 原地挪位,依次补位
queue.array[i-1] = queue.array[i]
,然后数组缩容:queue.array = queue.array[0 : queue.size-1]
,但是这样切片缩容的那部分内存空间不会释放。 - 创建新的数组,将老数组中除第一个元素以外的元素移动到新数组。
时间复杂度是:O(n)
。
五、实现链表队列 LinkQueue
队列先进先出,和栈操作顺序相反,我们这里只实现入队,和出队操作,其他操作和栈一样。
// 链表队列,先进先出
type LinkQueue struct {
root *LinkNode // 链表起点
size int // 队列的元素数量
lock sync.Mutex // 为了并发安全使用的锁
}
// 链表节点
type LinkNode struct {
Next *LinkNode
Value string
}
5.1.入队
// 入队
func (queue *LinkQueue) Add(v string) {
queue.lock.Lock()
defer queue.lock.Unlock()
// 如果栈顶为空,那么增加节点
if queue.root == nil {
queue.root = new(LinkNode)
queue.root.Value = v
} else {
// 否则新元素插入链表的末尾
// 新节点
newNode := new(LinkNode)
newNode.Value = v
// 一直遍历到链表尾部
nowNode := queue.root
for nowNode.Next != nil {
nowNode = nowNode.Next
}
// 新节点放在链表尾部
nowNode.Next = newNode
}
// 队中元素数量+1
queue.size = queue.size + 1
}
将元素放在链表的末尾,所以需要遍历链表,时间复杂度为:O(n)
。
5.2.出队
// 出队
func (queue *LinkQueue) Remove() string {
queue.lock.Lock()
defer queue.lock.Unlock()
// 队中元素已空
if queue.size == 0 {
panic("empty")
}
// 顶部元素要出队
topNode := queue.root
v := topNode.Value
// 将顶部元素的后继链接链上
queue.root = topNode.Next
// 队中元素数量-1
queue.size = queue.size - 1
return v
}
链表第一个节点出队即可,时间复杂度为:O(1)
。
系列文章入口
我是陈星星,欢迎阅读我亲自写的 数据结构和算法(Golang实现),文章首发于 阅读更友好的GitBook。
- 数据结构和算法(Golang实现)(1)简单入门Golang-前言
- 数据结构和算法(Golang实现)(2)简单入门Golang-包、变量和函数
- 数据结构和算法(Golang实现)(3)简单入门Golang-流程控制语句
- 数据结构和算法(Golang实现)(4)简单入门Golang-结构体和方法
- 数据结构和算法(Golang实现)(5)简单入门Golang-接口
- 数据结构和算法(Golang实现)(6)简单入门Golang-并发、协程和信道
- 数据结构和算法(Golang实现)(7)简单入门Golang-标准库
- 数据结构和算法(Golang实现)(8.1)基础知识-前言
- 数据结构和算法(Golang实现)(8.2)基础知识-分治法和递归
- 数据结构和算法(Golang实现)(9)基础知识-算法复杂度及渐进符号
- 数据结构和算法(Golang实现)(10)基础知识-算法复杂度主方法
- 数据结构和算法(Golang实现)(11)常见数据结构-前言
- 数据结构和算法(Golang实现)(12)常见数据结构-链表
- 数据结构和算法(Golang实现)(13)常见数据结构-可变长数组
- 数据结构和算法(Golang实现)(14)常见数据结构-栈和队列
- 数据结构和算法(Golang实现)(15)常见数据结构-列表
- 数据结构和算法(Golang实现)(16)常见数据结构-字典
- 数据结构和算法(Golang实现)(17)常见数据结构-树
- 数据结构和算法(Golang实现)(18)排序算法-前言
- 数据结构和算法(Golang实现)(19)排序算法-冒泡排序
- 数据结构和算法(Golang实现)(20)排序算法-选择排序
- 数据结构和算法(Golang实现)(21)排序算法-插入排序
- 数据结构和算法(Golang实现)(22)排序算法-希尔排序
- 数据结构和算法(Golang实现)(23)排序算法-归并排序
- 数据结构和算法(Golang实现)(24)排序算法-优先队列及堆排序
- 数据结构和算法(Golang实现)(25)排序算法-快速排序
- 数据结构和算法(Golang实现)(26)查找算法-哈希表
- 数据结构和算法(Golang实现)(27)查找算法-二叉查找树
- 数据结构和算法(Golang实现)(28)查找算法-AVL树
- 数据结构和算法(Golang实现)(29)查找算法-2-3树和左倾红黑树
- 数据结构和算法(Golang实现)(30)查找算法-2-3-4树和普通红黑树
数据结构和算法(Golang实现)(14)常见数据结构-栈和队列的更多相关文章
- 数据结构和算法(Golang实现)(11)常见数据结构-前言
常见数据结构及算法 数据结构主要用来组织数据,也作为数据的容器,载体. 各种各样的算法,都需要使用一定的数据结构来组织数据. 常见的典型数据结构有: 链表 栈和队列 树 图 上述可以延伸出各种各样的术 ...
- 数据结构和算法(Golang实现)(12)常见数据结构-链表
链表 讲数据结构就离不开讲链表.因为数据结构是用来组织数据的,如何将一个数据关联到另外一个数据呢?链表可以将数据和数据之间关联起来,从一个数据指向另外一个数据. 一.链表 定义: 链表由一个个数据节点 ...
- 数据结构和算法(Golang实现)(13)常见数据结构-可变长数组
可变长数组 因为数组大小是固定的,当数据元素特别多时,固定的数组无法储存这么多的值,所以可变长数组出现了,这也是一种数据结构.在Golang语言中,可变长数组被内置在语言里面:切片slice. sli ...
- 数据结构和算法(Golang实现)(15)常见数据结构-列表
列表 一.列表 List 我们又经常听到列表 List数据结构,其实这只是更宏观的统称,表示存放数据的队列. 列表List:存放数据,数据按顺序排列,可以依次入队和出队,有序号关系,可以取出某序号的数 ...
- 数据结构和算法(Golang实现)(16)常见数据结构-字典
字典 我们翻阅书籍时,很多时候都要查找目录,然后定位到我们要的页数,比如我们查找某个英文单词时,会从英语字典里查看单词表目录,然后定位到词的那一页. 计算机中,也有这种需求. 一.字典 字典是存储键值 ...
- 数据结构和算法(Golang实现)(17)常见数据结构-树
树 树是一种比较高级的基础数据结构,由n个有限节点组成的具有层次关系的集合. 树的定义: 有节点间的层次关系,分为父节点和子节点. 有唯一一个根节点,该根节点没有父节点. 除了根节点,每个节点有且只有 ...
- 数据结构和算法(Golang实现)(25)排序算法-快速排序
快速排序 快速排序是一种分治策略的排序算法,是由英国计算机科学家Tony Hoare发明的, 该算法被发布在1961年的Communications of the ACM 国际计算机学会月刊. 注:A ...
- 数据结构和算法(Golang实现)(1)简单入门Golang-前言
数据结构和算法在计算机科学里,有非常重要的地位.此系列文章尝试使用 Golang 编程语言来实现各种数据结构和算法,并且适当进行算法分析. 我们会先简单学习一下Golang,然后进入计算机程序世界的第 ...
- 数据结构和算法(Golang实现)(2)简单入门Golang-包、变量和函数
包.变量和函数 一.举个例子 现在我们来建立一个完整的程序main.go: // Golang程序入口的包名必须为 main package main // import "golang&q ...
随机推荐
- Python3学习之路~9.4 队列、生产者消费者模型
一 队列queue 当必须在多个线程之间安全地交换信息时,队列在线程编程中特别有用. 队列的作用:1.解耦,使程序直接实现松耦合 2.提高处理效率 列表与队列都是有顺序的,但是他们之间有一个很大的区别 ...
- 2020年Java基础高频面试题汇总(1.4W字详细解析)
1. Java语言有哪些特点 (1)简单易学.有丰富的类库 (2)面向对象(Java最重要的特性,让程序耦合度更低,内聚性更高) (3)与平台无关性(JVM是Java跨平台使用的根本) (4)可靠安全 ...
- Java日期处理易踩的十个坑
前言 整理了Java日期处理的十个坑,希望对大家有帮助. 一.用Calendar设置时间的坑 反例: Calendar c = Calendar.getInstance(); c.set(Calend ...
- effective-java学习笔记---静态工厂方法替代构造方法
使用静态方法的优点: 1.它们是有名字的,生成的客户端代码更易阅读. 如:返回素数的静态方法 BigInteger.probablePrime 2.与构造方法不同,它们不需要每次调用时都创建一个对象. ...
- [Java8教程]Java8新特性进阶集合
Java8新特性进阶集合 基于 AOP 抽离方法的重复代码 Java8:当 Lambda 遇上受检异常 Java8:对字符串连接的改进 Java8:Java8 中 Map 接口的新方法 Java8:当 ...
- Prism+MaterialDesign+EntityFramework Core+Postgresql WPF开发总结 之 基础篇
本着每天记录一点成长一点的原则,打算将目前完成的一个WPF项目相关的技术分享出来,供团队学习与总结. 总共分三个部分: 基础篇主要争对C#初学者,巩固C#常用知识点: 中级篇主要争对WPF布局与美化, ...
- 自签SSL证书
0.介绍 自己开发的使用了SSL协议的软件,通常没必要从证书签发机构那里来获取证书,自签证书成了必要的选择.自签证书还可以用来实现客户端登录认证. 1.创建CA 创建CA的私钥 openssl gen ...
- coding++:JS数组去重的几种常见方法
一.简单的去重方法 // 最简单数组去重法 /* * 新建一新数组,遍历传入数组,值不在新数组就push进该新数组中 * IE8以下不支持数组的indexOf方法 * */ function uniq ...
- Spring 事务注意事项
使用事务注意事项 1,事务是程序运行如果没有错误,会自动提交事物,如果程序运行发生异常,则会自动回滚. 如果使用了try捕获异常时.一定要在catch里面手动回滚. 事务手动回滚代码 Transact ...
- C++ 趣图
一.心形 1. http://mathworld.wolfram.com/HeartCurve.html #include<stdio.h> using namespace std; in ...