数据结构与算法03：栈

最新推荐文章于 2024-05-16 08:58:20 发布

浮尘笔记

最新推荐文章于 2024-05-16 08:58:20 发布

阅读量777

点赞数

分类专栏：数据结构与算法文章标签：数据结构算法 golang 笔记链表

本文链接：https://blog.csdn.net/rxbook/article/details/130880001

版权

数据结构与算法专栏收录该内容

12 篇文章 0 订阅

订阅专栏

什么是栈？

栈在函数调用中的应用

栈的应用：如何实现浏览器的前进和后退功能？

每日一练：左右括号匹配

什么是栈？

简单地说，先进后出，后进先出的数据结构就是栈，可以理解为一个纸箱子，往箱子里面放书，一本一本叠上去，取得时候只能从上面取最后放进去的书，最早放进去的最后才会被取出来。栈只允许在一端插入和删除数据，当某个数据集合只涉及在一端插入和删除数据，并且满足后进先出、先进后出的特性，就应该首选“栈”这种数据结构。

与数组或链表相比，栈的操作更为受限，那为什么会出现这种受限的数据结构呢? 从功能上讲，数组或者链表可以替代栈，但问题是数组或者链表的操作过于灵活，对外暴露的接口过多，当数据量很大的时候就会出现一些隐藏的风险。虽然栈限定降低了操作的灵活性，但这使得栈在处理只涉及一端新增和删除数据的问题时效率更高。

栈主要包含两个操作：入栈（在栈顶插入一个数据）和出栈（从栈顶删除一个数据），栈既可以用数组来实现，也可以用链表来实现。下面是在Go语言中分别使用数组和链表实现栈操作的核心代码（完整代码点这里查看）：

// go-algo-demo/stack/StackArray.go
// 基于数组实现的栈
type StackArray struct {
	data []interface{} //栈里面的数据
	top  int           //栈顶指针
}

// 初始化一个栈
func NewArrayStack() *StackArray {
	return &StackArray{
		data: make([]interface{}, 0, 32),
		top:  -1,
	}
}

// 向栈中插入元素
func (this *StackArray) Push(v interface{}) {
	if this.top < 0 {
		this.top = 0
	} else {
		this.top += 1
	}

	if this.top > len(this.data)-1 {
		this.data = append(this.data, v)
	} else {
		this.data[this.top] = v
	}
}

// 从栈中弹出元素
func (this *StackArray) Pop() interface{} {
	if this.IsEmpty() {
		return nil
	}
	v := this.data[this.top]
	this.top -= 1
	return v
}

// 获取当前栈顶的元素
func (this *StackArray) Top() interface{} {
	if this.IsEmpty() {
		return nil
	}
	return this.data[this.top]
}

// 测试
func main() {
	s := NewArrayStack()
	// 向栈中插入元素
	s.Push(1)
	s.Push(2)
	s.Push(3)
	s.Print() //3 2 1

	// 获取当前栈顶的元素
	fmt.Println(s.Top()) //3

	// 从栈中弹出元素
	fmt.Println(s.Pop()) //3
	fmt.Println(s.Pop()) //2
	fmt.Println(s.Pop()) //1
	fmt.Println(s.Pop()) //<nil>
	s.Print()            //empty statck
}

栈存储数据只需要一个大小为 n 的数组就够了，所以空间复杂度是 O(1)；入栈和出栈只涉及栈顶数据的操作，所以时间复杂度也是 O(1)。

如果要实现一个支持动态扩容的栈，可以使用一个可以动态扩容的数组来实现栈，当栈满了之后就申请一个更大的数组，将原来的数据搬移到新数组中。此时，对于出栈操作来说不会涉及内存的重新申请和数据的搬移，所以出栈的时间复杂度仍然是 O(1)。但是对于入栈操作来说，当栈中有空闲空间时，入栈操作的时间复杂度为 O(1)；当空间不够时就需要重新申请内存和数据搬移，时间复杂度就变成了 O(n)。

