Question

我正在学习Ruby，作为练习，我正在制作链表类。我正在为双向链表编写删除方法。我的问题是，如果我通过其头节点表示列表，我该如何删除头部？看起来Ruby不允许你分配给自变量，所以我不能将调用者的引用更改为下一个节点。一个解决方案是我可以从下一个节点复制密钥并交换引用，但一般来说，Ruby中有没有办法改变调用者的引用？

class LinkedListNode

    attr_accessor :next, :previous, :key

    def initialize(key=nil, next_node=nil, previous=nil)
        @next = next_node
        @previous = previous
        @key = key
    end

    def append(key=nil)
        newnode = LinkedListNode.new(key)
        seeker = self
        while seeker.next != nil
           seeker = seeker.next
        end
        newnode.previous = seeker
        seeker.next = newnode
     end

     def delete(key=nil)
         seeker = self
         while seeker.key != key
             return if seeker.next == nil
             seeker = seeker.next
         end
         if seeker.previous != nil
            if seeker.next != nil
                seeker.previous.next = seeker.next
                seeker.next.previous = seeker.previous
            else
                seeker.previous.next = nil
            end
         else
             return self = self.next
         end
         return seeker = nil
     end

     def print
         seeker = self
         string = ""
         while 1
            if seeker.next == nil
                string += seeker.key.to_s
                break
            else
                string += seeker.key.to_s + " -> "
            end
            seeker = seeker.next
        end
        puts string
    end
end

if __FILE__ == $0
    ll = LinkedListNode.new(1)
    ll.append(2)
    ll.append(3)
    ll.append(4)
    ll.append(5)

    ll.print

    ll.delete(5)
    ll.print

    ll.delete(1)
    ll.print
end

Answer 1

您无法更改调用者指向的对象（即修改self），但您可以按照您已经想过的任何方式操作对象。简短的回答是它无法完成。您可以想出其他方法对其进行建模，但我认为您已经走上正轨。

Answer 2

您需要以不同方式概念化链接列表。 LinkedListNode是LinkedList的组件，而不是LinkedList本身。附加，删除和打印等操作应该放在LinkedList类中，而不是LinkedListNode类中。尝试从

开始

class LinkedList

  # This one-liner defines a LinkedList::Node with associated constructor
  # and accessors for the three tags provided.  Any tags omitted during
  # construction will be initialized to nil.
  Node = Struct.new(:key, :previous, :next)

  attr_reader :head, :tail

  def initialize
    # start with no Nodes in the list
    @head = @tail = nil
  end

  def append(key)
    # Make the LinkedList tail a new node that stores the key,
    # points to the prior tail as its previous reference, and
    # has no next.
    @tail = Node.new(key, @tail)
    if @tail.previous  # the prior tail was not nil
      @tail.previous.next = @tail   # make the prior tail point to the new one
    else               # if there wasn't any tail before the list was empty
      @head = @tail    # so the new tail Node is also the head
    end
  end

  # ...

end

修改Ruby中的调用对象

2 个答案: