AVLTree::SortedMultiset(T)
Inherits Iterable < Indexable < Enumerable < Iterable < Enumerable < Reference < Object
SortedMultiset implements a collection of sorted values with possible duplicates.
Sample
require "avltree"
mset = AVLTree::SortedMultiset(Int32).new
mset << 3 << 1 << 4 << 1 << 5 << 9
mset # => SortedMultiset{1, 1, 3, 4, 5, 9}
mset[0] # => 1
mset[1] # => 1
mset[2] # => 3 (SortedMultiset#[k] returns the kth object)
mset.lower_bound(-1) # => 0
mset.lower_bound(2) # => 2
mset.lower_bound(3) # => 2
mset.lower_bound(9) # => 5
mset.lower_bound(10) # => 6
mset.delete(1)
mset # => SortedMultiset{1, 3, 4, 5, 9}Constructors
Instance methods
Like at, but returns nil
if trying to access an element outside the multiset's range.
Returns the number of elements in the set that exist within the range
set = AVLTree::SortedSet(Int32){3, 1, 4, 1, 5, 9}
set.count(0..1).should eq 2
set.count(0...1).should eq 0
set.count(0..2).should eq 2
set.count(0...2).should eq 2
set.count(2..3).should eq 1
set.count(2...3).should eq 0
set.count(2..9).should eq 4
set.count(2...9).should eq 3
set.count(2...).should eq 4
set.count(...).should eq 6
set.count(...9).should eq 5Returns the number of times that the passed item is present in the collection.
[1, 2, 3, 4].count(3) # => 1Returns a shallow copy of this object.
This allocates a new object and copies the contents of
self into it.
Calls the given block once for each element in self, passing that
element as a parameter.
a = ["a", "b", "c"]
a.each { |x| print x, " -- " }produces:
a -- b -- c --Returns true if self is empty, false otherwise.
([] of Int32).empty? # => true
([1]).empty? # => falseReturns the element at the given index, if in bounds, otherwise executes the given block with the index and returns its value.
a = [:foo, :bar]
a.fetch(0) { :default_value } # => :foo
a.fetch(2) { :default_value } # => :default_value
a.fetch(2) { |index| index * 3 } # => 6Returns the first element in the collection. Raises Enumerable::EmptyError
if the collection is empty.
([1, 2, 3]).first # => 1
([] of Int32).first # raises Enumerable::EmptyErrorReturns the first element in the collection.
When the collection is empty, returns nil.
([1, 2, 3]).first? # => 1
([] of Int32).first? # => nilReturns true if the collection contains obj, false otherwise.
[1, 2, 3].includes?(2) # => true
[1, 2, 3].includes?(5) # => falseReturns the index of the first appearance of object in self
starting from the given offset, or nil if object is not in self.
[1, 2, 3, 1, 2, 3].index(2, offset: 2) # => 4Returns the index of the first appearance of obj in self
starting from the given offset. Raises Enumerable::NotFoundError if
obj is not in self.
[1, 2, 3, 1, 2, 3].index!(2, offset: 2) # => 4Appends 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>Returns the last element of self if it's not empty, or raises IndexError.
([1, 2, 3]).last # => 3
([] of Int32).last # raises IndexErrorReturns the last element of self if it's not empty, or nil.
([1, 2, 3]).last? # => 3
([] of Int32).last? # => nilReturns the element with the maximum value in the collection.
It compares using > so it will work for any type that supports that method.
[1, 2, 3].max # => 3
["Alice", "Bob"].max # => "Bob"Raises Enumerable::EmptyError if the collection is empty.
Returns the element with the minimum value in the collection.
It compares using < so it will work for any type that supports that method.
[1, 2, 3].min # => 1
["Alice", "Bob"].min # => "Alice"Raises Enumerable::EmptyError if the collection is empty.
Returns a UInt64 that uniquely identifies this object.
The returned value is the memory address of this object.
string = "hello"
string.object_id # => 4460249568
pointer = Pointer(String).new(string.object_id)
string2 = pointer.as(String)
string2.object_id == string.object_id # => trueReturns the index of the last appearance of value in self, or
nil if the value is not in self.
If offset is given, it defines the position to end the search (elements beyond this point are ignored).
[1, 2, 3, 2, 3].rindex(2) # => 3
[1, 2, 3, 2, 3].rindex(2, offset: 2) # => 1Returns the index of the last appearance of value in self, or
nil if the value is not in self.
If offset is given, it defines the position to end the search (elements beyond this point are ignored).
[1, 2, 3, 2, 3].rindex(2) # => 3
[1, 2, 3, 2, 3].rindex(2, offset: 2) # => 1Raises Enumerable::NotFoundError if value is not in self.
Returns true if this reference is the same as other. This is only
true if this reference's object_id is the same as other's.
Returns an Array with all the elements in the collection.
(1..5).to_a # => [1, 2, 3, 4, 5]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>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.