栈在函数调用中的应用

操作系统给每个线程分配了一块独立的内存空间，这块内存就可以理解为“栈”这种结构, 用来存储函数调用时的临时变量。每进入一个函数，就会将临时变量入栈，当函数执行完成之后再将这个临时变量出栈。还记得吗？在 Go语言的函数和defer用法_浮尘笔记的博客-CSDN博客里面就说过关于栈的逻辑，可以使用defer实现一个函数调用栈，跟踪函数的执行过程。

package main
 
// 使用 defer 跟踪函数的执行过程
func main() {
	defer Trace("main")()
	foo()
}
func Trace(name string) func() {
	println("enter:", name)
	return func() {
		println("exit:", name)
	}
}
 
func foo() {
	defer Trace("foo")()
	bar()
}
func bar() {
	defer Trace("bar")()
}

栈的应用：如何实现浏览器的前进和后退功能？

当打开浏览器依次访问页面 A -> B -> C 之后，然后依次点击浏览器的后退按钮，就可以查看之前浏览过的页面 B 和 A；当后退到页面 A的时候，再点击前进按钮，就可以重新进入页面 B 和 C。但是如果后退到页面 B 之后又点击了新的页面 D，那就无法再通过前进和后退功能查看页面 C 了。

要实现这个功能，可以使用栈这种数据结构，使用两个栈来实现。实现逻辑如下：

比如顺序查看了 A，B，C 三个页面，就依次把 A，B，C压入栈X，当通过浏览器的后退按钮从页面 C 后退到页面 A 之后，就依次把 C 和 B页面从栈 X 中弹出，并且依次放入到栈 Y中。
如果再次进入页面 B，就把 B 再从栈 Y 中出栈并且放入栈 X 中。
如果此时从页面B跳转到新的页面D，那么页面C就无法再通过前进和后退按钮重复查看了，所以需要清空栈 Y。

下面使用Go语言代码实现了这个功能：

// go-algo-demo/stack/Browser.go
package main

import (
	"fmt"
)

type Stack interface {
	Push(v interface{})
	Pop() interface{}
	IsEmpty() bool
	Top() interface{}
	GetTopValue() int
	Flush()
}

type Browser struct {
	forward Stack //前进的栈
	back    Stack //后退的栈
}

// 初始化
func NewBrowser() *Browser {
	return &Browser{
		forward: NewArrayStack(),
		back:    NewArrayStack(),
	}
}

// 打开一个新页面
func (this *Browser) OpenNewPage(addr string) {
	fmt.Printf("打开新页面: %v\n", addr)
	this.back.Push(addr)
	this.forward.Flush()    //清空前进的栈
	this.forward.Push(addr) //把当前最新打开的页面添加到前进的栈
}

// 从已有页面跳转到下一个页面
func (this *Browser) PushNewPage(addr string) {
	fmt.Printf("跳转到: %v\n", addr)
	this.back.Push(addr)
}

// 后退
func (this *Browser) Back() {
	if this.back.GetTopValue() == 0 {
		fmt.Println("已经后退到了第一个页面,无法再次后退")
		return
	}

	this.back.Pop()
	top := this.back.Top()
	this.forward.Push(top)
	fmt.Printf("后退到: %v\n", top)
}

// 前进
func (this *Browser) Forward() {
	if this.forward.GetTopValue() == 0 {
		fmt.Println("已经前进到了最后一个页面,无法再次前进")
		return
	}

	this.forward.Pop()
	top := this.forward.Top()
	this.back.Push(top)
	fmt.Printf("前进到: %v\n", top)
}

