Как реализовать стек и очередь в JavaScript?

741

Каков наилучший способ реализации стека и очереди в JavaScript?

Я ищу алгоритм шунтирования и мне понадобятся эти структуры данных.

KingNestor
источник

Ответы:

1347
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, которые вы можете не знать "

Кори Баллу
источник
218
Я бы посоветовал с осторожностью использовать queue.shift. IIRC это не O (1), а O (n) и может быть слишком медленным, если очередь становится большой.
МАК
20
Я бы сказал, что это зависит от реализации JavaScript. Я не думаю, что это определено в спецификации javascript.
Георг Шолли
9
См. Code.stephenmorley.org/javascript/queues для простой реализации, которая улучшает производительность очереди.
Гили
15
Что касается проблем с производительностью очереди, посмотрите хорошее сравнение трех различных типов поведения стека на jsperf.com/queue-push-unshift-vs-shift-pop - Теперь, если бы кто-то был достаточно хорош, чтобы включить версию этого jsperf, которая бы содержит сценарий JS, упомянутый @Gili ...
Nenotlep
3
Я воскресил пост в блоге, связанный с этим ответом, так как archive.org не всегда самый эффективный. Я обновил ссылки и изображения, чтобы они работали, но я ничего не изменил.
Chev
87

В Javascript есть методы push и pop, которые работают с обычными объектами массива Javascript.

Для очередей смотрите здесь:

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

Очереди могут быть реализованы в JavaScript с использованием методов push и shift или методов unshift и pop объекта массива. Хотя это простой способ реализации очередей, он очень неэффективен для больших очередей - поскольку методы работают с массивами, методы shift и unshift перемещают каждый элемент массива при каждом вызове.

Queue.js - это простая и эффективная реализация очереди для JavaScript, чья функция удаления работает за амортизированное постоянное время. В результате для больших очередей это может быть значительно быстрее, чем использование массивов.

Роберт Харви
источник
2
С помощью ссылки, которой вы поделились, была реализована функция проверки результатов теста производительности, и я не вижу увеличения производительности при тестировании с Google Chrome версии 59. Queue.js не имеет ничего общего с его скоростью, но Chrome был предварительно согласован с его скоростью.
Сильо Полсон
Также я сделал демонстрацию с помощью queue.js, чтобы функция dequeue не удаляла элемент из очереди, поэтому мне интересно, как это работает? Если так, как вы можете получить новую очередь после удаления предыдущего элемента? codepen.io/adamchenwei/pen/VxgNrX?editors=0001
Ezeewei
похоже, что очередь в queue.js также требует дополнительной памяти, поскольку она клонирует массив с помощью слайса.
JaTo
Кроме того, базовый массив становится все больше и больше с каждым добавленным элементом. Хотя реализация время от времени уменьшает размер массива, общий размер увеличивается.
Филипп Миттерер
73

Массивы.

стек:

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();
Яни Хартикайнен
источник
1
Array.prototype.pop не удаляет значение из верхнего (первого элемента) массива. Удаляет значение из нижнего (последнего элемента) массива.
Майкл Геллер
21
@MichaelGeller Вершина стека является последним элементом массива. Методы push и pop для массива ведут себя как стек.
mrdommyg
@mrdommyg Array.prototype.pop удаляет последний элемент массива (см. developer.mozilla.org/en/docs/Web/JavaScript/Reference/… ). Последний в этом контексте означает элемент с самым высоким индексом. Массив в JS не имеет ничего общего со стеком. Это не стек только потому, что у него есть метод pop. Поп просто означает «удалить последний элемент и вернуть его». Конечно, вы можете имитировать функциональность стека с помощью массива, но массив по определению не является стеком. Это все еще список (объект типа «список» в соответствии с MDN).
Майкл Геллер
5
@MichaelGeller Поведение стека «первый вошел, последний вышел». Если реализовать его с помощью массива в JavaScript с его pushи popметодами, то проблема решена. Я действительно не вижу твоей точки зрения здесь.
Ракс Вебер
2
@MichaelGeller Стек является концептуальным. JS-массив (помимо прочего) по определению является стеком благодаря реализации семантики стека. То, что он также реализует семантику массива, не меняет этого. Вы можете использовать массив JS как стек из коробки, и в этом контексте то, что вы нажимаете и выдавливаете, является «верхним» элементом.
Ганс
32

