栈与队列
一、栈
栈是一种“操作受限的线性表”
1、栈主要包含两个操作，入栈和出栈，也就是在栈顶插入一个数据，在栈顶删除一个数据，也就是说所有的操作都是在栈顶进行的。
2、用代码实现一个栈
栈的实现有两种，如果是用数组实现的叫做顺序栈，如果是用链表实现的叫链式栈。
下面来用js实现一个顺序栈
class Stack{
constructor(){
this.items = []//存储栈元素的数组
this.length = 0//栈中元素
}
push(item){
//入栈操作
this.items.push(item)
this.length++;
}
pop(){
//出栈操作
let temp = this.items.pop()
this.length--;
return temp
}
}
let mystack = new Stack()
mystack.push('hush')
mystack.push('krys')
mystack.push('liang')
mystack.push('stefanie')
console.log(mystack.items)
let temp = mystack.pop()
console.log(temp,'..',mystack.items)
用js来实现一个链表栈
//初始化结点
class Node{
constructor(key){
this.next = null
this.key = key
}
}
//初始化单链表
class List{
constructor(){
this.head = null
this.length = 0
}
//创建结点
static createNode(key){
return new Node(key)
}
//往头部插入数据
push(node){
if (this.head){
//此时head有指向的结点
node.next = this.head
} else {
node.next = null
}
this.head = node
this.length++
}
//删除结点
pop(){
//删除头结点
this.head = this.head.next
this.length --;
return;
}
}
let node1 = new Node('krysliang'),node2 = new Node('wanlingliang')
let list = new List()
list.push(node1)
list.push((node2))
console.log(list.head)
list.pop()
console.log(list.head)
这里可以看到不管是出栈或者入栈，都只需要常量级的变量，而且没有循环，所以时间复杂度和空间复杂度都是O(1)
在考虑空间复杂度的时候，指的是除了原本的数据存储空间外，算法运行还需要额外的存储空间。
3、我们在讲栈的应用时，讲到用函数调用栈来保存临时变量，为什么函数调用要用“栈”来保存临时变量呢？用其他数据结构不行吗
其实，我们不一定非要用栈来保存临时变量，只不过如果这个函数调用符合后进先出的特性，用栈这种数据结构来实现，是最顺理成章的选择。
从调用函数进入被调用函数，对于数据来说，变化的是什么呢？是作用域。所以根本上，只要能保证每进入一个新的函数，都是一个新的作用域就可以。而要实现这个，用栈就非常方便。在进入被调用函数的时候，分配一段栈空间给这个函数的变量，在函数结束的时候，将栈顶复位，正好回到调用函数的作用域内。
4、有关于栈的算法训练
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例 1:
输入: "()"
输出: true
示例 2:
输入: "()[]{}"
输出: true
示例 3:
输入: "(]"
输出: false
示例 4:
输入: "([)]"
输出: false
示例 5:
输入: "{[]}"
输出: true
var isValid = function(s) {
let right = [')','}',']']
if(s.length==0) return true;
if(s.length==1) return false;
let stack = [],flag = true
for (let i = 0;i0){//如果此时栈中还有数据也就是还有未匹配的括号
flag = false
}
if (flag){
return true
} else {
return false
}
};
二、队列
CPU资源有限，任务的处理速度与线程个数并不是线性正相关，比如当线程过多的时候，CPU频繁的切换就会导致性能的下降。
队列就是先进先出，入队只能在队尾进行，出队只能在对头进行。
队列跟栈一样，如果用数组实现那么它就是顺序队列，如果用链表实现那么它就是链表队列。
1、用代码实现一个队列
class Quene{
constructor() {
this.items = []//用来装队列的数组
this.length = 0//队列长度
}
enquene(data){
//入队
this.items.push(data)
this.length++
}
dequene(){
let item = this.items.shift()
this.length--
return item
}
}
let quene = new Quene()
quene.enquene(1)
quene.enquene(2)
quene.enquene(3)
quene.enquene(4)
quene.enquene(5)
console.log(quene.items)
let item = quene.dequene()
console.log(item,quene.items)
用链表实现一个队列
class List{
constructor(){
this.head = null
this.length = 0
}
insert(node){
//入队
if (this.head){
let p = this.head.next
let prev = this.head
while (p){
prev = p
p = p.next
}
prev.next = node
} else {
//队列中暂时没有结点
this.head = node
}
this.length ++
}
delete(){
//出队
if (this.head){
let item = this.head.next
this.head = this.head.next
this.length++
return item
}
}
}
let node1 = new Node(1),node2 = new Node(2),node3 = new Node(3)
let list = new List()
list.insert(node1)
list.insert(node2)
list.insert(node3)
console.log(list.head)
let item = list.delete()
console.log(list.head)
2、循环队列
什么是循环队列呢？循环队列如何用代码实现？实现的关键是什么？
循环队列其实就是，本来队列是一条线的，我现在把它掰成一个环，比如下面这张图，数组有0~7一共8个位置，现在队尾在7，队头在4，因为tail已经在最后一个位置了，如果是普通队列，当插入最后一个数据后，如果再有新的数据到来，就要将数据移动到前面来，这就要有额外的时间去处理，但是如果我们用循环队列来实现，当到了7这里我监测到前面0的空间还是空的，那么我就跳到0这里把最新的数据插入。这样一来，循环队列是不是省事多了呢？
写循环队列的代码有两个需要注意的点：
-
队空和队满的判断
-
从7跳到0这里的判断
先来看看队空和队满的判断条件：
如果队列为空，也就是队列一个数据都没有，此时tail==head。
如果队列满了，此时tail的位置在head的前面一格，那么这个怎么用代码描述呢？假设数组的长度为8，此时head为4，如果队满了tail在3这里，这里有一个关系就(3+1)%8=4,也就是(tail+1)%n==head
class CircularQueue{
constructor(n){
this.items = []
this.n = n
this.head = 0
this.tail = 0
}
enqueue(item){
//入队
//如果队满了就不予以入队，否则入队，tail++
if ((this.tail+1)%this.n == this.head) {
console.log('队满不予以入队',this.items)
return false
}
this.items[this.tail] = item
this.tail = (this.tail+1)%this.n //当前队尾所在的位置
console.log('正常入队',item,this.items)
return true
}
dequene(){
//出队
//如果队空就返回false
if (this.head == this.tail) {
console.log('队空不予以出队')
return false
}
let item = this.items[this.head]
this.items[this.head] = null
this.head = (this.head+1)%this.n
console.log('出队元素',item,'当前队列',this.items)
return item
}
}
let myquene = new CircularQueue(3)
let item1 = myquene.dequene()
myquene.enqueue(1)
myquene.enqueue(2)
myquene.enqueue(3)
let item2 = myquene.dequene()
let item3 = myquene.dequene()
let item4 = myquene.dequene()
myquene.enqueue(4)
myquene.enqueue(5)
myquene.enqueue(6)
可以看到，tail所在的位置一定是空的，所以就会浪费掉一个正常的存储空间。
3、阻塞队列和并发队列
以前上操作系统的课的时候，讲到CPU进程调度的时候就有说过阻塞队列和并发队列了。就是当前如果队列为空也就是没有数据可以拿的时候，队列是被阻塞的，直到队列中有数据了，才可以从对头拿数据。而此外，当队列满的时候，就不可以再往队列插入数据，直到队列中有空闲位置再插入数据。这就是一个生产者-消费者的模型。
并发队列呢，就是同一时刻只允许一个存或者一个取操作。
4、思考
当线程池没有空闲线程的时候，新的任务请求线程资源的时候，线程池要如果处理呢？
一般有两种策略。第一种是非阻塞的处理方式，直接拒绝任务请求；
另一种是阻塞的处理方式，将请求进行排队，等到有空闲线程的时候，取出排队的请求继续处理。
那么这里的队列中，如果时基于链表的实现方式，可以实现一个支持无线排队的无界队列，但是可能会导致过多的请求排队等待，后面来的请求等待的时候就很长了。所以，针对响应时间比较敏感的系统，基于链表实现的无限排队的线程池时不合适的。
而基于数组实现的有界队列，队列的大小有限，所以线程池中排队的请求超过队列大小的时候，接下俩的请求就会被拒绝。这个时候，设置一个合理的队列大小就很重要了。
对于大部分资源有限的场景，当没有空闲资源的时候，基本上都可以通过队列这种数据结构i请求排队。