【golang数据结构和算法】--顺序栈和链式栈

栈：什么是栈，简单的讲：后进先出、 先进后出的线性表；

实际上， 栈既可以用数组来实现， 也可以用链表来实现。 用数组实现的栈， 叫作顺序栈， 用链表实现的栈， 叫作链式栈。

• 顺序栈

package modules

type DataStack struct {
	data []int	// 栈数组
	count int		// 栈元素个数
	n	  int 		// 栈大小
}
// 相当于构造函数
func (d *DataStack)InitStack(n int)  {
	d.data = make([]int, n)
	d.n = n
	d.count = 0
}

func (d *DataStack)PushStack(element int) bool {
	// 判断栈内元素的数量是否已经到达数组的最大长度
	if d.count == d.n {
		return false
	}
	d.data[d.count] = element
	d.count++
	return true
}

func (d *DataStack)PopStack() int {
	if d.count == 0 {
		return 0
	}
	// 将栈中最后一个下标的元素移除 (总共有count个元素，最后一个元素的下标为count-1)
	outElement := d.data[d.count-1]
	d.count--
	return outElement
}

• 链式栈

  package modules
  
  import "fmt"
  
  type Node struct {
  	Data int
  	Next *Node
  }
  // 定义头节点
  type List struct {
  	HeadNode *Node
  }
  
  func (list *List)PushLinkedStack(data int) {
  	var newNode = &Node{Data:data, Next:nil}
  	if list.HeadNode == nil {
  		list.HeadNode = newNode
  	} else {
  		// 栈不为空，将待入节点next指向null,然后指向栈顶
  		newNode.Next = list.HeadNode
  		list.HeadNode = newNode
  	}
  }
  
  func (list *List)PopLinkedStack() int {
  	if list.HeadNode == nil {
  		return -1
  	} else {
  		outNode := list.HeadNode.Data
  		// 栈顶节点指针下移一位
  		list.HeadNode = list.HeadNode.Next
  		return outNode
  	}
  }
  // 遍历栈内所以元素
  func (list *List)PrintLinkedStack() {
  	if list.HeadNode != nil {
  		// 取到栈顶节点
  		tmpNode := list.HeadNode
  		for {
  			fmt.Println(tmpNode.Data)
  			tmpNode = tmpNode.Next
  			if tmpNode == nil {
  				break
  			}
  		}
  	}
  }
  
  func (list *List)GetLength() int {
  	count := 0
  	cur := list.HeadNode
  	for cur != nil {
  		cur = cur.Next
  		count++
  	}
  	return count
  }