Если вы хотите создать свои собственные структуры данных, вы можете создать свои собственные:

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;
};
user2954463
источник
13
Чтобы избежать необходимости перебирать всю вещь для добавления в конец, сохраните ссылку на последнюю через узел this.last =;
Перкинс
9
Никогда не создавайте такую ​​очередь, как эта, если у вас нет действительно веской причины ... хотя это может показаться логически правильным, процессоры не работают в соответствии с человеческими абстракциями. Итерации по структуре данных с указателями повсеместно приведут к ошибкам кэша в ЦП, в отличие от последовательного массива, который очень эффективен. blog.davidecoppola.com/2014/05/… ЦП ненавидят указатели с пылкой страстью - они, вероятно, являются причиной № 1 ошибок кэша и необходимости доступа к памяти из ОЗУ.
Centril
1
это заманчивое решение, но я не вижу, чтобы созданные Nodes удалялись при выталкивании / снятии очереди ... разве они не будут сидеть сложа руки, пока браузер не рухнет?
ноября
5
@cneuro В отличие от C ++, JavaScript - это язык для сборки мусора. У него есть deleteключевое слово, но это полезно только для того, чтобы пометить свойство объекта как отсутствующее, что отличается от простого присвоения undefinedсвойству . В JavaScript также есть newоператор, но он просто используется для установки thisнового пустого объекта при вызове функции. В C ++ вам нужно соединить каждый newс delete, но не в JavaScript, потому что GC. Чтобы прекратить использование памяти в JavaScript, просто прекратите ссылаться на объект, и он в конечном итоге будет восстановлен.
Бинки
Разве также не нужно проверять стек на переполнение, устанавливая максимальный размер стека?
пчела
16

Моя реализация 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();

Рохит
источник
10

Javascript array shift () работает медленно, особенно когда содержит много элементов. Я знаю два способа реализации очереди с амортизированной сложностью O (1).

Во-первых, используя круговой буфер и удвоение таблицы. Я реализовал это раньше. Вы можете увидеть мой исходный код здесь https://github.com/kevyuu/rapid-queue

Второй способ - использование двух стеков. Это код для очереди с двумя стеками

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

Как вы можете видеть, это значительно быстрее с большим набором данных

kevinyu
источник
8

Есть немало способов, которыми вы можете реализовать стеки и очереди в 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

Чтобы пройти полное руководство о том, как эти структуры данных были реализованы и как их можно улучшить, вы можете просмотреть серию «Игра со структурами данных в javascript» на jschap.com. Вот ссылки для очередей - http://jschap.com/playing-data-structures-javascript-queues/

Аниш К.
источник
7

Вы можете использовать свой собственный класс настройки, основанный на концепции, здесь фрагмент кода, который вы можете использовать, чтобы делать вещи

