关于数据结构：如何在JavaScript中实现堆栈和队列？

How do you implement a Stack and a Queue in JavaScript?

在javascript中实现堆栈和队列的最佳方法是什么？

我想做调车场算法，我需要这些数据结构。

1
2
3
4
5
6
7
8
9
10
11

var stack = [];
stack.push(2); // stack is now [2]
stack.push(5); // stack is now [2, 5]
var i = stack.pop(); // stack is now [2]
alert(i); // displays 5

var queue = [];
queue.push(2); // queue is now [2]
queue.push(5); // queue is now [2, 5]
var i = queue.shift(); // queue is now [5]
alert(i); // displays 2

摘自"9个你可能不知道的javascript提示"

相关讨论

Javascript有push和pop方法，可以对普通的Javascript数组对象进行操作。

对于队列，请查看以下内容：

http://safalla.com/web-design/javascript/queues/

Queues can be implemented in
JavaScript using either the push and
shift methods or unshift and pop
methods of the array object. Although
this is a simple way to implement
queues, it is very inefficient for
large queues — because the methods
operate on arrays, the shift and
unshift methods move every element in
the array each time they are called.

Queue.js is a simple and efficient queue implementation for JavaScript whose dequeue function runs in amortised constant time. As a result, for larger queues it can be significantly faster than using arrays.

相关讨论

数组。

堆栈：

1
2
3
4
5
6
7

var stack = [];

//put value on top of stack
stack.push(1);

//remove value from top of stack
var value = stack.pop();

队列：

1
2
3
4
5
6
7

var queue = [];

//put value on end of queue
queue.push(1);

//Take first value from queue
var value = queue.shift();

相关讨论

如果您想创建自己的数据结构，可以构建自己的：

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

队列：

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

相关讨论

使用linked listakbd实现stakbd和queue

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

// Linked List
function Node(data) {
this.data = data;
this.next = null;
}

// Stack implemented using LinkedList
function Stack() {
this.top = null;
}

Stack.prototype.push = function(data) {
var newNode = new Node(data);

newNode.next = this.top; //Special attention
this.top = newNode;
}

Stack.prototype.pop = function() {
if (this.top !== null) {
var topItem = this.top.data;
this.top = this.top.next;
return topItem;
}
return null;
}

Stack.prototype.print = function() {
var curr = this.top;
while (curr) {
console.log(curr.data);
curr = curr.next;
}
}

// var stack = new Stack();
// stack.push(3);
// stack.push(5);
// stack.push(7);
// stack.print();

// Queue implemented using LinkedList
function Queue() {
this.head = null;
this.tail = null;
}

Queue.prototype.enqueue = function(data) {
var newNode = new Node(data);

if (this.head === null) {
this.head = newNode;
this.tail = newNode;
} else {
this.tail.next = newNode;
this.tail = newNode;
}
}

Queue.prototype.dequeue = function() {
var newNode;
if (this.head !== null) {
newNode = this.head.data;
this.head = this.head.next;
}
return newNode;
}

Queue.prototype.print = function() {
var curr = this.head;
while (curr) {
console.log(curr.data);
curr = curr.next;
}
}

var queue = new Queue();
queue.enqueue(3);
queue.enqueue(5);
queue.enqueue(7);
queue.print();
queue.dequeue();
queue.dequeue();
queue.print();

javascript array shift()速度很慢，尤其是在保存许多元素时。我知道两种实现具有摊余O(1)复杂性的队列的方法。

第一种方法是使用循环缓冲区和表加倍。我以前就实施过。你可以在这里看到我的源代码https://github.com/kevyuu/rapid-queue/快速队列

第二种方法是使用两个堆栈。这是用于具有两个堆栈的队列的代码

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
45
46

这是使用JSPerf的性能比较

circularQueue.shift()与array.shift()的比较

http://jspef.com/rapidqueue-shift-vs-array-shift

正如您所看到的，使用大型数据集的速度要快得多

相关讨论

