数据结构之队列总结_数据结构队列实验报告总结

介绍

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

队列相关算法题

力扣933—最近请求次数
题目大意：计算范围为[t -3000,t]的ping个数。
思路：

1. 定义一个空队列
2. 每次调用ping方法时，现将当前t入队，然后将不满足[t -3000,t]出队，最后返回当前队列个数即为满足[t -3000,t]的个数。

代码：

var RecentCounter = function() {
    this.queue = []
};

/** 
 * @param {number} t
 * @return {number}
 */
RecentCounter.prototype.ping = function(t) {
    this.queue.push(t)
    while(this.queue[0] < t - 3000){
        this.queue.shift()
    }
    return this.queue.length
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

力扣225—用队列实现栈
题目大意：使用两个队列，实现栈的先进后出。
思路：

1. 题目已经要求使用两个队列，所以先初始化两个空队列。
2. push()：直接在queue1入队
3. pop()：先判断queue1队列是否为空，若为空，和queue2队列进行交换（因为这两个队列的顺序都是一致的）。然后将queue1的元素推入到queue2里面，直到就剩下一个元素，直接弹出并返回。
4. top()：调用刚刚写的pop()方法，可以得到queue1最后一个元素，因为是取栈顶而不是将它弹出队列，所以要将它推回queue1里面，最后直接返回该元素即可
5. empty()：判断这两个队列是否都为空，若有一个不为空，说明这两个队列形成的栈有元素（因为pop()方法）。

var MyStack = function() {
    this.queue1 = []
    this.queue2 = []
};

/** 
 * @param {number} x
 * @return {void}
 */
MyStack.prototype.push = function(x) {
    this.queue1.push(x)
};

/**
 * @return {number}
 */
MyStack.prototype.pop = function() {
    if(this.queue1.length === 0){
        [this.queue1,this.queue2] = [this.queue2,this.queue1];
    }
    let len = this.queue1.length
    while(len > 1){
        this.queue2.push(this.queue1.shift())
        len--
    }
    return this.queue1.shift()
};

/**
 * @return {number}
 */
MyStack.prototype.top = function() {
    let x = this.pop()
    this.queue1.push(x)
    return x
};

/**
 * @return {boolean}
 */
MyStack.prototype.empty = function() {
    return this.queue1.length === 0 && this.queue2.length === 0
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

力扣232—用栈实现队列

题目大意：使用两个栈实现队列的先进先出。
思路：

1. 初始化两个栈（一个输入栈，一个输出栈）
2. push()：将元素推入stack1输入栈中
3. pop()：先判断stack2输出栈是否有元素，有的话直接pop()方法即可。没有的话，先将stack1输入栈里的元素逐一推入stack2输出栈里，最后直接pop()并将其返回出去即可。
4. peek()：调用刚刚自己写的pop()方法，拿到首元素，但是只是获取并不是将它真正的pop，所以还得将其推回stack2中，最后直接返回刚刚拿到的首元素即可。
5. 同样检查两个栈是否同时为空，若有一个为空，表示该形成的队列还有元素。

var MyQueue = function() {
    this.stack1 = []
    this.stack2 = []
};

/** 
 * @param {number} x
 * @return {void}
 */
MyQueue.prototype.push = function(x) {
    this.stack1.push(x)
};

/**
 * @return {number}
 */
MyQueue.prototype.pop = function() {
    let len = this.stack2.length
    if(len){
        return this.stack2.pop()
    }
    let len1 = this.stack1.length
    while(len1--){
        this.stack2.push(this.stack1.pop())
    }
    return this.stack2.pop()
};

/**
 * @return {number}
 */
MyQueue.prototype.peek = function() {
    let x = this.pop()
    this.stack2.push(x)
    return x
};

/**
 * @return {boolean}
 */
MyQueue.prototype.empty = function() {
    return !this.stack1.length && !this.stack2.length
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44