标签：amp   循环   超出   return   nod   扩容   没有   数据   ext   

栈

//用数组实现一个顺序栈

type Stack struct{
	arr []int
	used int
	capcity int
}

func NewStack(capicity int) *Stack{
	stack := &Stack{}
	stack.arr = make([]int,capicity)
	stack.used = 0
	stack.capcity = capicity
	return stack
}

// 入栈操作
func (this *Stack)push(item int)bool{
	// 数组空间不够了，直接返回false，入栈失败。
	if this.capcity == this.used {
		return false
	}
	// 将item放到下标为used的位置，并且used加一
	this.arr[this.used] = item
	this.used++
	return true
}

// 出栈操作
func (this *Stack)pop() int{
	// 栈为空，则直接返回-1
	if this.used == 0 {
		return -1
	}
	// 返回下标为used-1的数组元素，并且栈中元素个数used减一
	tmp := this.arr[this.used-1]
	this.used--
	return tmp
}

/**
用哨兵链表实现一个顺序栈
*/
type Node struct {
	value int
	next *Node
}
type Stack struct {
	top *Node
}

//初始化的时候创建一个空的带头节点
func NewStack()*Stack{
	stack := &Stack{}
	newNode := &Node{}
	stack.top = newNode
	return stack
}

//入栈
func (this *Stack)push(value int) bool{
	newNode := &Node{}
	newNode.value = value
	//直接把头节点复制给新节点然后把新节点指向到头节点
	newNode.next = this.top.next
	this.top.next = newNode
	return true
}

//出栈
func (this *Stack)pop() int{
	//栈空返回-1
	if this.top.next == nil {
		return -1
	}
	//获取第一个非带头节点的值，并且把指针往后移
	tmp := this.top.next.value
	this.top.next = this.top.next.next
	return tmp
}

队列

/**
用数组实现一个顺序队列
*/
type Queue struct {
	arr []int
	head int
	tail int
	capicity int
}

func NewQueue(capicity int)*Queue{
	queue := &Queue{}
	queue.arr = make([]int,capicity)
	queue.head = 0
	queue.tail = 0
	queue.capicity = capicity
	return queue
}

func (this *Queue)push(value int) bool{
	//尾部 == 容量 表示满了
	if this.tail == this.capicity {
		//如果头部为0 表示没有扩容空间
		if(this.head == 0){
			return false
		}
		//把数据批量往前移动
		for i:=this.head; i<this.tail; i++{
			this.arr[i-this.head] = this.arr[i]
		}
	}
	this.arr[this.tail] = value
	//tail变成表示最后一个空的空间
	this.tail++
	return true
}

func (this *Queue)pop()int{
	//需要判断队列是否为空
	if this.head == this.tail{
		return -1
	}
	value := this.arr[this.head]
	this.head++
	return value
}

/**
循环队列
*/

//入队
func (this *LoopQueue) pop() int{
	if this.head == this.tail {
		return -1
	}
	value := this.arr[this.head]
	this.head = (this.head+1) % this.count
	return value
}
//出队
func (this *LoopQueue) push(value int) bool{
	//求余其实就是一个0~count的循环条件，相当于在循环旋转
	//队列满的条件 tail+1 == head,如果tail+1已经超出范围，需要用求余循环往复
	if (this.tail + 1) % this.count == this.head{
		return false
	}
	this.arr[this.tail] = value
	//tail往后移动，如果无法后移，则从0开始（通过求余循环）
	this.tail = (this.tail+1) % this.count
	return true
}

栈 队列 递归

标签：amp   循环   超出   return   nod   扩容   没有   数据   ext   

原文地址：https://www.cnblogs.com/jaychan/p/13096801.html