Fundamental Data Structures in Ruby

Introduction

Ruby is a powerful and versatile programming language that offers a wide range of data structures to help developers efficiently manage and manipulate data. In this article, we will explore some of the fundamental data structures in Ruby and how they can be used in your programs.

Arrays

Arrays are one of the most commonly used data structures in Ruby. They are ordered collections of objects, indexed by integers starting from 0. Arrays can contain any type of object, including other arrays.

# Creating an array
array = [1, 2, 3, 4, 5]

# Accessing elements in an array
puts array[0] # Output: 1

# Adding elements to an array
array << 6
puts array.inspect # Output: [1, 2, 3, 4, 5, 6]

# Removing elements from an array
array.pop
puts array.inspect # Output: [1, 2, 3, 4, 5]

Hashes

Hashes are another essential data structure in Ruby. They are collections of key-value pairs, where each key is unique. Hashes are commonly used to store and retrieve data based on a specific key.

# Creating a hash
hash = {name: 'Alice', age: 30, city: 'New York'}

# Accessing values in a hash
puts hash[:name] # Output: Alice

# Adding a new key-value pair to a hash
hash[:email] = 'alice@example.com'
puts hash.inspect # Output: {:name=>"Alice", :age=>30, :city=>"New York", :email=>"alice@example.com"}

# Removing a key-value pair from a hash
hash.delete(:age)
puts hash.inspect # Output: {:name=>"Alice", :city=>"New York", :email=>"alice@example.com"}

Sets

Sets are collections of unique elements in Ruby. They are useful for storing a collection of items without duplicates. Sets provide efficient methods for performing set operations such as union, intersection, and difference.

require 'set'

# Creating a set
set = Set.new([1, 2, 3, 4, 5])

# Adding elements to a set
set.add(6)
puts set.inspect # Output: #

# Removing elements from a set
set.delete(3)
puts set.inspect # Output: #

Linked Lists

Linked lists are a linear data structure in which elements are stored in nodes. Each node contains a value and a reference to the next node in the sequence. Linked lists can be singly linked, where each node points to the next node, or doubly linked, where each node points to both the next and previous nodes.

# Node class for a singly linked list
class Node
  attr_accessor :value, :next

  def initialize(value)
    @value = value
    @next = nil
  end
end

# Creating a linked list
node1 = Node.new(1)
node2 = Node.new(2)
node3 = Node.new(3)

node1.next = node2
node2.next = node3

current_node = node1
while current_node
  puts current_node.value
  current_node = current_node.next
end

Conclusion

In this article, we have explored some of the fundamental data structures in Ruby, including arrays, hashes, sets, and linked lists. By understanding how these data structures work and how to use them effectively in your programs, you can write more efficient and organized code. Experiment with these data structures in your Ruby projects to see how they can improve the performance and readability of your code.