有很多方法可以在javascript中实现堆栈和队列。上面的大多数答案都是非常肤浅的实现，我将尝试实现更具可读性(使用ES6的新语法特性)和健壮性的东西。

下面是堆栈实现：

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

class Stack {
constructor(...items){
this._items = []

if(items.length>0)
items.forEach(item => this._items.push(item) )

}

push(...items){
//push item to the stack
items.forEach(item => this._items.push(item) )
return this._items;

}

pop(count=0){
//pull out the topmost item (last item) from stack
if(count===0)
return this._items.pop()
else
return this._items.splice( -count, count )
}

peek(){
// see what's the last item in stack
return this._items[this._items.length-1]
}

size(){
//no. of items in stack
return this._items.length
}

isEmpty(){
// return whether the stack is empty or not
return this._items.length==0
}

toArray(){
return this._items;
}
}

这就是如何使用堆栈：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

let my_stack = new Stack(1,24,4);
// [1, 24, 4]
my_stack.push(23)
//[1, 24, 4, 23]
my_stack.push(1,2,342);
//[1, 24, 4, 23, 1, 2, 342]
my_stack.pop();
//[1, 24, 4, 23, 1, 2]
my_stack.pop(3)
//[1, 24, 4]
my_stack.isEmpty()
// false
my_stack.size();
//3

如果您想了解有关此实现的详细描述以及如何进一步改进，可以阅读以下内容：http://jschap.com/data-structures-in-javascript-stack/

以下是ES6中队列实现的代码：

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

class Queue{
constructor(...items){
//initialize the items in queue
this._items = []
// enqueuing the items passed to the constructor
this.enqueue(...items)
}

enqueue(...items){
//push items into the queue
items.forEach( item => this._items.push(item) )
return this._items;
}

dequeue(count=1){
//pull out the first item from the queue
this._items.splice(0,count);
return this._items;
}

peek(){
//peek at the first item from the queue
return this._items[0]
}

size(){
//get the length of queue
return this._items.length
}

isEmpty(){
//find whether the queue is empty or no
return this._items.length===0
}
}

以下是如何使用此实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

let my_queue = new Queue(1,24,4);
// [1, 24, 4]
my_queue.enqueue(23)
//[1, 24, 4, 23]
my_queue.enqueue(1,2,342);
//[1, 24, 4, 23, 1, 2, 342]
my_queue.dequeue();
//[24, 4, 23, 1, 2, 342]
my_queue.dequeue(3)
//[1, 2, 342]
my_queue.isEmpty()
// false
my_queue.size();
//3

要了解如何实现这些数据结构以及如何进一步改进这些数据结构的完整教程，您可能需要学习jschap.com上的"在javascript中玩数据结构"系列。以下是队列链接-http://jschap.com/playing-data-structures-javascript-queues/

相关讨论

/*------------------------------------------------------------------
Defining Stack Operations using Closures in Javascript, privacy and
state of stack operations are maintained

@author:Arijt Basu
Log: Sun Dec 27, 2015, 3:25PM
-------------------------------------------------------------------
*/
var stackControl = true;
var stack = (function(array) {
array = [];
//--Define the max size of the stack
var MAX_SIZE = 5;

function isEmpty() {
if (array.length < 1) console.log("Stack is empty");
};
isEmpty();

return {

push: function(ele) {
if (array.length < MAX_SIZE) {
array.push(ele)
return array;
} else {
console.log("Stack Overflow")
}
},
pop: function() {
if (array.length > 1) {
array.pop();
return array;
} else {
console.log("Stack Underflow");
}
}

}
})()
// var list = 5;
// console.log(stack(list))
if (stackControl) {
console.log(stack.pop());
console.log(stack.push(3));
console.log(stack.push(2));
console.log(stack.pop());
console.log(stack.push(1));
console.log(stack.pop());
console.log(stack.push(38));
console.log(stack.push(22));
console.log(stack.pop());
console.log(stack.pop());
console.log(stack.push(6));
console.log(stack.pop());
}
//End of STACK Logic

/* Defining Queue operations*/

var queue = (function(array) {
array = [];
var reversearray;
//--Define the max size of the stack
var MAX_SIZE = 5;

function isEmpty() {
if (array.length < 1) console.log("Queue is empty");
};
isEmpty();

return {
insert: function(ele) {
if (array.length < MAX_SIZE) {
array.push(ele)
reversearray = array.reverse();
return reversearray;
} else {
console.log("Queue Overflow")
}
},
delete: function() {
if (array.length > 1) {
//reversearray = array.reverse();
array.pop();
return array;
} else {
console.log("Queue Underflow");
}
}
}

})()

console.log(queue.insert(5))
console.log(queue.insert(3))
console.log(queue.delete(3))

下面是一个非常简单的队列实现，有两个目标：

与array.shift()不同，您知道这个出列方法需要恒定的时间(o(1))。
为了提高速度，这种方法使用的分配比链表方法少很多。

堆栈实现只共享第二个目标。

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
45
46
47
48

// Queue
function Queue() {
this.q = new Array(5);
this.first = 0;
this.size = 0;
}
Queue.prototype.enqueue = function(a) {
var other;
if (this.size == this.q.length) {
other = new Array(this.size*2);
for (var i = 0; i < this.size; i++) {
other[i] = this.q[(this.first+i)%this.size];
}
this.first = 0;
this.q = other;
}
this.q[(this.first+this.size)%this.q.length] = a;
this.size++;
};
Queue.prototype.dequeue = function() {
if (this.size == 0) return undefined;
this.size--;
var ret = this.q[this.first];
this.first = (this.first+1)%this.q.length;
return ret;
};
Queue.prototype.peek = function() { return this.size > 0 ? this.q[this.first] : undefined; };
Queue.prototype.isEmpty = function() { return this.size == 0; };

// Stack
function Stack() {
this.s = new Array(5);
this.size = 0;
}
Stack.prototype.push = function(a) {
var other;
if (this.size == this.s.length) {
other = new Array(this.s.length*2);
for (var i = 0; i < this.s.length; i++) other[i] = this.s[i];
this.s = other;
}
this.s[this.size++] = a;
};
Stack.prototype.pop = function() {
if (this.size == 0) return undefined;
return this.s[--this.size];
};
Stack.prototype.peek = function() { return this.size > 0 ? this.s[this.size-1] : undefined; };

或者，您可以使用两个数组来实现队列数据结构。

1
2
3
4
5
6

var temp_stack = new Array();
var stack = new Array();

temp_stack.push(1);
temp_stack.push(2);
temp_stack.push(3);

如果我现在弹出元素，那么输出将是3，2，1。但我们需要先进先出的结构，这样你可以做以下。

1
2
3
4
5
6
7

stack.push(temp_stack.pop());
stack.push(temp_stack.pop());
stack.push(temp_stack.pop());

stack.pop(); //Pop out 1
stack.pop(); //Pop out 2
stack.pop(); //Pop out 3

相关讨论

如果您了解使用push()和pop()函数的堆栈，那么queue只是为了让oposite中的一个操作有意义。push()的oposite是unsift()和pop()es shift()的oposite。然后：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

//classic stack
var stack = [];
stack.push("first"); // push inserts at the end
stack.push("second");
stack.push("last");
stack.pop(); //pop takes the"last" element

//One way to implement queue is to insert elements in the oposite sense than a stack
var queue = [];
queue.unshift("first"); //unshift inserts at the beginning
queue.unshift("second");
queue.unshift("last");
queue.pop(); //"first"

//other way to do queues is to take the elements in the oposite sense than stack
var queue = [];
queue.push("first"); //push, as in the stack inserts at the end
queue.push("second");
queue.push("last");
queue.shift(); //but shift takes the"first" element

javascript中的常规数组结构是一个堆栈(先进、后出)，也可以用作队列(先进、先进、后出)，具体取决于您所做的调用。

检查此链接以了解如何使数组像队列一样工作：

队列

下面是队列的链接列表版本，其中还包括最后一个节点，如@perkins建议的和最合适的。

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

// QUEUE Object Definition

