Class: SknUtils::Lists::CircularLinkedList

Inherits:
LinkedCommons show all
Defined in:
lib/skn_utils/lists/circular_linked_list.rb

Overview

LinkedCommons provides;

  • #initialize, #first, #next, #current, #last, #at_index, #insert, #prepend, #append, #empty?, #clear, #each, #to_a, and #sort!

Instance Attribute Summary

Attributes inherited from LinkedCommons

#size

Instance Method Summary collapse

Methods inherited from LinkedCommons

#at_index, call, #clear, #current, #each, #empty?, #first, #initialize, #last, #next, #nodes, #prepend, #sort!, #to_a

Constructor Details

This class inherits a constructor from SknUtils::Lists::LinkedCommons

Instance Method Details

#insert(value) ⇒ Object Also known as: append

Modifications

return new size



74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/skn_utils/lists/circular_linked_list.rb', line 74

def insert(value)
  node = @current
  @current = LinkNode.call(value, node, :circle_after, self,  &@match_value)
  if self.size == 0           # only
    self.head      =  @current
    self.tail      =  @current
  elsif self.tail == node
    self.tail      =  @current
    @current.next      = self.head
    self.head.prev = @current
  end
  self.size += 1
end

#insert_after(position_value, value) ⇒ Object

return new size



106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/skn_utils/lists/circular_linked_list.rb', line 106

def insert_after(position_value, value)
  target = find_by_value(position_value)
  node = LinkNode.call(value, target, :circle_after, self,  &@match_value)
  @current = node
  if self.size == 0           # only
    self.head =  node
    self.tail =  node
  elsif self.tail == target
    self.tail =  node
    node.next      = self.head
    self.head.prev = node
  end
  self.size += 1
end

#insert_before(position_value, value) ⇒ Object

return new size



90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/skn_utils/lists/circular_linked_list.rb', line 90

def insert_before(position_value, value)
  target = find_by_value(position_value)
  node = LinkNode.call(value, target, :circle_before, self,  &@match_value)
  @current = node
  if self.size == 0           # only
    self.head =  node
    self.tail =  node
  elsif self.head == target   # new head
    self.head      =  node
    node.prev      = self.tail
    self.tail.next = node
  end
  self.size += 1
end

#nth(index) ⇒ Object

-+ int position from current node



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/skn_utils/lists/circular_linked_list.rb', line 49

def nth(index)
  node = @current
  position = node
  if index > 0
    while index > 1 and node and node.next
      node = node.next
      index -= 1
      @current = node
      break if position.equal?(node)
    end
  elsif index < 0
    while index < 0 and node and node.prev
      node = node.prev
      index += 1
      @current = node
      break if position.equal?(node)
    end
  end
  current
end

#prev ⇒ Object 



43
44
45
46
 
# File 'lib/skn_utils/lists/circular_linked_list.rb', line 43

def prev
  @current = @current.prev if @current and @current.prev
  @current.value rescue nil
end

#remove(value) ⇒ Object

return remaining size



122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/skn_utils/lists/circular_linked_list.rb', line 122

def remove(value)
  target_node = find_by_value(value)
  if target_node
    if self.size == 1                           # will become zero
      @current = nil
      self.head = nil
      self.tail = nil
    elsif target_node.equal?(self.head)            # top
      @current = target_node.next
      @current.prev = target_node.prev
      self.tail.next = @current
      self.head = @current
    elsif target_node.equal?(self.tail)            # bottom
      @current = target_node.prev
      @current.next = target_node.next
      self.head.prev = @current
      self.tail = @current
    else                                   # middle
      @current           = target_node.prev
      @current.next      = target_node.next
      @current.next.prev = @current
    end
    target_node.remove!
    self.size -= 1
  end
end