Deque
class Deque(T)
Overview
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
Defined in:
deque.crClass Method Summary
- .new(size : Int, value : T)
Creates a new
Deque
of the given size filled with the same value in each position- - .new(initial_capacity : Int)
Creates a new empty
Deque
backed by a buffer that is initiallyinitial_capacity
big- - .new(array : Array(T))
Creates a new
Deque
that copies its items from an Array- - .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-
Instance Method Summary
- #+(other : Deque(U)) forall U
Concatenation.
- #<<(value : T)
Alias for
#push
. - #==(other : Deque)
Returns
true
if it is passed aDeque
andequals?
returnstrue
for both deques, the caller and the argument- - #[]=(index : Int, value : T)
Sets the given value at the given index.
- #clear
Removes all elements from
self
. - #clone
Returns a new
Deque
that has this deque's elements cloned- - #concat(other : Enumerable(T))
Appends the elements of other to
self
, and returnsself
. - #delete(obj)
Removes all items from
self
that are equal to obj. - #delete_at(index : Int)
Delete the item that is present at the index.
- #dup
Returns a new
Deque
that has exactly this deque's elements- - #each(&block) : Nil
Yields each item in this deque, from first to last.
- #insert(index : Int, value : T)
Insert a new item before the item at index.
- #inspect(io : IO)
- #pop(n : Int)
Removes the last n (at most) items in the deque.
- #pop
Removes and returns the last item.
- #pop(&block)
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, if not empty, otherwise
nil
. - #pretty_print(pp)
- #push(value : T)
Adds an item to the end of the deque.
- #rotate!(n : Int = 1)
Rotates this deque in place so that the element at n becomes first.
- #shift(&block)
Removes and returns the first item, if not empty, otherwise executes the given block and returns its value.
- #shift(n : Int)
Removes the first n (at most) items in the deque.
- #shift
Removes and returns the first item.
- #shift?
Removes and returns the first item, if not empty, otherwise
nil
. - #size
Returns the number of elements in the deque.
- #swap(i, j)
Swaps the items at the indices i and j.
- #to_a
Returns an
Array
(shallow copy) that contains all the items of this deque- - #to_s(io : IO)
- #unsafe_at(index : Int)
- #unshift(value : T)
Adds an item to the beginning of the deque.
Instance methods inherited from module Comparable(Deque(T))
<, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >= Instance methods inherited from module Indexable(T)
[](index : Int) [], []?(index : Int) []?, at(index : Int, &block)at(index : Int) at, bsearch(&block) bsearch, bsearch_index(&block) bsearch_index, each(&block)
each each, each_index(&block) : Nil
each_index each_index, empty? empty?, equals?(other : Indexable, &block)
equals?(other, &block) equals?, first(&block)
first first, first? first?, hash hash, index(object, offset : Int = 0)
index(offset : Int = 0, &block) index, last
last(&block) last, last? last?, reverse_each(&block) : Nil
reverse_each reverse_each, rindex(offset = size - 1, &block)
rindex(value, offset = size - 1) rindex, sample(random = Random::DEFAULT) sample, size size, unsafe_at(index : Int) unsafe_at, values_at(*indexes : Int) values_at, zip(other : Indexable, &block)
zip(other : Indexable(U)) forall U zip, zip?(other : Indexable, &block)
zip?(other : Indexable(U)) forall U zip?
Instance methods inherited from module Enumerable(T)
all?(&block)all? all?, any?(&block)
any? any?, chunks(&block : T -> U) forall U chunks, compact_map(&block) compact_map, count(&block)
count(item) count, cycle(n, &block)
cycle(&block) cycle, each(&block : T -> _) each, each_cons(count : Int, reuse = false, &block) each_cons, each_slice(count : Int, reuse = false, &block) each_slice, each_with_index(offset = 0, &block) each_with_index, each_with_object(obj, &block) each_with_object, find(if_none = nil, &block) find, first(count : Int)
first first, first? first?, flat_map(&block : T -> Array(U) | Iterator(U) | U) forall U flat_map, grep(pattern) grep, group_by(&block : T -> U) forall U group_by, in_groups_of(size : Int, filled_up_with : U = nil) forall U
in_groups_of(size : Int, filled_up_with : U = nil, reuse = false, &block) forall U in_groups_of, includes?(obj) includes?, index(&block)
index(obj) index, index_by(&block : T -> U) forall U index_by, join(separator, io)
join(separator = "")
join(separator, io, &block)
join(separator = "", &block) join, map(&block : T -> U) forall U map, map_with_index(&block : T, Int32 -> U) forall U map_with_index, max max, max? max?, max_by(&block : T -> U) forall U max_by, max_by?(&block : T -> U) forall U max_by?, max_of(&block : T -> U) forall U max_of, max_of?(&block : T -> U) forall U max_of?, min min, min? min?, min_by(&block : T -> U) forall U min_by, min_by?(&block : T -> U) forall U min_by?, min_of(&block : T -> U) forall U min_of, min_of?(&block : T -> U) forall U min_of?, minmax minmax, minmax? minmax?, minmax_by(&block : T -> U) forall U minmax_by, minmax_by?(&block : T -> U) forall U minmax_by?, minmax_of(&block : T -> U) forall U minmax_of, minmax_of?(&block : T -> U) forall U minmax_of?, none?(&block)
none? none?, one?(&block) one?, partition(&block) partition, product(&block)
product(initial : Number, &block)
product
product(initial : Number) product, reduce(&block)
reduce(memo, &block) reduce, reject(&block : T -> ) reject, select(&block : T -> ) select, size size, skip(count : Int) skip, skip_while(&block) skip_while, sum(initial)
sum
sum(initial, &block)
sum(&block) sum, take_while(&block) take_while, to_a to_a, to_h to_h, to_set to_set
Instance methods inherited from module Iterable(T)
chunk(reuse = false, &block : T -> U) forall U chunk, cycle(n)cycle cycle, each each, each_cons(count : Int, reuse = false) each_cons, each_slice(count : Int, reuse = false) each_slice, each_with_index(offset = 0) each_with_index, each_with_object(obj) each_with_object
Instance methods inherited from class Reference
==(other : self)==(other) ==, dup dup, hash hash, inspect(io : IO) : Nil inspect, object_id : UInt64 object_id, pretty_print(pp) : Nil pretty_print, same?(other : Reference)
same?(other : Nil) same?, to_s(io : IO) : Nil to_s
Class methods inherited from class Reference
new new Instance methods inherited from class Object
!=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)===(other : YAML::Any)
===(other) ===, =~(other) =~, class class, dup dup, hash hash, inspect(io : IO)
inspect inspect, itself itself, not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, tap(&block) tap, to_json(io : IO)
to_json to_json, to_pretty_json(indent : String = " ")
to_pretty_json(io : IO, indent : String = " ") to_pretty_json, to_s
to_s(io : IO) to_s, to_yaml(io : IO)
to_yaml to_yaml, try(&block) try
Class methods inherited from class Object
from_json(string_or_io, root : String) : selffrom_json(string_or_io) : self from_json, from_yaml(string_or_io) : self from_yaml
Class Method Detail
def self.new(size : Int, value : T)Source
Creates a new Deque
of the given size filled with the same value in each position-
Deque.new(3, 'a') # => Deque{'a', 'a', 'a'}
def self.new(initial_capacity : Int)Source
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
def self.new(array : Array(T))Source
Creates a new Deque
that copies its items from an Array-
Deque.new([1, 2, 3]) # => Deque{1, 2, 3}
def self.newSource
Creates a new empty Deque
def self.new(size : Int, &block : Int32 -> T)Source
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}
Instance Method Detail
def +(other : Deque(U)) forall USource
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-
def ==(other : Deque)Source
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
def []=(index : Int, value : T)Source
Sets the given value at the given index.
Raises IndexError
if the deque had no previous value at the given index-
def clearSource
Removes all elements from self
.
def cloneSource
def concat(other : Enumerable(T))Source
Appends the elements of other to self
, and returns self
.
def delete(obj)Source
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"}
def delete_at(index : Int)Source
Delete 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}
def dupSource
Returns a new Deque
that has exactly this deque's elements- That is, it returns a shallow copy of this deque-
def each(&block) : NilSource
Yields each item in this deque, from first to last.
Do not modify the deque while using this variant of #each
!
def insert(index : Int, value : T)Source
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}
def popSource
Removes and returns the last item. Raises IndexError
if empty-
a = Deque{1, 2, 3} a.pop # => 3 a # => Deque{1, 2}
def pop(&block)Source
Removes and returns the last item, if not empty, otherwise executes the given block and returns its value.
def pop?Source
Removes and returns the last item, if not empty, otherwise nil
.
def pretty_print(pp)Source
def push(value : T)Source
Adds an item to the end of the deque.
a = Deque{1, 2} a.push 3 # => Deque{1, 2, 3}
def rotate!(n : Int = 1)Source
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) }
.
def shift(&block)Source
Removes and returns the first item, if not empty, otherwise executes the given block and returns its value.
def shiftSource
Removes and returns the first item. Raises IndexError
if empty-
a = Deque{1, 2, 3} a.shift # => 1 a # => Deque{2, 3}
def shift?Source
Removes and returns the first item, if not empty, otherwise nil
.
def sizeSource
Returns the number of elements in the deque.
Deque{:foo, :bar}.size # => 2
def swap(i, j)Source
Swaps the items at the indices i and j.
def unshift(value : T)Source
Adds an item to the beginning of the deque.
a = Deque{1, 2} a.unshift 0 # => Deque{0, 1, 2}
© 2012–2017 Manas Technology Solutions.
Licensed under the Apache License, Version 2.0.
https://crystal-lang.org/api/0.22.0/Deque.html