var Queue = function() {
this.first = null;
this.last = null;
this.size = 0;
};

var Node = function(data) {
this.data = data;
this.next = null;
};

Queue.prototype.enqueue = function(data) {
var node = new Node(data);

if (!this.first){ // for empty list first and last are the same
this.first = node;
this.last = node;
} else { // otherwise we stick it on the end
this.last.next=node;
this.last=node;
}

this.size += 1;
return node;
};

Queue.prototype.dequeue = function() {
if (!this.first) //check for empty list
return null;

temp = this.first; // grab top of list
if (this.first==this.last) {
this.last=null; // when we need to pop the last one
}
this.first = this.first.next; // move top of list down
this.size -= 1;
return temp;
};

相关讨论

你可以根据概念使用你自己的定制类，这里是你可以用来做这些事情的代码片段。

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

/*
* Stack implementation in JavaScript
*/

function Stack(){
this.top = null;
this.count = 0;

this.getCount = function(){
return this.count;
}

this.getTop = function(){
return this.top;
}

this.push = function(data){
var node = {
data : data,
next : null
}

node.next = this.top;
this.top = node;

this.count++;
}

this.peek = function(){
if(this.top === null){
return null;
}else{
return this.top.data;
}
}

this.pop = function(){
if(this.top === null){
return null;
}else{
var out = this.top;
this.top = this.top.next;
if(this.count>0){
this.count--;
}

return out.data;
}
}

this.displayAll = function(){
if(this.top === null){
return null;
}else{
var arr = new Array();

var current = this.top;
//console.log(current);
for(var i = 0;i<this.count;i++){
arr[i] = current.data;
current = current.next;
}

return arr;
}
}
}

要检查这一点，请使用您的控制台并逐个尝试这些行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

>> var st = new Stack();

>> st.push("BP");

>> st.push("NK");

>> st.getTop();

>> st.getCount();

>> st.displayAll();

>> st.pop();

>> st.displayAll();

>> st.getTop();

>> st.peek();

相关讨论

如果您正在寻找具有一些基本操作(基于链接列表)的堆栈和队列数据结构的ES6 OOP实现，那么它可能如下所示：

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

import LinkedList from '../linked-list/LinkedList';

export default class Queue {
constructor() {
this.linkedList = new LinkedList();
}

isEmpty() {
return !this.linkedList.tail;
}

peek() {
if (!this.linkedList.head) {
return null;
}

return this.linkedList.head.value;
}

enqueue(value) {
this.linkedList.append(value);
}

dequeue() {
const removedHead = this.linkedList.deleteHead();
return removedHead ? removedHead.value : null;
}

toString(callback) {
return this.linkedList.toString(callback);
}
}

STAC.JS

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58

import LinkedList from '../linked-list/LinkedList';

export default class Stack {
constructor() {
this.linkedList = new LinkedList();
}

/**
* @return {boolean}
*/
isEmpty() {
return !this.linkedList.tail;
}

/**
* @return {*}
*/
peek() {
if (!this.linkedList.tail) {
return null;
}

return this.linkedList.tail.value;
}

/**
* @param {*} value
*/
push(value) {
this.linkedList.append(value);
}

/**
* @return {*}
*/
pop() {
const removedTail = this.linkedList.deleteTail();
return removedTail ? removedTail.value : null;
}

/**
* @return {*[]}
*/
toArray() {
return this.linkedList
.toArray()
.map(linkedListNode => linkedListNode.value)
.reverse();
}

/**
* @param {function} [callback]
* @return {string}
*/
toString(callback) {
return this.linkedList.toString(callback);
}
}

上面例子中用于堆栈和队列的LinkedList实现可以在Github上找到。

堆栈实现很简单，如其他答案中所述。

然而，在这个线程中，我没有找到任何令人满意的答案来实现JavaScript中的队列，所以我自己做了一个。

此线程中有三种类型的解决方案：

