Kaip įdiegti „Stack“ ir eilę „JavaScript“?

Koks yra geriausias būdas įgyvendinti steką ir eilę javascript'e?

Aš ieškoju aplinkkelio algoritmo, ir man reikia šių duomenų struktūrų.

594
19 окт. „ KingNestor“ nustatė spalio 19 d. 2009-10-19 21:15 '09 21:15 2009-10-19 21:15
@ 23 atsakymai
 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“ patarimų, kurių nežinote

1070
19 окт. Corey Ballou atsakymas spalio 19 d 2009-10-19 21:19 '09 9:19 val. 2009-10-19 21:19

„Javascript“ turi „push and pop“ metodus, kurie dirba su įprastais „Javascript“ masyvo objektais.

Dėl eilių ieškokite čia:

border=0

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

Eilės gali būti įdiegtos javascript'e, naudojant masyvo objekto paspaudimo ir perjungimo metodus arba ofsetinės ir pop metodus. Nors tai yra paprastas būdas įgyvendinti eilę, jis yra labai neveiksmingas didelėms eilėms - nes metodai, skirti dirbti su masyvais, pamainomis ir nuokrypiais, perkelia kiekvieną elementą į masyvą kiekvieną kartą, kai jie vadinami.

„Queue.js“ yra paprastas ir efektyvus „JavaScript“ eilės įgyvendinimas, kurio dekompresijos funkcija vykdoma fiksuoto pastovaus laiko režimu. Dėl to didelėms eilėms tai gali būti daug greičiau nei naudojant masyvus.

74
19 окт. Robert Harvey atsakymas 19 spalis 2009-10-19 21:21 '09 21:21 2009-10-19 21:21

Lėkštės

Stack

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

Eilė

 var queue = []; //put value on end of queue queue.push(1); //Take first value from queue var value = queue.shift(); 
57
19 окт. atsakymą pateikė Jani Hartikainen 19 val. 2009-10-19 21:19 '09 9:19 val. 2009-10-19 21:19

Jei norite sukurti savo duomenų struktūras, galite sukurti savo:

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

Ir eilėje:

 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 atsakymą pateikė vartotojo2954463 gegužės 09 '14, 23:13 2014-05-09 23:13

Mano „ Stack“ ir „ Queue“ diegimas naudojant susietą sąrašą

12
13 июля '15 в 17:59 2015-07-13 17:59 Atsakymą davė Rohitas liepos 15 d. 15, 17:59 2015-07-13 17:59

Yra nemažai būdų, kaip „JavaScript“ sistemoje įdiegti kaminus ir eiles. Dauguma pirmiau pateiktų atsakymų yra gana paviršutiniški, ir aš stengsiuosi įgyvendinti kažką aiškesnį (naudojant naujas sintaksės funkcijas es6) ir patikimą.

Čia pateikiamas kamino įgyvendinimas:

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

Taip galite naudoti steką:

 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 

Jei norite pamatyti išsamų šio įgyvendinimo aprašymą ir kaip jį patobulinti, galite skaityti čia: http://jschap.com/data-structures-in-javascript-stack/

Čia yra kodas, kuriuo galima įdiegti es6 eilę:

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

Štai kaip galite naudoti šį įgyvendinimą:

 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 

Norėdami peržiūrėti išsamią informaciją apie tai, kaip šios duomenų struktūros buvo įgyvendintos ir kaip jas galima tobulinti, galite peržiūrėti „JavaScript“ žaidimą su „Data Structures“ serija „jschap.com“. Čia pateikiamos nuorodos į eiles - http://jschap.com/playing-data-structures-javascript-queues/

8
11 дек. Atsakymą pateikė Anish K. 11 d. 2017-12-11 09:08 '17 at 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 дек. Arijit Basu atsakymas 28 d 2015-12-28 00:40 '16 prie 0:40 2015-12-28 00:40

Arba galite naudoti dvi masyvus, kad įgyvendintumėte eilės duomenų struktūrą.

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

Jei dabar pasirodysiu elementais, rezultatas bus 3,2,1. Bet mes norime FIFO struktūros, kad galėtumėte atlikti šiuos veiksmus.

 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 окт. atsakymas pateikiamas Ni3 29 okt. 2012-10-29 09:09 '12 - 09:09 2012-10-29 09:09

