Kako implementirati stog i red u javascript?

Koji je najbolji način za implementaciju stogova i redova u javascript?

Tražim algoritam za zaobilaženje i trebam te strukture podataka.

594
19 окт. postavila KingNestor 19. listopada. 2009-10-19 21:15 '09 u 21:15 2009-10-19 21:15
@ 23 odgovora
 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 

preuzeto iz 9 javascript savjeta koje ne znate

1070
19 окт. Odgovor je dao Corey Ballou 19. listopada. 2009-10-19 21:19 '09 u 21:19 2009-10-19 21:19

Javascript ima push i pop metode koje rade s običnim objektima u Javascript polju.

Za redove potražite ovdje:

border=0

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

Redovi se mogu implementirati u javascript, koristeći metode push i shift ili offset i pop metode polja objekta. Iako je to jednostavan način za implementaciju reda, vrlo je neučinkovit za velike redove - jer metode za rad s nizovima, smjenama i offset metodama premještaju svaki element u niz svaki put kad se pozovu.

Queue.js je jednostavna i učinkovita implementacija reda za JavaScript, čija se dekompresijska funkcija izvršava u načinu fiksnog konstantnog vremena. Kao rezultat toga, za velike redove to može biti puno brže od korištenja nizova.

74
19 окт. Odgovor dao Robert Harvey 19. listopada 2009-10-19 21:21 '09 u 21:21 2009-10-19 21:21

Polja.

stog

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

red

 var queue = []; //put value on end of queue queue.push(1); //Take first value from queue var value = queue.shift(); 
57
19 окт. odgovor dao Jani Hartikainen 19. listopada 2009-10-19 21:19 '09 u 21:19 2009-10-19 21:19

Ako želite stvoriti vlastite strukture podataka, možete izraditi vlastite:

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

I za red:

 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 odgovor je dao korisnik2954463 Svibanj 09 '14 u 23:13 2014-05-09 23:13

Moja implementacija skupa i redova pomoću povezanog popisa

12
13 июля '15 в 17:59 2015-07-13 17:59 Odgovor je dao Rohit 13. srpnja '15. U 17:59. 2015-07-13 17:59

Postoji nekoliko načina na koje možete implementirati stacks i queues u Javascriptu. Većina gore navedenih odgovora prilično je površna implementacija i pokušat ću implementirati nešto čitljivije (koristeći nove sintaktičke funkcije es6) i pouzdane.

Evo implementacije stog:

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

I to je način na koji možete koristiti stog:

 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 

Ako želite vidjeti detaljan opis ove implementacije i kako je poboljšati, možete pročitati ovdje: http://jschap.com/data-structures-in-javascript-stack/

Evo koda za implementaciju reda 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 } } 

Evo kako možete koristiti ovu implementaciju:

 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 

Da biste pregledali kompletan vodič o tome kako su te strukture podataka implementirane i kako se mogu poboljšati, možete pogledati javascript igru ​​s nizom podataka struktura na jschap.com. Ovdje su linkovi na redove - http://jschap.com/playing-data-structures-javascript-queues/

8
11 дек. Odgovor daje Anish K. 11. prosinca. 2017-12-11 09:08 '17 u 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 дек. Odgovor koji je dao Arijit Basu 28. prosinca 2015-12-28 00:40 '16 u 0:40 2015-12-28 00:40

Ili možete koristiti dva niza za implementaciju strukture podataka o redovima.

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

Ako sad popijem elemente, izlaz će biti 3,2,1. Ali želimo FIFO strukturu tako da možete učiniti sljedeće.

 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 окт. odgovor je dan Ni3 29. listopada 2012-10-29 09:09 '12 u 9:09 2012-10-29 09:09

Ovo je prilično jednostavna implementacija reda čekanja s dva cilja:

  • Za razliku od array.shift (), znate da ova metoda odvajanja traje konstantno vrijeme (O (1)).
  • Kako bi se povećala brzina, ovaj pristup koristi mnogo manje distribucija od referentnog pristupa.

Implementacija stog dijeli samo drugi cilj.

 // 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 сент. odgovor je dan snydergd 02 sep . 2016-09-02 01:05 '16 u 1:05 2016-09-02 01:05

Pomak matrice Javascripta () je spor, osobito kada sadrži mnogo elemenata. Znam dva načina za implementaciju reda s amortiziranom složenošću O (1).

Prvo, koristeći kružni međuspremnik i udvostručujući stol. Prije sam ga implementirao. Moj izvorni kod možete vidjeti ovdje https://github.com/kevyuu/rapid-queue

Drugi način je korištenje dva hrpe. Ovo je kôd za red dvaju stupova.

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

Ovo je usporedba performansi pomoću jsPerf

CircularQueue.shift () vs. Array.shift ()

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

Kao što možete vidjeti, to je mnogo brže s velikim skupom podataka.

5
03 мая '15 в 17:43 2015-05-03 17:43 odgovor je dan kevinyu 03 Svibanj '15 u 17:43 2015-05-03 17:43

Na temelju koncepta možete koristiti vlastiti razred prilagođavanja, ovdje je isječak koda koji možete koristiti za izradu materijala

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

i da biste to provjerili, koristite konzolu i isprobajte ovaj red za redom.

 >> 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 нояб. odgovor je dan jforjs 05 Nov. 2013-11-05 14:58 '13 u 14:58 2013-11-05 14:58

Uobičajena struktura polja u Javascriptu je stog (prvi dolazi, posljednji put), koji se također može koristiti kao red (prvi dolazi, prvi out), ovisno o tome koje pozive ste napravili.

