JavaScriptでスタックとキューをどのように実装しますか？
JavaScriptでスタックとキューを実装するための最良の方法は何ですか？
私はシャントヤードアルゴリズムをやろうと思っていて、これらのデータ構造が必要になるでしょう。
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には、通常のJavascript配列オブジェクトを操作するPushメソッドとpopメソッドがあります。
キューについては、こちらをご覧ください。
http://safalra.com/web-design/javascript/queues/
キューは、配列オブジェクトのPushメソッドとshiftメソッド、またはunshiftメソッドとpopメソッドを使用してJavaScriptで実装できます。これはキューを実装する簡単な方法ですが、大きなキューには非常に非効率的です。メソッドが配列に対して機能するため、shiftメソッドとunshiftメソッドは呼び出されるたびに配列内のすべての要素を移動します。
Queue.jsはJavaScriptのシンプルで効率的なキュー実装で、デキュー機能は一定の償却時間で実行されます。その結果、大きなキューの場合は、配列を使用するよりもかなり高速になります。
配列.
スタック：
var stack = [];
//put value on top of stack
stack.Push(1);
//remove value from top of stack
var value = stack.pop();
キュー：
var queue = [];
//put value on end of queue
queue.Push(1);
//Take first value from queue
var value = queue.shift();
あなたがあなた自身のデータ構造を作りたければ、あなたはあなた自身のものを作ることができます：
var Stack = function(){
this.top = null;
this.size = 0;
};
var Node = function(data){
this.data = data;
this.previous = null;
};
Stack.prototype.Push = function(data) {
var node = new Node(data);
node.previous = this.top;
this.top = node;
this.size += 1;
return this.top;
};
Stack.prototype.pop = function() {
temp = this.top;
this.top = this.top.previous;
this.size -= 1;
return temp;
};
そしてキューの場合：
var Queue = function() {
this.first = 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){
this.first = node;
} else {
n = this.first;
while (n.next) {
n = n.next;
}
n.next = node;
}
this.size += 1;
return node;
};
Queue.prototype.dequeue = function() {
temp = this.first;
this.first = this.first.next;
this.size -= 1;
return temp;
};
私の実装 Stack そして Queue 使う Linked List
// 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の配列shift（）は、多くの要素を保持している場合は特に遅くなります。償却されたO(1)複雑さでキューを実装する2つの方法を知っています。
まず、循環バッファとテーブルダブリングを使用します。私は以前にこれを実行しました。あなたは私のソースコードをここで見ることができます https://github.com/kevyuu/rapid-queue
二つ目の方法は二つのスタックを使うことです。これは2スタックのキューのコードです
function createDoubleStackQueue() {
var that = {};
var pushContainer = [];
var popContainer = [];
function moveElementToPopContainer() {
while (pushContainer.length !==0 ) {
var element = pushContainer.pop();
popContainer.Push(element);
}
}
that.Push = function(element) {
pushContainer.Push(element);
};
that.shift = function() {
if (popContainer.length === 0) {
moveElementToPopContainer();
}
if (popContainer.length === 0) {
return null;
} else {
return popContainer.pop();
}
};
that.front = function() {
if (popContainer.length === 0) {
moveElementToPopContainer();
}
if (popContainer.length === 0) {
return null;
}
return popContainer[popContainer.length - 1];
};
that.length = function() {
return pushContainer.length + popContainer.length;
};
that.isEmpty = function() {
return (pushContainer.length + popContainer.length) === 0;
};
return that;}
これはjsPerfを使ったパフォーマンスの比較です
CircularQueue.shift（）とArray.shift（）の組み合わせ
http://jsperf.com/rapidqueue-shift-vs-array-shift
ご覧のとおり、大規模データセットではかなり高速です。
Javascriptでスタックとキューを実装するには、いくつかの方法があります。上記の答えのほとんどは非常に浅い実装であり、私はもっと読みやすい（es6の新しい構文機能を使用して）堅牢なものを実装しようとします。
これがスタックの実装です。
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;
}
}
そして、これはあなたがスタックを使うことができる方法です：
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のキュー実装のコードです。
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
}
}
この実装を使用する方法は次のとおりです。
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))
これは、2つの目的を持つ、かなり単純なキューの実装です。
- Array.shift（）と異なり、このデキュー方法には一定の時間がかかることがわかります（O（1））。
- 速度を向上させるために、このアプローチはリンクリストアプローチよりもはるかに少ない割り当てを使用します。
スタックの実装は2番目の目的のみを共有しています。
// 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; };
あるいは、2つの配列を使用してキューデータ構造を実装することもできます。
var temp_stack = new Array();
var stack = new Array();
temp_stack.Push(1);
temp_stack.Push(2);
temp_stack.Push(3);
ここで要素をポップすると、出力は3,2,1になります。しかし、私たちはFIFO構造体が欲しいので、次のことができます。
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
あなたはコンセプトに基づいてあなた自身のカスタマイズクラスを使うことができます、ここであなたがものをするのに使用できるコードスニペット
/*
* 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;
}
}
}
これを確認するには、コンソールを使って次の行を順番に試してください。
>> var st = new Stack();
>> st.Push("BP");
>> st.Push("NK");
>> st.getTop();
>> st.getCount();
>> st.displayAll();
>> st.pop();
>> st.displayAll();
>> st.getTop();
>> st.peek();
これは最後のノードも含むキューのリンクリスト版です。
// 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;
};
Push（）とpop（）関数を使ったスタックを理解しているなら、queueは単に反対の意味でこれらの操作の1つをすることです。 Push（）の反対はunshift（）であり、pop（）es shift（）の反対です。その後：
//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の通常の配列構造はスタック（先入れ先出し）であり、呼び出しによってはキュー（先入れ先出し）としても使用できます。
このリンクをチェックして、ArrayをQueueのように機能させる方法を確認してください。
他の答えで説明したように、スタックの実装は簡単です。
しかし、私はこのスレッドでjavascriptでキューを実装するための満足のいく答えを見つけることができなかったので、私は自分で作りました。
このスレッドには3種類の解決策があります。
- 配列 - 大規模な配列で
array.shift()を使うという最悪の解決策は非常に非効率的です - リンクリスト - それはO(1)だが、各要素にオブジェクトを使うことは、特にそれらがたくさんあり、それらが小さい、数字を格納するようなものであるならば、多すぎる。
- 遅延シフト配列 - インデックスを配列に関連付けることで構成されます。要素がデキューされると、インデックスは前方に移動します。インデックスが配列の中央に達すると、配列は2つにスライスされて前半が削除されます。
遅延シフト配列は私の頭の中では最も満足のいく解決策ですが、それらは問題となる可能性がある1つの大きな連続した配列にすべてを保存しているため、配列をスライスするとアプリケーションがずれるでしょう。
小さな配列のリンクリスト（それぞれ最大1000要素）を使って実装しました。これらの配列は、スライスされることがないという点を除いて、遅延シフト配列と同じように動作します。配列内のすべての要素が削除されると、配列は単純に破棄されます。
パッケージは npm に基本的なFIFO機能性があるので、最近プッシュしました。コードは2つの部分に分かれています。
これが最初の部分です
/** 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クラスです。
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コードを取得できます。
配列なし
//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;
}
}
ES6 OOPいくつかの基本的な操作（スタックリストに基づく）を持つStack and Queueデータ構造の実装を探しているなら、それはこのように見えるかもしれません：
Queue.js
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);
}
}
Stack.js
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);
}
}
そして、上記の例でStackとQueueに使用されているLinkedListの実装は GitHubでは - にあります。
よろしく、
Javascriptでは、スタックとキューの実装は次のとおりです。
スタック： スタックは、後入れ先出し（LIFO）の原則に従って挿入および削除されるオブジェクトのコンテナです。
- Push：Methodは1つ以上の要素を配列の末尾に追加して新しい長さの配列を返します。
- Pop：Methodは配列から最後の要素を削除し、その要素を返します。
キュー： キューは、先入れ先出し（FIFO）の原則に従って挿入および削除されるオブジェクトのコンテナ（線形コレクション）です。
シフトなし：メソッドは、配列の先頭に1つ以上の要素を追加します。
Shift：Methodは配列から最初の要素を削除します。
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); 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]
これらの各データ構造が持つさまざまなメソッド（Push、pop、peekなど）を提供する一対のクラスを作成します。今すぐメソッドを実装します。あなたがスタック/キューの背後にある概念に精通しているなら、これはかなり簡単なはずです。スタックを配列で、キューをリンクリストを使って実装することができますが、他にも確かな方法があります。 Javascriptは型付けが弱いのでこれを簡単にします。そのため、JavaやC＃で実装している場合に必要なジェネリック型について心配する必要はありません。
私には、組み込み配列がスタックには問題ないと思われます。 TypeScriptでQueueが欲しいなら、これが実装です。
/**
* 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テストです。
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();
});
誰かがこれが役に立つと願っています、
乾杯、
Stu
あなたはES6クラスでプライベートプロパティを実装するためにWeakMapsを使用することができますそして以下のようなJavaScript言語でのStringプロパティとメソッドの利点：
const _items = new WeakMap();
class Stack {
constructor() {
_items.set(this, []);
}
Push(obj) {
_items.get(this).Push(obj);
}
pop() {
const L = _items.get(this).length;
if(L===0)
throw new Error('Stack is empty');
return _items.get(this).pop();
}
peek() {
const items = _items.get(this);
if(items.length === 0)
throw new Error ('Stack is empty');
return items[items.length-1];
}
get count() {
return _items.get(this).length;
}
}
const stack = new Stack();
//now in console:
//stack.Push('a')
//stack.Push(1)
//stack.count => 2
//stack.peek() => 1
//stack.pop() => 1
//stack.pop() => "a"
//stack.count => 0
//stack.pop() => Error Stack is empty
これが私のStackの実装です。
function Stack() {
this.dataStore = [];
this.top = 0;
this.Push = Push;
this.pop = pop;
this.peek = peek;
this.clear = clear;
this.length = length;
}
function Push(element) {
this.dataStore[this.top++] = element;
}
function peek() {
return this.dataStore[this.top-1];
}
function pop() {
return this.dataStore[--this.top];
}
function clear() {
this.top = 0;
}
function length() {
return this.top;
}
var s = new Stack();
s.Push("David");
s.Push("Raymond");
s.Push("Bryan");
console.log("length: " + s.length());
console.log(s.peek());