# Question about linked list with multiple pointers

**URL:** <https://www.ruby-forum.com/t/question-about-linked-list-with-multiple-pointers/229178>\
**Category:** Ruby\
**Created:** [July 24, 2009, 7:58am UTC](https://www.ruby-forum.com/t/question-about-linked-list-with-multiple-pointers/229178 "2009-07-24T07:58:47Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![risknet](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/r/dbc845/32.png) [@risknet](https://www.ruby-forum.com/u/risknet)\
**Post date:** [July 24, 2009, 7:58am UTC](https://www.ruby-forum.com/t/question-about-linked-list-with-multiple-pointers/229178/1 "2009-07-24T07:58:47Z")

</div>

Hi, I just learned ruby in class and I’ve been making a program about a  
threaded list, which I add some objects to a linked list and each node  
will be connected through multiple pointers of each threads. I’ve been  
working on this all night and it seems like it is not working, and I  
have no idea why this wouldn’t work… I am really new to this, so I was  
wondering if anyone could help me out, and if my program actually does  
make sense that I am on right track… This may look long, but this is a  
very simple program, and help would be really appreciated!!

class LibraryItem  
def findIndex  
end  
end

class Movie \< LibraryItem  
attr\_reader :title, :director, :year, :star

def initialize(title, director, year, \*star)  
@title = title  
@director = director  
@year = year  
@star = star  
end

#find out which indexes are going to be applied for a data object for  
node.  
def findIndex  
if star.size != 0  
return [“title”, “director”, “year”, “star”, “creator”]  
else  
return [“title”, “director”, “year”, “creator”]  
end  
end

def to\_s  
if star.size != 0  
“Movie: title=’#{title}’ director=#{director} year=#{year}  
star=#{star}”  
else  
“Movie: title=’#{title}’ director=#{director} year=#{year}”  
end  
end  
end

class Album \< LibraryItem  
attr\_reader :title, :artist, :year

def initialize(title, artist, year)  
@title = title  
@artist= artist  
@year = year  
end

#find out which indexes are going to be applied for a data object for  
node.  
def findIndex  
return [“title”, “artist”, “year”, “creator”]  
end

def to\_s  
“Album: title=’#{title}’ artist=#{artist} year=#{year}”  
end  
end

class Book \< LibraryItem  
attr\_reader :title, :author, :year, :page

def initialize(title, author, year, page)  
@title = title  
@author = author  
@year = year  
@page = page  
end

#find out which indexes are going to be applied for a data object for  
node.  
def findIndex  
return [“title”, “author”, “year”, “page”]  
end  
def to\_s  
“Book: title=’#{title}’ author=#{author} year=#{year} page=#{page}”  
end  
end

class ThreadedList  
class Node  
attr\_reader :data, :next, :nextPtrs  
attr\_writer :nextPtrs, :next  
def initialize(data, nextNode)  
@data = data  
@nextPtrs = {}  
@next = nextNode  
end  
end

def initialize()  
@head = nil  
@threadHeads = {“director”, “title”, “author”, “year”, “page”,  
“artist”, “star”, “creator”}  
end  
end

def add(item)  
#add to main list  
itemNode = Node.new(item, @head)  
@head = itemNode

```
# find out the indexes of the item, and if it does not have a method

```

to find indexes, print an error message.  
if item.findIndex.respond\_to? “index”  
index = item.findIndex  
else  
puts “Unable to add an item”  
0.upto(info.size - 1) do |i|  
item.nextPtrs[index[i]] = nil  
end

```
#add to threads
itemNode.nextPtrs.keys.each do |i|
  current = @threadHeads[i]
  # if there is nothing in the thread heads, set item to the thread

```

heads.  
if current.nil?  
@threadHeads[i] = itemNode  
# else, if the value of the item is bigger than the item to be  
inserted, set the pointers before heads.  
else  
if current.data.send(i) \> item.send(i)  
itemNode.nextPtrs[i] = @threadHeads[i]  
@threadHeads[i] = itemNode  
# otherwise, loop through the list to see where it should be  
inserted at.  
else  
while !(current.nextPtrs[i]).nil? ||  
current.nextPtrs[i].data.send(i) \> item.send(i)  
current = current.nextPtrs[i]  
end  
# if current is nil at this point, add it at the end.  
if current.nextPtrs[i].nil?  
current.nextPtrs[i] = itemNode  
# else, add it at the right position.  
else  
itemNode.nextPtrs[i] = current.nextPtrs[i]  
current.nextPtrs[i] = itemNode  
end  
end  
end  
end  
end

# print out the original list as it was inserted in order of file

reading.  
def print  
current = @head  
while !current.nil?  
puts current.data.to\_s  
current = current.next  
end  
end

# loop through the hash table of the thread heads and print each out.

def printList  
@threadHeads.keys.each do |i|  
current = @threadHeads[i]  
while current != nil?  
current = current.nextPtrs[i]  
end  
end  
end  
end

token = []

# make the threaded list and do file reading.

list = ThreadedList.new  
file = File.open(“a4q1.txt”)  
file.each do |line|  
token = line.split(/,/)

# if the data input is an album, tokenize it and add it to the list.

if token[0] == “Album”  
album = Album.new(token[1], token[2], token[3])  
list.add(album)

# if the data input is a moive, tokenize it and add it to the list.

elsif token[0] == “Movie”  
if token.size == 4  
movie = Movie.new(token[1], token[2], token[3])  
else  
movie = Movie.new(token[1], token[2], token[3], token[4])  
list.add(movie)  
end

# in other cases, the data will be a book.

else  
book = Book.new(token[1], token[2], token[3], token[4])  
list.add(book)  
end  
end  
file.close  
puts “\*\* Original Data:”  
list.print()

puts “\*\* List:”  
list.printList()

puts “\*\* Making modifications:”  
list.add(“Ruby”)

puts “\*\* Final Result:”  
list.printList()