链式栈 Stack
- 栈: 受限线性表。 收该中数据类型存储特性限制。 先进后出 FILO
- 依然是 链式存储 1:1
- 无论压栈(入栈)、弹栈(出栈)都属于 增、删操作。选用链式存。
- 实现链式栈,参照 单向链表(可以没有头结点,全部数据结点)
数据结构
type StackNode struct {
Data interface{}
Next *StackNode
}
操作方法
- 创建链式栈 CreateStack(数据)
- 打印链式栈 PrintStack()
- 获取链式栈个数 Length() int
- 压栈(入栈):Push(数据)
- 弹栈(出栈):Pop()
- 清空链式栈:ClearStack()
创建链式栈CreateStack()
- 容错
- 创建链式栈对象 stack := new(StackNode)
- 创建 表示 “下一个结点” nextNode
- 循环按data 创建链式栈结点。并初始化
- newNode := new(StackNOde) 依次初始化
- 将 新结点作为当前结点 stack = newNode
- 将 当前结点的 下一个结点,指向 nextNode stack.Next = nextNode
- 更新 当前结点 为 下一个结点。 nextNode = stack
- 返回 stack
func CreateStack(Data ...interface{}) *StackNode {
if Data == nil {
return nil
}
if len(Data) == 0 {
return nil
}
// 定义一个结点,记录 下一结点
var nextNode *StackNode = nil
// 创建链式栈对象
stack := new(StackNode) // 相当于 原来 node -- "当前结点"
// 循环 借助Data 创建结点,并且按栈型数据结构,组织数据.
for _, v := range Data {
// 创建新结点,初始化
newNode := new(StackNode)
newNode.Data = v
newNode.Next = nil
// 将stack 保存数据结点.
stack = newNode
// 当前结点的 下一个结点
stack.Next = nextNode
// 当有新结点产生时, nextNode 记录 当前结点的下一个结点
nextNode = stack
}
// 将链式栈返回
return stack
}
打印链式栈 PrintStack()
- 容错
- 循环 打印每一个 结点。判断条件 for s != nil {
- 打印结点。 后移 s。 s = s.Next
// 打印链式栈
func PrintStack(s *StackNode) {
if s == nil {
return
}
for s != nil {
fmt.Print(s.Data, " ")
s = s.Next
}
}
获取链式栈长度
// 获取链式栈长度
func LengthStack(s *StackNode) int {
if s == nil {
return -1
}
// 计数器
i := 0
for s != nil {
i++
s = s.Next
}
return i
}
链式栈的压栈操作
- 就是单向链表的 头插法。
// 压栈 -- 头插
func PushStack(s *StackNode, Data interface{}) *StackNode {
if s == nil {
return nil
}
if Data == nil {
return s
}
// 创建新结点
newNode := new(StackNode)
newNode.Data = Data
// 将 新结点 放到 最前面(新结点的 Next 是 原链表的 s)
newNode.Next = s
return newNode // 新结点作为链表的 头
}
出栈(弹栈)PopStack()
- 直接返回 头结点的 下一个结点。 s.Next
- 依赖 go 语言的 GC
// 出栈
func PopStack(s *StackNode) *StackNode {
if s == nil {
return nil
}
return s.Next
}
清空栈ClearStack()
func ClearStack(s *StackNode) {
if s == nil { // 递归出口
return
}
ClearStack(s.Next)
s.Data = nil
s.Next = nil
s = nil
}
链式队列Queue
特性:
- Queue 受限线性表: 存储数据时,需要满足 队列 的规则。 FIFO
- 链式队列的实现:
- 与单向链表完全一致。该 数据结构 只支持 出队(头删)、入队(尾插)两种操作。
- 入队 相当于单向链表的“尾插”。出队 都是“头删”。数据结构,规定:不允许直接从“中间”操作。
实现链式队列函数:
- 创建链式队列:Create(数据集)
- 打印链式队列:Print()
- 获取链式队列个数: Length()
- 入队 Push() —— 相当于 Insert
- 出队 Pop() —— 相当于 Delete
于单向链表的“尾插”。出队 都是“头删”。数据结构,规定:不允许直接从“中间”操作。
实现链式队列函数:
- 创建链式队列:Create(数据集)
- 打印链式队列:Print()
- 获取链式队列个数: Length()
- 入队 Push() —— 相当于 Insert
- 出队 Pop() —— 相当于 Delete