Question

我在线检查了几个Ruby教程，他们似乎都在使用数组。那么我怎么能在Ruby中实现以下数据结构呢？

栈
队列
链接列表
地图
集

Answer 1

（从评论中移动）

好吧，通过将自己限制为堆栈或队列方法（push，pop，shift，unshift），数组可以是堆栈或队列。使用push / pop提供LIFO（后进先出）行为（堆栈），而使用push / shift或unshift / pop给出FIFO行为（队列）。

地图为hashes，且Set类已存在。

您可以使用类实现链接列表，但是数组将使用标准数组方法提供类似链接列表的行为。

Answer 2

我猜大部分内容都包含在上面的答案中，但仅仅是为了更好的解释而总结：

堆栈：

stack = []
stack << 2 # push 2 => stack = [2]
stack << 3 # push 3 => stack = [2, 3]
stack.pop  # pop => 3, stack = [2]

队列：

# we have a Queue class
queue = Queue.new
queue << 2 # push 2 => queue = [2]
queue << 3 # push 3 => queue = [2, 3] (just a representation, it will be an object though)
queue.pop # pop 2

链接列表：

# A very simple representation
class Node
  attr_accessor :value, :next_node

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

class LinkedList

  def initialize(value)
    @head = Node.new(value)
  end

  def add(value)
    current = @head
    while !current.next_node.nil?
      current = current.next_node
    end
    current.next_node = Node.new(value)
  end
end

ll = LinkedList.new
ll.add(10)
ll.add(20)

图：

# Hash incase of ruby
a = {} (or a = Hash.new)
a['one'] = 1 # a = {"one"=>1}
a['two'] = 2 # a = {"one"=>1, "two"=>2}

集：

# we have a Set class
require 'set'
s = Set.new         # <Set: {}>
s.add(1)            # <Set: {1}>
s.add(2)            # <Set: {1, 2}>
s.add(1)            # <Set: {1, 2}>
s.instance_of?(Set) # true

Answer 3

是的，虽然没有明确的名义。 Array类可用作堆栈，队列或链表。例如，push和pop使其行为类似于堆栈。 Ruby的Map是Hash类。 Ruby也有一个Set类，但您必须导入一个模块才能使用它（require 'set'）。

Answer 4

Ruby语言实际上有一个Queue类，可以用作....等待它...一个队列;）

线程安全且易于使用。

@James的其余部分回答非常准确。

Answer 5

堆/优先队列使用排序集可以实现最小堆/优先级队列功能。

创建（向堆/PQ添加数据）

pq = SortedSet.new([3]) #=> #<SortedSet: {3}>
pq.add(1) #=> #<SortedSet: {1, 3}>
pq.add(6) #=> #<SortedSet: {1, 3, 6}>

删除（最高优先级元素）

top = pq.first #1
pq.delete(top) #=> #<SortedSet: {3, 6}>, top is '1'
top = pq.first #3
pq.delete(top) #=> #<SortedSet: {6}>

Answer 6

我想在Ruby中添加Deque实现（在线性DS使用中更通用）：

class Node
  attr_accessor :value, :next, :prev
  def initialize(value, next_node, prev_node)
    @value = value
    @next = next_node
    @prev = prev_node
  end
end


class Deque
  attr_accessor :start, :end
  def initialize
    @start = @end = nil
  end

  def push_back(val)
    if @start.nil?
      @start = @end = Node.new(val, nil, nil)
    else
      @end.next = Node.new(val, nil, @end)
      @end.next.prev = @end
      @end = @end.next
    end
  end

  def pop_back
    if @start == @end #only one node
      @start = @end = nil
    else
      @end = @end.prev
      @end.next = nil
    end
  end

  def push_front(val)
    @start.prev = Node.new(val, @start, nil)
    @start = @start.prev
  end

  def pop_front
    if @start == @end #only one node
      @start = @end = nil
    else
      @start = @start.next
      @start.prev.next = nil
      @start.prev = nil
    end
  end

  def empty?
    @start.nil? && @end.nil?
  end

  def front
    @start.value unless self.empty?
  end

  def back
    @end.value unless self.empty?
  end

  def print(node)
    arr = []
    while node
      arr << node.value
      node = node.next
    end
    p arr
  end
end


q = Deque.new
q.push_back(1)
q.push_back(2)
q.push_back(3)
q.push_back(4)
q.print(q.start)
q.push_front(0)
q.push_front(-1)
q.print(q.start)
q.pop_back()
q.pop_back()
q.print(q.start)
q.pop_front()
q.pop_front()
q.print(q.start)
p q.front
p q.back

输出：

[1, 2, 3, 4]
[-1, 0, 1, 2, 3, 4]
[-1, 0, 1, 2]
[1, 2]
1
2

Ruby有堆栈，队列，链表，地图或集合等容器吗？

6 个答案: