Bagaimana menerapkan tumpukan dan antrian di JavaScript?

Apa cara terbaik untuk mengimplementasikan tumpukan dan antrian di javascript?

Saya mencari algoritma bypass, dan saya butuh struktur data ini.

594
19 окт. ditetapkan oleh KingNestor pada 19 Oktober. 2009-10-19 21:15 '09 pukul 21:15 2009-10-19 21:15
@ 23 jawaban
 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 

diambil dari 9 tips javascript yang tidak Anda ketahui

1070
19 окт. Jawabannya diberikan oleh Corey Ballou 19 Okt. 2009-10-19 21:19 '09 jam 9:19 malam 2009-10-19 21:19

Javascript memiliki metode push dan pop yang bekerja dengan objek biasa dalam array Javascript.

Untuk antrian, lihat di sini:

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

Antrian dapat diimplementasikan dalam javascript menggunakan metode push dan shift atau metode offset dan pop dari objek array. Meskipun ini adalah cara sederhana untuk mengimplementasikan antrian, itu sangat tidak efisien untuk antrian besar - karena metode bekerja dengan array, shift dan metode offset memindahkan setiap elemen ke array setiap kali mereka dipanggil.

Queue.js adalah implementasi sederhana dan efisien dari antrian untuk JavaScript, fungsi dekompresi yang dijalankan dalam mode waktu tetap konstan. Akibatnya, untuk antrian besar ini bisa lebih cepat daripada menggunakan array.

74
19 окт. Balas diberikan oleh Robert Harvey 19 Okt 2009-10-19 21:21 '09 pada 21:21 2009-10-19 21:21

Array

Tumpukan

 var stack = []; //put value on top of stack stack.push(1); //remove value from top of stack var value = stack.pop(); 

Antrian

 var queue = []; //put value on end of queue queue.push(1); //Take first value from queue var value = queue.shift(); 
57
19 окт. jawaban yang diberikan oleh Jani Hartikainen 19 Oktober. 2009-10-19 21:19 '09 jam 9:19 malam 2009-10-19 21:19

Jika Anda ingin membuat struktur data Anda sendiri, Anda bisa membuatnya sendiri:

 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; }; 

Dan untuk antrian:

 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; }; 
27
09 мая '14 в 23:13 2014-05-09 23:13 jawabannya diberikan oleh user2954463 09 Mei '14 pada 23:13 2014-05-09 23:13

Implementasi Stack and Queue saya menggunakan Linked List

12
13 июля '15 в 17:59 2015-07-13 17:59 Jawaban diberikan oleh Rohit pada 13 Juli '15 pada 17:59 2015-07-13 17:59

Ada beberapa cara Anda dapat mengimplementasikan tumpukan dan antrian di Javascript. Sebagian besar jawaban yang diberikan di atas adalah implementasi yang cukup dangkal, dan saya akan mencoba untuk mengimplementasikan sesuatu yang lebih mudah dibaca (menggunakan fungsi sintaks baru es6) dan dapat diandalkan.

Berikut ini adalah implementasi dari stack:

 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 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; } } 

Dan ini adalah bagaimana Anda dapat menggunakan stack:

 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 

Jika Anda ingin melihat uraian terperinci tentang implementasi ini dan cara memperbaikinya, Anda dapat membaca di sini: http://jschap.com/data-structures-in-javascript-stack/

Berikut adalah kode untuk mengimplementasikan antrian 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 } } 

Inilah cara Anda dapat menggunakan implementasi ini:

 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 

Untuk membaca panduan lengkap tentang bagaimana struktur data ini diimplementasikan dan bagaimana mereka dapat ditingkatkan, Anda dapat melihat game javascript dengan seri Struktur Data di jschap.com. Berikut ini tautan ke antrian - http://jschap.com/playing-data-structures-javascript-queues/

8
11 дек. Jawabannya diberikan oleh Anish K. 11 Des. 2017-12-11 09:08 '17 pada 9:08 2017-12-11 09:08
  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  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)) 
7
28 дек. Jawabannya diberikan oleh Arijit Basu 28 Des. 2015-12-28 00:40 '16 pada 0:40 2015-12-28 00:40

Atau Anda dapat menggunakan dua array untuk menerapkan struktur data antrian.

 var temp_stack = new Array(); var stack = new Array(); temp_stack.push(1); temp_stack.push(2); temp_stack.push(3); 

Jika saya memunculkan elemen sekarang, hasilnya akan menjadi 3,2,1. Tetapi kami menginginkan struktur FIFO sehingga Anda dapat melakukan hal berikut.

 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 
5
29 окт. jawabannya diberikan Ni3 pada 29 Oktober 2012-10-29 09:09 '12 pada 9:09 2012-10-29 09:09

Berikut ini adalah implementasi antrian yang cukup sederhana dengan dua tujuan:

  • Tidak seperti array.shift (), Anda tahu bahwa metode dequeue ini membutuhkan waktu yang konstan (O (1)).
  • Untuk meningkatkan kecepatan, pendekatan ini menggunakan distribusi yang jauh lebih sedikit daripada pendekatan referensi.

Implementasi stack hanya berbagi tujuan kedua.

 // 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; }; 
5
02 сент. jawabannya diberikan snydergd 02 sept . 2016-09-02 01:05 '16 pada 1:05 2016-09-02 01:05

Pergeseran array Javascript () lambat, terutama ketika berisi banyak elemen. Saya tahu dua cara untuk mengimplementasikan antrian dengan kompleksitas disusutkan O (1).

Pertama, menggunakan buffer lingkaran dan menggandakan tabel. Saya menerapkannya sebelumnya. Anda dapat melihat kode sumber saya di sini https://github.com/kevyuu/rapid-queue

Cara kedua adalah menggunakan dua tumpukan. Ini adalah kode untuk antrian dua-tumpukan.

 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;} 

Ini adalah perbandingan kinerja menggunakan jsPerf

CircularQueue.shift () vs Array.shift ()

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

Seperti yang Anda lihat, itu jauh lebih cepat dengan dataset besar.

5
03 мая '15 в 17:43 2015-05-03 17:43 jawabannya diberikan kevinyu 03 Mei '15 pada 17:43 2015-05-03 17:43

Anda dapat menggunakan kelas kustomisasi Anda sendiri berdasarkan konsep, di sini adalah potongan kode yang dapat Anda gunakan untuk membuat materi

  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; } } } 

dan untuk memeriksanya, gunakan konsol dan coba baris ini secara bergantian.

 >> var st = new Stack(); >> st.push("BP"); >> st.push("NK"); >> st.getTop(); >> st.getCount(); >> st.displayAll(); >> st.pop(); >> st.displayAll(); >> st.getTop(); >> st.peek(); 
3
05 нояб. jawabannya diberikan jforjs 5 Nov. 2013-11-05 14:58 '13 pada 14:58 2013-11-05 14:58

Struktur array yang biasa dalam Javascript adalah stack (first come, last out), yang juga dapat digunakan sebagai antrian (first come, first out), tergantung pada panggilan apa yang Anda lakukan.

Periksa tautan ini untuk melihat cara membuat array berjalan sebagai antrian:

Antrian

3
19 окт. Justin Niessner dikirim balasan . 2009-10-19 21:19 '09 jam 9:19 malam 2009-10-19 21:19

Berikut ini adalah versi tertaut dari daftar antrian, yang juga termasuk node terakhir, seperti yang disarankan oleh @perkins, dan bagaimana ini paling tepat.

 // 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; }; 
3
06 сент. Jawabannya diberikan oleh DrByrd 06 Sep. 2016-09-06 21:44 '16 pada 21:44 2016-09-06 21:44

Jika Anda memahami tumpukan dengan fungsi push () dan pop (), maka antrian hanya untuk melakukan salah satu dari operasi ini dalam arti yang berlawanan. Oposite of push () adalah unshift () dan oposite dari pop () adalah shift (). Lalu:

 //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 
3
26 апр. Balas diberikan oleh Javier Giovannini pada 26 April 2014-04-26 23:07 '14 pada 23:07 2014-04-26 23:07

Jika Anda mencari implementasi struktur data stack dan antrian O6 ESOP dengan beberapa operasi dasar (berdasarkan daftar tertaut), maka mungkin terlihat seperti ini:

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(); }  isEmpty() { return !this.linkedList.tail; }  peek() { if (!this.linkedList.tail) { return null; } return this.linkedList.tail.value; }  push(value) { this.linkedList.append(value); }  pop() { const removedTail = this.linkedList.deleteTail(); return removedTail ? removedTail.value : null; }  toArray() { return this.linkedList .toArray() .map(linkedListNode => linkedListNode.value) .reverse(); }  toString(callback) { return this.linkedList.toString(callback); } } 

Dan implementasi LinkedList, yang digunakan untuk Stack dan Antrian dalam contoh di atas, dapat ditemukan di GitHub di sini .

2
14 мая '18 в 15:14 2018-05-14 15:14 jawabannya diberikan Oleksii Trekhleb 14 Mei '18 pukul 15:14 2018-05-14 15:14

Tidak ada larik

 //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; } } 
2
09 февр. Jawabannya diberikan oleh Andriy 09 Feb. 2014-02-09 05:06 '14 pada 5:06 2014-02-09 05:06
  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] 