/*
*   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();
jforjs
источник
2
Downvote для соглашения об именах: метод, начинающийся с заглавной буквы, которая считается конструктором.
Павло
6
/*------------------------------------------------------------------ 
 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))
Ариджит Басу
источник
5

Или же вы можете использовать два массива для реализации структуры данных очереди.

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
Ni3
источник
1
Это работает, только если вы никогда pushпосле первого разаpop
jnnnnn
5

Вот довольно простая реализация очереди с двумя целями:

  • В отличие от array.shift (), вы знаете, что этот метод удаления занимает постоянное время (O (1)).
  • Для повышения скорости этот подход использует намного меньше распределений, чем подход связанного списка.

Реализация стека разделяет только вторую цель.

// 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; };
snydergd
источник
5

Реализация стека является тривиальной, как объяснено в других ответах.

Тем не менее, я не нашел удовлетворительных ответов в этой ветке для реализации очереди в javascript, поэтому я сделал свой собственный.

В этой теме есть три типа решений:

  • Массивы - худшее решение, использование array.shift()большого массива очень неэффективно.
  • Связанные списки - это O (1), но использование объекта для каждого элемента немного избыточно, особенно если их много и они маленькие, например, для хранения чисел.
  • Задержка сдвига массивов - состоит из связывания индекса с массивом. Когда элемент снят с производства, индекс движется вперед. Когда индекс достигает середины массива, массив разделяется на две части, чтобы удалить первую половину.

Я считаю, что массивы с отложенным сдвигом - самое удовлетворительное решение, но они все еще хранят все в одном большом непрерывном массиве, что может быть проблематично, и приложение будет колебаться, когда массив будет разрезан.

Я сделал реализацию, используя связанные списки небольших массивов (максимум 1000 элементов каждый). Массивы ведут себя как массивы с отложенным сдвигом, за исключением того, что они никогда не разделяются: когда каждый элемент в массиве удаляется, массив просто отбрасывается.

Пакет находится на npm с базовой функциональностью FIFO, я только недавно его отправил. Код разбит на две части.

Вот первая часть

/** 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.

coyotte508
источник
4

Если вы понимаете стеки с помощью функций push () и pop (), то очередь - это просто выполнение одной из этих операций в противоположном смысле. Противоположностью 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
Хавьер Джованнини
источник
Предупреждение для тех, кто пишет программное обеспечение, критичное к производительности. .shift()Метод не является правильной реализации очереди. Это O (n), а не O (1), и будет медленным для больших очередей.
Руди Кершоу
3

Вот версия связанного списка очереди, которая также включает в себя последний узел, предложенный @perkins и наиболее подходящий.

// 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;
};
DrByrd
источник
В dequeue вы должны вместо этого вернуть temp.data. Потому что это то, что было в очереди.
не робот
3

Если вы ищете реализацию структуры данных стека и очереди ES6 OOP с некоторыми базовыми операциями (на основе связанных списков), то это может выглядеть так:

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

А реализацию LinkedList, которая используется для стека и очереди в приведенных выше примерах, можно найти на GitHub здесь .

Алексей Трехлеб
источник
2

Нет массива (ов)

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

}
Андрей
источник
Как я могу запустить данную внутреннюю функцию, такую ​​как push pop?
Чандан Кумар
2

Обычная структура массива в Javascript - это стек (первым пришел, последним вышел), который также может быть использован в качестве очереди (первым вошел, первым вышел) в зависимости от того, какие звонки вы делаете.

Проверьте эту ссылку, чтобы увидеть, как заставить массив работать как очередь:

Очереди

Джастин Нисснер
источник
2

С Уважением,

В Javascript реализация стеков и очередей выглядит следующим образом:

Стек: стек - это контейнер объектов, которые вставляются и удаляются в соответствии с принципом «последний пришел первым - вышел» (LIFO).

  • Push: Метод добавляет один или несколько элементов в конец массива и возвращает новую длину массива.
  • Pop: Метод удаляет последний элемент из массива и возвращает этот элемент.

Очередь: Очередь - это контейнер объектов (линейная коллекция), которые вставляются и удаляются в соответствии с принципом «первым пришел-первым вышел» (FIFO).

  • Unshift: метод добавляет один или несколько элементов в начало массива.

  • Shift: метод удаляет первый элемент из массива.

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

Даниэль Барриентос
источник
1
  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

Мне кажется, что встроенный массив подходит для стека. Если вы хотите Очередь в TypeScript, вот реализация

/**
 * 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

Стюарт Кларк
источник
0

Создайте пару классов, которые предоставляют различные методы, которые есть в каждой из этих структур данных (push, pop, peek и т. Д.). Теперь реализуем методы. Если вы знакомы с концепциями стека / очереди, это должно быть довольно просто. Вы можете реализовать стек с массивом и очередь со связанным списком, хотя, безусловно, есть и другие способы сделать это. Javascript сделает это легко, потому что он слабо типизирован, так что вам даже не нужно беспокоиться о универсальных типах, что вам придется делать, если вы реализуете его в Java или C #.

эхо
источник
0

Вот моя реализация стеков.

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

вы можете использовать WeakMaps для реализации частной собственности в классе ES6 и преимуществ свойств String и методов на языке JavaScript, как показано ниже:

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
Салар
источник
0

Построить очередь, используя два стека.

O (1) для операций постановки в очередь и удаления из очереди.

class Queue {
  constructor() {
    this.s1 = []; // in
    this.s2 = []; // out
  }

  enqueue(val) {
    this.s1.push(val);
  }

  dequeue() {
    if (this.s2.length === 0) {
      this._move();
    }

    return this.s2.pop(); // return undefined if empty
  }

  _move() {
    while (this.s1.length) {
      this.s2.push(this.s1.pop());
    }
  }
}
Yuki-мечтатель
источник