在Ruby中修改调用对象

Question

I am in the process of learning Ruby and as practice I am making a linked list class. I am in the process of writing the delete method for a doubly linked list. My question is, if I represent the list by its head node, how do I delete the head? It seems like Ruby wont allow you to assign to the self variable, so I can't change the reference of the caller to be the next node. One solution is that I can copy the key from the next node and swap references, but in general, is there a way in Ruby to change the reference of the caller?

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

You can't change the which object is being pointed to by the caller (ie modify self ), but you can manipulate the object in any way you want, as you've already thought through. The short answer is that it can't be done. You can come up with other ways to model it, but I think you're already on the right track.

Answer 2

You need to conceptualize a linked list differently. A LinkedListNode is a component of a LinkedList, not a LinkedList itself. Operations such as append, delete, and print should go in your LinkedList class, not your LinkedListNode class. Try starting with something like

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