// go run Browser.go StackArray.go 
func main() {
	browser := NewBrowser()

	// 依次访问页面 A -> B -> C
	browser.OpenNewPage("www.A.com") //打开新页面: www.A.com
	browser.PushNewPage("www.B.com") //跳转到: www.B.com
	browser.PushNewPage("www.C.com") //跳转到: www.C.com

	// 后退两次, C -> B -> A
	browser.Back() //后退到: www.B.com
	browser.Back() //后退到: www.A.com
	browser.Back() //已经后退到了第一个页面,无法再次后退
	browser.Back() //已经后退到了第一个页面,无法再次后退

	// 前进一次, A -> B
	browser.Forward() //前进到: www.B.com

	//打开一个新页面, A -> B -> D
	browser.OpenNewPage("www.D.com") //打开新页面: www.D.com

	//后退两次, D -> B -> A
	browser.Back() //后退到: www.B.com
	browser.Back() //后退到: www.A.com
	browser.Back() //已经后退到了第一个页面,无法再次后退

	//前进两次, A -> B -> D
	browser.Forward() //前进到: www.B.com
	browser.Forward() //前进到: www.D.com
	browser.Forward() //已经前进到了最后一个页面,无法再次前进
	browser.Forward() //已经前进到了最后一个页面,无法再次前进
}

每日一练：左右括号匹配

力扣20. 有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。每个右括号都有一个对应的相同类型的左括号。

示例：输入：s = "()[]{}"，输出：true；输入：s = "(]"，输出：false

思路 1：不使用数据结构和算法，直接用内置的 Replace() 方法将字符串中的 () ， [] ，{} 全部替换成空字符串，替换之后如果字符串的长度为0就说明是一个“有效的括号” 字符串。时间复杂度: O(N^2)，空间复杂度: O(N)

func isValidBrackets1(s string) bool {
	for {
		l := len(s)
		s = strings.Replace(s, "()", "", -1)
		s = strings.Replace(s, "[]", "", -1)
		s = strings.Replace(s, "{}", "", -1)
		//判断s是否没变过，相当于s不存在(),[],{}
		if len(s) == l {
			break
		}
	}
	return len(s) == 0
}

func main() {
	fmt.Println(isValidBrackets1("[]()")) //true
	fmt.Println(isValidBrackets1("[])"))  //false
}

思路2：用栈来实现，利用栈的后进先出的特性，如果是左括号就入栈，如果是右括号则查看当前栈顶元素是否与当前元素匹配，如果不匹配直接返回 false；如果全部匹配成功则返回 true。时间复杂度: O(N)，空间复杂度: O(N)。注意，如果左右括号的个数是奇数则肯定返回false。

func isValidBrackets2(s string) bool {
    if len(s)%2 != 0 { //如果左右括号的个数是奇数则肯定返回false
		return false
	}
	stack := make([]rune, len(s))
	n := 0
	for _, c := range s {
		switch c {
		case '(', '[', '{':
			stack[n] = c
			n++
		case ')':
			if n == 0 || stack[n-1] != '(' {
				return false
			}
			n--
		case ']':
			if n == 0 || stack[n-1] != '[' {
				return false
			}
			n--
		case '}':
			if n == 0 || stack[n-1] != '{' {
				return false
			}
			n--
		}
	}
	if n == 0 {
		return true
	} else {
		return false
	}
}
func main() {
	fmt.Println(isValidBrackets2("[]()")) //true
	fmt.Println(isValidBrackets2("[])"))  //false
	fmt.Println(isValidBrackets2("[]))")) //false
}

源代码：https://gitee.com/rxbook/go-algo-demo/tree/master/stack

浮尘笔记

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
2
评论
数据结构与算法03：栈

先进后出，后进先出的数据结构就是栈，可以理解为一个纸箱子，往箱子里面放书，一本一本叠上去，取得时候只能从上面取最后放进去的书，最早放进去的最后才会被取出来。栈只允许在一端插入和删除数据，当某个数据集合只涉及在一端插入和删除数据，并且满足后进先出、先进后出的特性，就应该首选“栈”这种数据结构。虽然栈限定降低了操作的灵活性，但这使得栈在处理只涉及一端新增和删除数据的问题时效率更高。
复制链接

扫一扫