Pogledajte ovu vezu da biste saznali kako napraviti niz kao red čekanja:

redovi

3
19 окт. Odgovor je dao Justin Niessner 19. listopada. 2009-10-19 21:19 '09 u 21:19 2009-10-19 21:19

Ovdje je povezana verzija popisa redova, koja također uključuje zadnji čvor, kako je predložio @perkins, i kako je najprikladniji.

 // 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 сент. Odgovor daje DrByrd 06. rujna. 2016-09-06 21:44 '16 u 21:44 2016-09-06 21:44

Ako ste razumjeli hrpe s funkcijama push () i pop (), onda je red samo za napraviti jednu od ovih operacija u suprotnom smislu. Nasuprot push () je unshift () i suprotno od pop () es shift (). zatim:

 //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 апр. Odgovor dao je Javier Giovannini 26. travnja 2014-04-26 23:07 '14 u 23:07 2014-04-26 23:07

Ako tražite implementaciju strukture podataka stog i ES6 OOP reda s nekim osnovnim operacijama (na temelju povezanih popisa), onda može izgledati ovako:

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

A implementacija LinkedLista, koji se koristi za Stack i Queue u gore navedenim primjerima, može se naći na GitHubu ovdje .

2
14 мая '18 в 15:14 2018-05-14 15:14 odgovor je dao Oleksii Trekhleb 14. svibnja '18 u 15:14 2018-05-14 15:14

Nema niza

 //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 февр. Odgovor daje Andriy 09. veljače. 2014-02-09 05:06 '14 u 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 сент. odgovor dao Rajesh Kumar 27 sep. 2017-09-27 08:58 '17 u 8:58 am 2017-09-27 08:58

S poštovanjem,

U Javascriptu je implementacija nizova i redova sljedeća:

Stack: Stack je kontejner objekata koji su umetnuti i uklonjeni prema principu “last arrival, first out” (LIFO).

  • Push: Metoda dodaje jedan ili više elemenata na kraj polja i vraća novu duljinu polja.
  • Pop: Metoda uklanja posljednji element iz niza i vraća taj element.

Red: Red čekanja je kontejner objekata (linearna zbirka) koji se umeću i uklanjaju prema principu FIFO.

  • Unshift: metoda dodaje jedan ili više elemenata na početak niza.

  • Shift: metoda uklanja prvi element iz niza.

1
20 дек. Odgovoriti Daniel Barrientos 20. prosinca 2018-12-20 19:33 '18 u 19:33 2018-12-20 19:33

Implementacija stog je trivijalna, kao što je objašnjeno u drugim odgovorima.

Međutim, nisam našao zadovoljavajuće odgovore u ovoj niti kako bih implementirao red u javascript, pa sam napravio svoj.

U ovom streamu postoje tri vrste rješenja:

  • Nizovi su najgore rješenje pomoću array.shift() u velikom nizu, vrlo neučinkovito
  • Povezani popisi su O (1), ali korištenje objekta za svaki element je pomalo pretjerano, pogotovo ako ih ima puno i mali su, primjerice, pohranjivanje brojeva.
  • Odloženi nizovi za prebacivanje. Sastoji se od povezivanja indeksa s nizom. Kada je stavka otkazana, indeks se pomiče naprijed. Kada indeks dosegne sredinu polja, polje se dijeli na dva dijela kako bi se uklonila prva polovica.

Odgođeni nizovi smjene su najučinkovitije rješenje u mom umu, ali oni još uvijek pohranjuju sve u jednom velikom susjednom nizu, što može biti problematično, a aplikacija će se pomaknuti kad se niz izreže.

Proveo sam implementaciju pomoću povezanih popisa malih polja (1000 max elemenata svaki). Nizovi se ponašaju kao nizovi odgođenih pomaka, osim što se nikada ne presijecaju: kada se obriše svaki element niza, polje se jednostavno odbacuje.

Npm paket s osnovnom FIFO funkcionalnošću, nedavno sam ga samo kliknuo. Kôd je podijeljen u dva dijela.

Ovdje je prvi dio

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

I ovdje je glavna klasa 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; } 

Oznake tipa ( : X ) mogu se jednostavno ukloniti kako bi se dobio JavaScript kod za ES6.

1
18 апр. coyotte508 objavljeno 18. travnja 2018-04-18 17:40 '18 u 17:40 sati 2018-04-18 17:40

Ovdje je moja implementacija hrpe.

 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 февр. Odgovor je dao Hitesh Joshi 16. veljače. 2018-02-16 10:47 '18 u 10:47 2018-02-16 10:47

Stvorite nekoliko klasa koje pružaju različite metode koje svaka od tih struktura podataka ima (push, pop, peek, itd.). Sada primjenjujemo metode. Ako ste upoznati s konceptima iza stog / reda, to bi trebalo biti prilično jednostavno. Možete implementirati skup nizova i red s pridruženom listom, iako, naravno, postoje i drugi načini. Javascript olakšava jer je slabo ukucavan, pa čak ni ne morate brinuti o tipičnim vrstama koje biste trebali učiniti ako ste ga implementirali u Java ili C #.

0
19 окт. odgovor je dat odjek 19 listopada. 2009-10-19 21:23 '09 u 21:23 2009-10-19 21:23

Čini mi se da je ugrađeni niz odličan za stog. Ako želite da Queue u TypeScriptu bude implementacija

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

A ovdje je i Jest test za njega

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

Nadam se da će netko pronaći ovo korisno,

živjeli,

Stu

0
04 апр. Odgovor daje Stuart Clark 04. travnja. 2018-04-04 13:04 '18 u 13:04 2018-04-04 13:04