阵列-在大型阵列上使用array.shift()的最差解决方案效率非常低
链表-它是O(1)，但是对每个元素使用一个对象有点过分，特别是如果它们很多而且很小，比如存储数字
延迟移位数组-它包括将索引与数组关联。当元素出列时，索引向前移动。当索引到达数组的中间时，数组被分成两部分以删除前半部分。

延迟移位数组在我看来是最令人满意的解决方案，但是它们仍然将所有内容存储在一个可能有问题的大型连续数组中，并且当数组被切片时，应用程序将交错进行。

我使用小数组的链接列表(每个数组最多1000个元素)来实现。数组的行为类似于延迟移位数组，但它们从未被切片过：当数组中的每个元素都被移除时，数组将被简单地丢弃。

这个包是NPM上的，具有基本的FIFO功能，我最近刚推过它。代码分为两部分。

这是第一部分

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

/** Queue contains a linked list of Subqueue */
class Subqueue <T> {
public full() {
return this.array.length >= 1000;
}

public get size() {
return this.array.length - this.index;
}

public peek(): T {
return this.array[this.index];
}

public last(): T {
return this.array[this.array.length-1];
}

public dequeue(): T {
return this.array[this.index++];
}

public enqueue(elem: T) {
this.array.push(elem);
}

private index: number = 0;
private array: T [] = [];

public next: Subqueue<T> = null;
}

这里是主要的Queue类：

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
45
46
47

class Queue<T> {
get length() {
return this._size;
}

public push(...elems: T[]) {
for (let elem of elems) {
if (this.bottom.full()) {
this.bottom = this.bottom.next = new Subqueue<T>();
}
this.bottom.enqueue(elem);
}

this._size += elems.length;
}

public shift(): T {
if (this._size === 0) {
return undefined;
}

const val = this.top.dequeue();
this._size--;
if (this._size > 0 && this.top.size === 0 && this.top.full()) {
// Discard current subqueue and point top to the one after
this.top = this.top.next;
}
return val;
}

public peek(): T {
return this.top.peek();
}

public last(): T {
return this.bottom.last();
}

public clear() {
this.bottom = this.top = new Subqueue();
this._size = 0;
}

private top: Subqueue<T> = new Subqueue();
private bottom: Subqueue<T> = this.top;
private _size: number = 0;
}

