Skip to content

Crystal

Deque

class `Deque(T)`
inherits `Reference` ¶

A Deque ("double-ended queue") is a collection of objects of type T that behaves much like an Array.

Deque has a subset of Array's API. It performs better than an Array when there are frequent insertions or deletions of items near the beginning or the end.

The most typical use case of a Deque is a queue: use push to add items to the end of the queue and shift to get and remove the item at the beginning of the queue.

This Deque is implemented with a dynamic array used as a circular buffer.

Included modules

Indexable

Class methods¶

`.from_json(string_or_io, &) : Nil` ¶

`.additive_identity : self` ¶

Returns the additive identity of this type.

This is an empty deque.

`.new(size : Int, value : T)` ¶

Creates a new Deque of the given size filled with the same value in each position.

Deque.new(3, 'a') # => Deque{'a', 'a', 'a'}

`.new(array : Array(T))` ¶

Creates a new Deque that copies its items from an Array.

Deque.new([1, 2, 3]) # => Deque{1, 2, 3}

`.new(initial_capacity : Int)` ¶

Creates a new empty Deque backed by a buffer that is initially initial_capacity big.

The initial_capacity is useful to avoid unnecessary reallocations of the internal buffer in case of growth. If you have an estimate of the maximum number of elements a deque will hold, you should initialize it with that capacity for improved execution performance.

deq = Deque(Int32).new(5)
deq.size # => 0

`.new(pull : JSON::PullParser)` ¶

`.new` ¶

Creates a new empty Deque

`.new(size : Int, &block : Int32 -> T)` ¶

Creates a new Deque of the given size and invokes the block once for each index of the deque, assigning the block's value in that index.

Deque.new(3) { |i| (i + 1) ** 2 } # => Deque{1, 4, 9}

`.new(pull : JSON::PullParser` ¶

Methods¶

`#+(other : Deque(U)) forall U` ¶

Concatenation. Returns a new Deque built by concatenating two deques together to create a third. The type of the new deque is the union of the types of both the other deques.

`#<<(value : T)` ¶

Alias for push.

`#==(other : Deque)` ¶

Returns true if it is passed a Deque and equals? returns true for both deques, the caller and the argument.

deq = Deque{2, 3}
deq.unshift 1
deq == Deque{1, 2, 3} # => true
deq == Deque{2, 3}    # => false

`#[]=(index : Int, value : T)` ¶

Sets the given value at the given index.

Raises IndexError if the deque had no previous value at the given index.

`#clear` ¶

Removes all elements from self.

`#clone` ¶

Returns a new Deque that has this deque's elements cloned. That is, it returns a deep copy of this deque.

Use #dup if you want a shallow copy.

`#concat(other : Enumerable(T))` ¶

Appends the elements of other to self, and returns self.

`#delete(obj)` ¶

Removes all items from self that are equal to obj.

a = Deque{"a", "b", "b", "b", "c"}
a.delete("b") # => true
a             # => Deque{"a", "c"}

`#delete_at(index : Int)` ¶

Deletes the item that is present at the index. Items to the right of this one will have their indices decremented. Raises IndexError if trying to delete an element outside the deque's range.

a = Deque{1, 2, 3}
a.delete_at(1) # => 2
a              # => Deque{1, 3}

`#dup` ¶

Returns a new Deque that has exactly this deque's elements. That is, it returns a shallow copy of this deque.

`#each(&) : Nil` ¶

Yields each item in this deque, from first to last.

Do not modify the deque while using this variant of each!

`#insert(index : Int, value : T)` ¶

Insert a new item before the item at index. Items to the right of this one will have their indices incremented.

a = Deque{0, 1, 2}
a.insert(1, 7) # => Deque{0, 7, 1, 2}

`#inspect(io : IO) : Nil` ¶

Appends a String representation of this object which includes its class name, its object address and the values of all instance variables.

class Person
  def initialize(@name : String, @age : Int32)
  end
end

Person.new("John", 32).inspect # => #<Person:0x10fd31f20 @name="John", @age=32>

`#pop` ¶

Removes and returns the last item, if not empty, otherwise executes the given block and returns its value.

`#pop` ¶

Removes and returns the last item. Raises IndexError if empty.

a = Deque{1, 2, 3}
a.pop # => 3
a     # => Deque{1, 2}

`#pop(n : Int)` ¶

Removes the last n (at most) items in the deque.

`#pop?` ¶

Removes and returns the last item, if not empty, otherwise nil.

`#pretty_print(pp)` ¶

`#push(value : T)` ¶

Adds an item to the end of the deque.

a = Deque{1, 2}
a.push 3 # => Deque{1, 2, 3}

`#reject!(pattern)` ¶

Modifies self, deleting the elements in the collection for which pattern === element.

a = Deque{1, 6, 2, 4, 8}
a.reject!(3..7)
a # => Deque{1, 2, 8}

See also: Deque#reject.

`#reject!` ¶

Modifies self, deleting the elements in the collection for which the passed block returns true. Returns self.

a = Deque{1, 6, 2, 4, 8}
a.reject! { |x| x > 3 }
a # => Deque{1, 2}

See also: Deque#reject.

`#rotate!(n : Int = 1)` ¶

Rotates this deque in place so that the element at n becomes first.

For positive n, equivalent to n.times { push(shift) }.
For negative n, equivalent to (-n).times { unshift(pop) }.

`#select!` ¶

Modifies self, keeping only the elements in the collection for which the passed block returns true. Returns self.

a = Deque{1, 6, 2, 4, 8}
a.select! { |x| x > 3 }
a # => Deque{6, 4, 8}

See also: Deque#select.

`#select!(pattern)` ¶

Modifies self, keeping only the elements in the collection for which pattern === element.

ary = [1, 6, 2, 4, 8]
ary.select!(3..7)
ary # => [6, 4]

See also: Deque#select.

`#shift(n : Int)` ¶

Removes the first n (at most) items in the deque.

`#shift` ¶

Removes and returns the first item. Raises IndexError if empty.

a = Deque{1, 2, 3}
a.shift # => 1
a       # => Deque{2, 3}

`#shift` ¶

Removes and returns the first item, if not empty, otherwise executes the given block and returns its value.

`#shift?` ¶

Removes and returns the first item, if not empty, otherwise nil.

`#size` ¶

Returns the number of elements in the deque.

Deque{:foo, :bar}.size # => 2

`#swap(i, j)` ¶

Swaps the items at the indices i and j.

`#to_json(json : JSON::Builder)` ¶

`#to_s(io : IO) : Nil` ¶

Appends a short String representation of this object which includes its class name and its object address.

class Person
  def initialize(@name : String, @age : Int32)
  end
end

Person.new("John", 32).to_s # => #<Person:0x10a199f20>

`#unsafe_fetch(index : Int)` ¶

Returns the element at the given index, without doing any bounds check.

Indexable makes sure to invoke this method with index in 0...size, so converting negative indices to positive ones is not needed here.

Clients never invoke this method directly. Instead, they access elements with #[](index) and #[]?(index).

This method should only be directly invoked if you are absolutely sure the index is in bounds, to avoid a bounds check for a small boost of performance.

`#unshift(value : T)` ¶

Adds an item to the beginning of the deque.

a = Deque{1, 2}
a.unshift 0 # => Deque{0, 1, 2}