What Is Data Structure in Ruby?

A data structure is a way of organizing and storing data in a computer program. It helps in efficient data management and retrieval. Ruby, a dynamic, object-oriented programming language, provides several built-in data structures that developers can use to solve complex problems.

Let’s explore some commonly used data structures in Ruby:

Arrays

An array is an ordered collection of elements. In Ruby, arrays can store objects of different types.

You can access elements using their index position, which starts from 0. Arrays are mutable, meaning you can add or remove elements from them.

Example:

# Creating an array
fruits = ["apple", "banana", "orange"]

# Accessing elements
puts fruits[0] # Output: apple

# Adding elements
fruits.push("grape") # ["apple", "banana", "orange", "grape"]

# Removing elements
fruits.pop # ["apple", "banana", "orange"]

Hashes

A hash is a key-value pair data structure. Also known as associative arrays or dictionaries, hashes provide fast access to values based on their keys. In Ruby, hash keys can be any object type while values can be of any type as well.

Example:

# Creating a hash
person = {
  name: "John",
  age: 30,
  city: "New York"
}

# Accessing values
puts person[:name] # Output: John

# Adding new key-value pairs
person[:occupation] = "Developer" # { name: "John", age: 30, city: "New York", occupation: "Developer" }

# Removing key-value pairs
person.delete(:age) # { name: "John", city: "New York", occupation: "Developer" }

Linked Lists

A linked list is a linear data structure that consists of nodes where each node contains a value and a reference to the next node. Unlike arrays, linked lists do not require contiguous memory allocation. They are efficient for insertions and deletions but have slower access times compared to arrays.

Example:

# Creating a linked list
class Node
  attr_accessor :value, :next_node
  
  def initialize(value)
    @value = value
    @next_node = nil
  end
end

class LinkedList
  attr_accessor :head
  
  def initialize
    @head = nil
  end
  
  def add(value)
    new_node = Node.new(value)
    
    if @head.nil?
      @head = new_node
    else
      current_node = @head
      
      while current_node.next_node != nil
        current_node = current_node.next_node
      end
      
      current_node.next_node = new_node
    end
    
    self
  end
  
  # Other methods like remove, search, etc.
end

# Usage:
list = LinkedList.new.add(10).add(20).add(30)

These are just a few examples of data structures commonly used in Ruby. Understanding them and their characteristics can greatly enhance your ability to write efficient and scalable code.

Remember to choose the appropriate data structure based on the requirements of your program. Each data structure has its own advantages and disadvantages, so it’s essential to analyze the problem and select the most suitable one.