类型注释(: X可以很容易地删除以获得ES6 JavaScript代码。

没有数组(s)

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
45
46
47
48
49
50
51
52

//Javascript stack linked list data structure (no array)

function node(value, noderef) {
this.value = value;
this.next = noderef;
}
function stack() {
this.push = function (value) {
this.next = this.first;
this.first = new node(value, this.next);
}
this.pop = function () {
var popvalue = this.first.value;
this.first = this.first.next;
return popvalue;
}
this.hasnext = function () {
return this.next != undefined;
}
this.isempty = function () {
return this.first == undefined;
}

}

//Javascript stack linked list data structure (no array)
function node(value, noderef) {
this.value = value;
this.next = undefined;
}
function queue() {
this.enqueue = function (value) {
this.oldlast = this.last;
this.last = new node(value);
if (this.isempty())
this.first = this.last;
else
this.oldlast.next = this.last;
}
this.dequeue = function () {
var queuvalue = this.first.value;
this.first = this.first.next;
return queuvalue;
}
this.hasnext = function () {
return this.first.next != undefined;
}
this.isempty = function () {
return this.first == undefined;
}

}

相关讨论

1
2
3
4
5
6
7
8
9
10
11
12

var x = 10;
var y = 11;
var Queue = new Array();
Queue.unshift(x);
Queue.unshift(y);

console.log(Queue)
// Output [11, 10]

Queue.pop()
console.log(Queue)
// Output [11]

当做，

在javascript中，堆栈和队列的实现如下：

堆栈：堆栈是根据后进先出(LIFO)原则插入和移除对象的容器。

push：方法将一个或多个元素添加到数组的末尾，并返回数组的新长度。
pop:方法从数组中移除最后一个元素并返回该元素。

队列：队列是根据先进先出(FIFO)原则插入和删除的对象(线性集合)的容器。

unshift:方法将一个或多个元素添加到数组的开头。
shift:方法从数组中移除第一个元素。

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

let stack = [];
stack.push(1);//[1]
stack.push(2);//[1,2]
stack.push(3);//[1,2,3]

console.log('It was inserted 1,2,3 in stack:', ...stack);

stack.pop(); //[1,2]
console.log('Item 3 was removed:', ...stack);

stack.pop(); //[1]
console.log('Item 2 was removed:', ...stack);

let queue = [];
queue.push(1);//[1]
queue.push(2);//[1,2]
queue.push(3);//[1,2,3]

console.log('It was inserted 1,2,3 in queue:', ...queue);

queue.shift();// [2,3]
console.log('Item 1 was removed:', ...queue);

queue.shift();// [3]
console.log('Item 2 was removed:', ...queue);

在我看来，内置数组对于堆栈来说是可以的。如果您希望在typescript中有一个队列，这里是一个实现

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

/**
* A Typescript implementation of a queue.
*/
export default class Queue {

private queue = [];
private offset = 0;

constructor(array = []) {
// Init the queue using the contents of the array
for (const item of array) {
this.enqueue(item);
}
}

/**
* @returns {number} the length of the queue.
*/
public getLength(): number {
return (this.queue.length - this.offset);
}

/**
* @returns {boolean} true if the queue is empty, and false otherwise.
*/
public isEmpty(): boolean {
return (this.queue.length === 0);
}

/**
* Enqueues the specified item.
*
* @param item - the item to enqueue
*/
public enqueue(item) {
this.queue.push(item);
}

/**
* Dequeues an item and returns it. If the queue is empty, the value
* {@code null} is returned.
*
* @returns {any}
*/
public dequeue(): any {
// if the queue is empty, return immediately
if (this.queue.length === 0) {
return null;
}

// store the item at the front of the queue
const item = this.queue[this.offset];

// increment the offset and remove the free space if necessary
if (++this.offset * 2 >= this.queue.length) {
this.queue = this.queue.slice(this.offset);
this.offset = 0;
}

// return the dequeued item
return item;
};

/**
* Returns the item at the front of the queue (without dequeuing it).
* If the queue is empty then {@code null} is returned.
*
* @returns {any}
*/
public peek(): any {
return (this.queue.length > 0 ? this.queue[this.offset] : null);
}

}

这里有一个Jest测试

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

it('Queue', () => {
const queue = new Queue();
expect(queue.getLength()).toBe(0);
expect(queue.peek()).toBeNull();
expect(queue.dequeue()).toBeNull();

queue.enqueue(1);
expect(queue.getLength()).toBe(1);
queue.enqueue(2);
expect(queue.getLength()).toBe(2);
queue.enqueue(3);
expect(queue.getLength()).toBe(3);

expect(queue.peek()).toBe(1);
expect(queue.getLength()).toBe(3);
expect(queue.dequeue()).toBe(1);
expect(queue.getLength()).toBe(2);

expect(queue.peek()).toBe(2);
expect(queue.getLength()).toBe(2);
expect(queue.dequeue()).toBe(2);
expect(queue.getLength()).toBe(1);

expect(queue.peek()).toBe(3);
expect(queue.getLength()).toBe(1);
expect(queue.dequeue()).toBe(3);
expect(queue.getLength()).toBe(0);

expect(queue.peek()).toBeNull();
expect(queue.dequeue()).toBeNull();
});

希望有人发现这有用，

干杯，

斯图

这是我对堆栈的实现。

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

创建一对类，提供每个数据结构所具有的各种方法(push、pop、peek等)。现在实现这些方法。如果您熟悉堆栈/队列背后的概念，那么这应该非常简单。您可以用一个数组实现堆栈，用一个链表实现队列，尽管当然还有其他方法可以实现。JavaScript会使它变得简单，因为它是弱类型的，因此，您甚至不必担心泛型类型，如果在Java或C语言中实现它，则必须这样做。

您可以使用weakmaps在ES6类中实现私有属性，并使用javascript语言实现字符串属性和方法的好处，如下所示：

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