1
27 сент. balasan yang diberikan oleh Rajesh Kumar 27 sept. 2017-09-27 08:58 '17 pada 8:58 pagi 2017-09-27 08:58

Hormat kami,

Dalam Javascript, implementasi tumpukan dan antrian adalah sebagai berikut:

Tumpukan: Tumpukan adalah wadah benda yang dimasukkan dan dihapus sesuai dengan prinsip "terakhir tiba, pertama keluar" (LIFO).

  • Push: Metode ini menambahkan satu atau lebih elemen ke ujung array dan mengembalikan panjang array yang baru.
  • Pop: Metode ini menghapus elemen terakhir dari array dan mengembalikan elemen ini.

Antrian: Antrian adalah wadah objek (koleksi linier) yang dimasukkan dan dihapus sesuai dengan prinsip first come, first served (FIFO).

  • Unshift: metode menambahkan satu atau lebih elemen ke awal array.

  • Shift: metode menghapus elemen pertama dari array.

1
20 дек. Jawab Daniel Barrientos 20 Des 2018-12-20 19:33 '18 pada 19:33 2018-12-20 19:33

Implementasi stack itu sepele, seperti dijelaskan dalam jawaban lain.

Namun, saya tidak menemukan jawaban yang memuaskan di utas ini untuk mengimplementasikan antrian di javascript, jadi saya membuatnya sendiri.

Ada tiga jenis solusi dalam aliran ini:

  • Array adalah solusi terburuk menggunakan array.shift() dalam array besar, sangat tidak efisien
  • Daftar tertaut adalah O (1), tetapi menggunakan objek untuk setiap elemen agak berlebihan, terutama jika ada banyak dan mereka kecil, misalnya menyimpan angka.
  • Array shift yang ditangguhkan. Ini terdiri dari mengaitkan indeks dengan array. Ketika item dibatalkan, indeks bergerak maju. Ketika indeks mencapai bagian tengah array, array dibagi menjadi dua bagian untuk menghapus bagian pertama.

Array pergeseran yang ditangguhkan adalah solusi yang paling memuaskan dalam pikiran saya, tetapi mereka masih menyimpan semuanya dalam satu array yang berdekatan yang besar, yang dapat bermasalah, dan aplikasi akan terhuyung ketika array dipotong.

Saya melakukan implementasi menggunakan daftar array array kecil (masing-masing 1000 elemen maks). Array berperilaku seperti array shift yang ditangguhkan, kecuali bahwa mereka tidak pernah diiris: ketika setiap elemen array dihapus, array hanya dibuang.

Paket npm dengan fungsionalitas FIFO dasar, saya baru saja mengkliknya. Kode ini dibagi menjadi dua bagian.

Inilah bagian pertama

  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; } 

Dan inilah Queue kelas utama:

 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; } 

Anotasi tipe ( : X ) dapat dengan mudah dihapus untuk mendapatkan kode JavaScript untuk ES6.

1
18 апр. coyotte508 diposting pada 18 April 2018-04-18 17:40 '18 pukul 17:40 2018-04-18 17:40

Inilah implementasi tumpukan saya.

 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()); 
0
16 февр. Jawabannya diberikan oleh Hitesh Joshi pada 16 Feb. 2018-02-16 10:47 '18 pada 10:47 2018-02-16 10:47

Buat beberapa kelas yang menyediakan metode berbeda yang dimiliki masing-masing struktur data ini (push, pop, mengintip, dll.). Sekarang kami menerapkan metode. Jika Anda terbiasa dengan konsep di balik tumpukan / antrian, itu harus cukup sederhana. Anda dapat mengimplementasikan tumpukan array dan antrian dengan daftar terkait, meskipun, tentu saja, ada cara lain. Javascript membuatnya mudah karena diketik dengan lemah, jadi Anda bahkan tidak perlu khawatir tentang jenis-jenis khas yang perlu Anda lakukan jika Anda menerapkannya dalam Java atau C #.

0
19 окт. jawabannya diberikan gema 19 Oktober. 2009-10-19 21:23 '09 pada jam 21:23, 2009-10-19 21:23

Sepertinya saya bahwa array tertanam sangat bagus untuk stack. Jika Anda ingin Antrian dalam TypeScript di sini menjadi implementasi

  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); } }  public getLength(): number { return (this.queue.length - this.offset); }  public isEmpty(): boolean { return (this.queue.length === 0); }  public enqueue(item) { this.queue.push(item); }  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; };  public peek(): any { return (this.queue.length > 0 ? this.queue[this.offset] : null); } } 

Dan inilah tes Jest untuknya

 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(); });