Welcome to our exploration of handling sorted structures using Ruby. In this lesson, we'll learn about alternative methods to manage sorted collections in Ruby. We'll explore how the SortedSet class and Ruby's built-in sorting techniques can help maintain organized data structures.

In Ruby, a SortedSet, available through the set library, is a collection that automatically maintains its elements in a sorted order based on natural ordering or a custom comparator if defined. It is a collection of unique values. In contrast, a Hash is a key-value pair structure that maintains the order of insertion, preserving the sequence in which the pairs are added, but does not sort its keys or values.

Ruby
Copy to clipboard
1require 'set'
2
3sorted_set = SortedSet.new(['b', 'a', 'c'])
4puts sorted_set.to_a  # Outputs: ["a", "b", "c"]

Ruby allows us to define custom classes to create objects that represent our data. For example, you might use a "Person" class to handle employee information or a "Book" class for a library database. Here's a simple implementation of a Person class in Ruby:

Ruby
Copy to clipboard
1class Person
2  attr_accessor :name, :age
3
4  def initialize(name, age)
5    @name = name
6    @age = age
7  end
8end
9
10person = Person.new("John Doe", 30)
11puts person.name  # Outputs: John Doe
12puts person.age   # Outputs: 30

We can manage sorted collections by sorting arrays of custom objects or using SortedSet. Below is an example of how to handle custom sorting of custom objects in Ruby:

Ruby
Copy to clipboard
1require 'set'
2
3class Person
4  attr_accessor :name, :age
5
6  def initialize(name, age)
7    @name = name
8    @age = age
9  end
10
11  def <=>(other)
12    [@age, @name] <=> [other.age, other.name]
13  end
14end
15
16people = SortedSet.new
17john = Person.new("John", 30)
18alice = Person.new("Alice", 25)
19
20people.add(john)
21people.add(alice)
22
23people.each do |person|
24  puts "#{person.name}, Age: #{person.age}"
25end
26# Output:
27# Alice, Age: 25
28# John, Age: 30

Ruby's comparator methods, like <=>, enable us to define how our custom objects are compared. This is necessary to sort these objects in data structures that allow sorting. The <=> method returns -1, 0, or 1, depending on whether the object is less than, equal to, or greater than the other object.

Ruby
Copy to clipboard
1class Person
2  attr_accessor :name, :age
3
4  def initialize(name, age)
5    @name = name
6    @age = age
7  end
8
9  def <=>(other)
10    [@age, @name] <=> [other.age, other.name]
11  end
12
13  def ==(other)
14    [@age, @name] == [other.age, other.name]
15  end
16end
17
18people = [Person.new("John", 30), Person.new("Alice", 25)]
19sorted_people = people.sort
20
21sorted_people.each do |person|
22  puts "#{person.name}, Age: #{person.age}"
23end
24# Output:
25# Alice, Age: 25
26# John, Age: 30

In this lesson, we explored how to create and manipulate sorted collections using custom classes in Ruby. We examined how to use comparator methods to dictate the order of objects. Now, it's time for hands-on practice — try creating your own custom objects and sorting them to reinforce these concepts.