Čia yra gana paprastas eilės su dviem tikslais įgyvendinimas:

  • Skirtingai nuo array.shift (), žinote, kad šis dequeue metodas užima nuolatinį laiką (O (1)).
  • Norint padidinti greitį, šis metodas naudoja daug mažiau paskirstymo nei referencinis metodas.

Stekų įgyvendinimas dalijasi tik antruoju tikslu.

 // 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 сент. atsakymas pateikiamas snydergd 02 sep . 2016-09-02 01:05 '16 at 1:05 2016-09-02 01:05

„Javascript“ masyvo poslinkis () yra lėtas, ypač kai jame yra daug elementų. Aš žinau du būdus, kaip įgyvendinti eilę su nuvertėjimu O (1).

Pirma, naudojant apvalų buferį ir padvigubinkite lentelę. Aš ją įgyvendinau anksčiau. Mano šaltinį galite pamatyti čia https://github.com/kevyuu/rapid-queue

Antrasis būdas yra naudoti du kaminus. Tai yra dviejų stekų eilės kodas.

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

Tai yra veiklos palyginimas naudojant jsPerf

CircularQueue.shift () vs Array.shift ()

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

Kaip matote, su dideliu duomenų rinkiniu tai yra daug greičiau.

5
03 мая '15 в 17:43 2015-05-03 17:43 atsakymas pateikiamas kevinyu 03 gegužės 15 d. 17:43 2015-05-03 17:43

Jūs galite naudoti savo pritaikymo klasę pagal šią koncepciją, čia yra kodo fragmentas, kurį galite naudoti kuriant medžiagą

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

ir tai patikrinti, naudokite konsolę ir išbandykite šią eilutę.

 >> 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 нояб. atsakymas pateikiamas jforjs 05 lapkričio. 2013-11-05 14:58 '13, 14:58, 2013-11-05 14:58

Įprasta „Javascript“ masyvo struktūra yra stack (pirmiausia ateis, paskutinis), kuris taip pat gali būti naudojamas kaip eilė (pirmiausia ateina, iš pradžių), priklausomai nuo to, ką skambinate.

Peržiūrėkite šią nuorodą, kad pamatytumėte, kaip masyvą paleisti kaip eilę:

Eilės

3
19 окт. Atsakymą Justin Niessner pateikė spalio 19 d. 2009-10-19 21:19 '09 9:19 val. 2009-10-19 21:19

Čia yra susieta eilių sąrašo versija, kurioje taip pat yra paskutinis mazgas, kaip pasiūlė @perkins, ir kaip jis yra tinkamiausias.

 // 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 сент. atsakymą pateikė DrByrd 06 2016-09-06 21:44 '16 at 21:44 2016-09-06 21:44

Jei suprantate, kokių kaminų yra su funkcijomis „push“ () ir „pop“ (), eilė yra tik tam, kad atliktumėte vieną iš šių operacijų priešinga prasme. Stūmimo () posūkis yra nepakeistas () ir pop () poslinkio () poslinkis (). Tada:

 //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 апр. Javier Giovannini atsakymas, pateiktas balandžio 26 d 2014-04-26 23:07 '14, 23:07 2014-04-26 23:07

Jei ieškote kamino duomenų struktūros ir ES6 OOP eilės įgyvendinimo su kai kuriomis pagrindinėmis operacijomis (remiantis susietais sąrašais), tada jis gali atrodyti taip:

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

„LinkedList“, kuri yra naudojama „Stack“ ir „Queue“, įgyvendinimas aukščiau pateiktuose pavyzdžiuose, yra čia .

2
14 мая '18 в 15:14 2018-05-14 15:14 atsakymas pateikiamas Oleksii Trekhleb gegužės 14, 18 d. 15:14 2018-05-14 15:14

Nėra masyvo (-ų)

 //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 февр. Atsakymą pateikė Andriy 09 Feb. 2014-02-09 05:06 '14 at 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 сент. atsakė Rajesh Kumar 27 sep. 2017-09-27 08:58 '17 at 8:58 am 2017-09-27 08:58

Pagarbiai

„Javascript“ versijose „stekų ir eilių“ įgyvendinimas yra toks:

Stack: Stack - tai objektų konteineris, kuris įterpiamas ir pašalinamas pagal principą „paskutinį kartą atvykęs, iš pradžių“ (LIFO).

  • Stumti: metodas prideda vieną ar daugiau elementų masyvo pabaigoje ir grąžina naują masyvo ilgį.
  • Pop: metodas pašalina paskutinį elementą iš masyvo ir grąžina šį elementą.

Eilė: eilė yra objektų konteineris (linijinė kolekcija), kuri įterpiama ir pašalinama pagal principą „pirmas atėjai, pirmas“ (FIFO).

  • Unshift: metodas prideda vieną ar daugiau elementų masyvo pradžioje.

  • Shift: metodas pašalina pirmąjį elementą iš masyvo.

1
20 дек. Atsakyti Daniel Barrientos 20 gr 2018-12-20 19:33 '18 19:33 2018-12-20 19:33

Kaip paaiškinta kituose atsakymuose, kamino įgyvendinimas yra nereikšmingas.

Tačiau šioje temoje neradau tinkamų atsakymų, kad įgyvendintume „JavaScript“ eilę, todėl padariau savo pačių.

Šiame sraute yra trijų tipų sprendimai:

  • Array yra blogiausias sprendimas, naudojant array.shift() dideliame masyve, labai neveiksmingas
  • Susieti sąrašai yra O (1), bet objekto naudojimas kiekvienam elementui yra šiek tiek pernelyg didelis, ypač jei yra daug jų ir jie yra maži, pavyzdžiui, numeriai.
  • Atidėtos pamainos matricos. Ją sudaro indekso susiejimas su masyvu. Kai elementas atšaukiamas, indeksas juda į priekį. Kai indeksas pasiekia masyvo vidurį, masyvas yra padalintas į dvi dalis, kad būtų pašalinta pirmoji pusė.

Atidėtojo poslinkio matricos yra man labiausiai patenkinamas sprendimas, tačiau jie vis dar saugo viską vienoje didelėje gretimoje matricoje, kuri gali būti problemiška, o taikymas bus sustingęs, kai masyvas bus nupjautas.

Įgyvendindamas naudoju susietus smulkių masyvų sąrašus (po 1000 max elementų). Įrenginiai elgiasi kaip atidėtos pamainos matricos, išskyrus tai, kad jie niekada nesupjaustyti: kai kiekvienas masyvo elementas ištrinamas, masyvas yra tiesiog išmestas.

Npm paketas su pagrindinėmis FIFO funkcijomis, neseniai jį spustelėjau. Kodas suskirstytas į dvi dalis.

Čia yra pirmoji dalis

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

Ir čia yra pagrindinė klasės 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; } 

Tipo ( : X ) anotacijas galima lengvai pašalinti, kad gautumėte „JavaScript“ kodą ES6.

1
18 апр. coyotte508 paskelbė balandžio 18 d 2018-04-18 17:40 '18, 17:40 val. 2018-04-18 17:40

Štai mano krūvų įgyvendinimas.

 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 февр. Atsakymą pateikė Hitesh Joshi . 2018-02-16 10:47 '18 at 10:47 2018-02-16 10:47

Sukurkite keletą klasių, kurios pateikia skirtingus metodus, kuriuos kiekviena iš šių duomenų struktūrų turi (stumti, pop, peek ir tt). Dabar įgyvendiname metodus. Jei esate susipažinę su užkrovimo / eilės koncepcijomis, tai turėtų būti gana paprasta. Galite įgyvendinti masyvo kaminą ir eilę su susijusiu sąrašu, nors, žinoma, yra ir kitų būdų. „Javascript“ palengvina, nes jis yra silpnai įvestas, todėl net nereikia jaudintis dėl tipiškų tipų, kuriuos reikės padaryti, jei ją įdiegėte „Java“ arba „C #“.

0
19 окт. atsakymas pateikiamas echo 19 okt. 2009-10-19 21:23 '09 9:23 val. 2009-10-19 21:23

Man atrodo, kad įdėta masyvas puikiai tinka kaminai. Jei norite, kad eilutėje „TypeScript“ būtų įgyvendinimas

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

Ir čia yra Jest testas

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

Tikiuosi, kad kažkas tai naudinga,

Hooray

Stu

0
04 апр. Atsakymą pateikė Stuart Clark 04 balandžio. '18 в 13:04 2018-04-04 13:04