链式栈与链式队列 Stack

链式栈 Stack

• 栈： 受限线性表。 收该中数据类型存储特性限制。 先进后出 FILO
• 依然是 链式存储 1:1
• 无论压栈（入栈）、弹栈（出栈）都属于 增、删操作。选用链式存。
• 实现链式栈，参照 单向链表（可以没有头结点，全部数据结点）

数据结构

type StackNode struct {
    Data interface{}
    Next *StackNode
}

操作方法

1. 创建链式栈 CreateStack（数据）
2. 打印链式栈 PrintStack（）
3. 获取链式栈个数 Length() int
4. 压栈（入栈）：Push（数据）
5. 弹栈（出栈）：Pop（）
6. 清空链式栈：ClearStack()

创建链式栈CreateStack（）

1. 容错
2. 创建链式栈对象 stack := new(StackNode)
3. 创建 表示 “下一个结点” nextNode
4. 循环按data 创建链式栈结点。并初始化
   1. newNode := new(StackNOde) 依次初始化
   2. 将 新结点作为当前结点 stack = newNode
   3. 将 当前结点的 下一个结点，指向 nextNode stack.Next = nextNode
   4. 更新 当前结点 为 下一个结点。 nextNode = stack
5. 返回 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()

1. 容错
2. 循环 打印每一个 结点。判断条件 for s != nil {
3. 打印结点。 后移 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
• 链式队列的实现：
  • 与单向链表完全一致。该 数据结构 只支持 出队（头删）、入队（尾插）两种操作。
  • 入队 相当于单向链表的“尾插”。出队 都是“头删”。数据结构，规定：不允许直接从“中间”操作。

实现链式队列函数：

1. 创建链式队列：Create（数据集）
2. 打印链式队列：Print（）
3. 获取链式队列个数： Length（）
4. 入队 Push（） —— 相当于 Insert
5. 出队 Pop（） —— 相当于 Delete

于单向链表的“尾插”。出队 都是“头删”。数据结构，规定：不允许直接从“中间”操作。

实现链式队列函数：

1. 创建链式队列：Create（数据集）
2. 打印链式队列：Print（）
3. 获取链式队列个数： Length（）
4. 入队 Push（） —— 相当于 Insert
5. 出队 Pop（） —— 相当于 Delete