// READ: http://msdn.microsoft.com/en-us/library/6x16t2tx.aspx
// list [i] = value; i is new list q is old list
public string this[int i]
{
get { return this.ElementAt(i); }
set {
var placeHolderList = new SinglyLinkedList();
for (var q = 0; q < this.Count(); q++)
{
if (q==i)
{
placeHolderList.AddLast(value);
}
else
{
placeHolderList.AddLast(this.ElementAt(q));
}
}
first_node = new SinglyLinkedListNode(placeHolderList.First());
for (var w = 1; w < placeHolderList.Count(); w++)
{
this.AddLast(placeHolderList.ElementAt(w));
}
}
}
public void AddLast(string value)
{
SinglyLinkedListNode newNode = new SinglyLinkedListNode(value);
if (firstNode == null) firstNode = newNode;
else LastNode().Next = newNode;
count++;
}
public void AddAfter(string existingValue, string value)
{
var node = this.first_node;
var inputValue = IndexOf(existingValue);
var value2Add = new SinglyLinkedListNode(value);
if (IndexOf(existingValue) == -1)
{
throw new ArgumentException();
}
for (var i = 0; i < this.Count(); i++)
{
if (node.Value == existingValue)
{
// gets the index of the found node
var foundPosition = node;
// set the pointer for the new node
value2Add.Next = foundPosition.Next;
// set the new value for after foundPosition
foundPosition.Next = value2Add;
}
else if (!node.IsLast())
{
this.AddLast(value2Add.Value);
}
node = new SinglyLinkedListNode(value);
}
}
// READ: http://msdn.microsoft.com/en-us/library/6x16t2tx.aspx
public string this[int i]
{
get { return this.ElementAt(i); }
set
{
var copy_of_list = new SinglyLinkedList();
for (var j = 0; j < this.Count(); j++)
{
if (j == i)
{
copy_of_list.AddLast(value);
}
else
{
copy_of_list.AddLast(this.ElementAt(j));
}
}
first_node = new SinglyLinkedListNode(copy_of_list.First());
for (var o = 1; o < copy_of_list.Count(); o++)
{
this.AddLast(copy_of_list.ElementAt(o));
}
}
}
// READ: http://msdn.microsoft.com/en-us/library/6x16t2tx.aspx
public string this[int i]
{
//uses the ElementAt function to get value (saves you from duplicating your code)
get { return this.ElementAt(i); }
set
{
//using a placeholder list helps save the values in order without having to do voodoo with the pointers
var placeholderList = new SinglyLinkedList();
for (var q = 0; q < this.Count(); q++)
{
//if this is the place where you need to exchange the value, insert it here
if (q == i)
{
placeholderList.AddLast(value);
}
//otherwise, insert the value that was preexisting in the list
else
{
placeholderList.AddLast(this.ElementAt(q));
}
}
//now swap out the values in the placeholder list into the real list.
//first swap the first value to clear out the old list
first_node = new SinglyLinkedListNode(placeholderList.First());
//then loop through the placeholder list and add the values to the real list in order
for (var w = 1; w < placeholderList.Count(); w++)
{
this.AddLast(placeholderList.ElementAt(w));
}
}
}
public void NodeLastWhenLast()
{
SinglyLinkedListNode node1 = new SinglyLinkedListNode("foo");
SinglyLinkedListNode node2 = new SinglyLinkedListNode("bar");
node1.Next = node2;
Assert.IsFalse(node1.IsLast());
}
public void AddAfter(string existingValue, string value)
{
if (ElementAt(-1) == existingValue)
{
AddLast(value);
}
else
{
SinglyLinkedListNode prevNode = firstNode;
bool found = false;
while (!prevNode.IsLast())
{
if (prevNode.Value == existingValue)
{
SinglyLinkedListNode newNode = new SinglyLinkedListNode(value);
SinglyLinkedListNode oldNext = prevNode.Next;
newNode.Next = oldNext;
prevNode.Next = newNode;
found = true;
count++;
break;
}
prevNode = prevNode.Next;
}
if (!found)
{
throw new ArgumentException();
}
}
}
// READ: http://msdn.microsoft.com/en-us/library/6x16t2tx.aspx
public string this[int i]
{
get { return this.ElementAt(i); }
set
{
var newList = new SinglyLinkedList();
for (var x = 0; x < this.Count(); x++)
{
if (x == i)
{
newList.AddLast(value);
}
else
{
newList.AddLast(this.ElementAt(x));
}
}
first_node = new SinglyLinkedListNode(newList.First());
for (var w = 1; w < newList.Count(); w++)
{
this.AddLast(newList.ElementAt(w));
}
}
}
// READ: http://msdn.microsoft.com/en-us/library/6x16t2tx.aspx
public string this[int index]
{
get
{
return this.ElementAt(index);
}
set
{
var placeholder = new SinglyLinkedList();
for(var j = 0; j < this.Count(); j++)
{
if (j == index)
{
placeholder.AddLast(value);
} else
{
placeholder.AddLast(this.ElementAt(j));
}
}
first_node = new SinglyLinkedListNode(placeholder.First());
for(var k = 1; k < placeholder.Count(); k++ )
{
this.AddLast(placeholder.ElementAt(k));
}
}
}
public void NodeEqualityWithEqualValues()
{
SinglyLinkedListNode node1 = new SinglyLinkedListNode("foo");
SinglyLinkedListNode node2 = new SinglyLinkedListNode("foo");
Assert.AreEqual(node1, node2); // Equivalent to: Assert.IsTrue(node1.Equals(node2));
// When you create your own types, you should override Equals. -- quote from the docs
}
public void AddAfter(string existingValue, string value)
{
/* if (last.Value == existingValue)
{
AddLast(value);
} */
SinglyLinkedListNode adding = new SinglyLinkedListNode(value);
SinglyLinkedListNode test = first;
while (true) {
if (test == null)
{
throw new ArgumentException();
}
if (test != null)
{
if (test.Value == existingValue)
{
adding.Next = test.Next;
test.Next = adding;
count++;
break;
}
test = test.Next;
}
}
}
public void AddFirst(string value)
{
SinglyLinkedListNode newNode = new SinglyLinkedListNode(value);
newNode.Next = firstNode;
firstNode = newNode;
count++;
}
public void AddAfter(string existingValue, string value)
{
if (ElementAt(-1) == existingValue)
{
AddLast(value);
}
else
{
SinglyLinkedListNode current = firstNode;
bool found = false;
while (!current.IsLast())
{
if (current.Value == existingValue)
{
SinglyLinkedListNode new_node = new SinglyLinkedListNode(value);
SinglyLinkedListNode old_next = current.Next;
new_node.Next = old_next;
current.Next = new_node;
found = true;
break;
}
current = current.Next;
}
if (!found)
{
throw new ArgumentException();
}
}
}
public void NodeEqualityIgnoresNext()
{
SinglyLinkedListNode node1 = new SinglyLinkedListNode("foo");
node1.Next = new SinglyLinkedListNode("bob");
SinglyLinkedListNode node2 = new SinglyLinkedListNode("foo");
node2.Next = new SinglyLinkedListNode("sally");
Assert.AreEqual(node1, node2);
}
public SinglyLinkedListNode(string value)
{
this.value = value;
this.next = null;
// Used by the visualizer:
allNodes.Add(this);
}
public SinglyLinkedListNode(string value)
{
// throw new NotImplementedException();
this.value = value;
this.next = null;
// Used by the visualizer:
allNodes.Add(this);
}
private string value; // same as this.value
#endregion Fields
#region Constructors
public SinglyLinkedListNode(string input)
{
this.value = input;
// data members default to null, but...
this.next = null;
// Used by the visualizer:
allNodes.Add(this);
}
private string value; //same as this.value
#endregion Fields
#region Constructors
public SinglyLinkedListNode(string input)
{
this.value = input; //distinguishing between the two named items in this context
//don't have to use setter because in same class
//Initialized data members default to null, but...
this.next = null;
// Used by the visualizer:
allNodes.Add(this);
}
// READ: http://msdn.microsoft.com/en-us/library/aa691335(v=vs.71).aspx
public SinglyLinkedList(params object[] values)
{
first = new SinglyLinkedListNode(values[0].ToString());
int i = 1;
while (i < values.Length)
{
AddLast(values[i].ToString());
i += 1;
}
}
// READ: http://msdn.microsoft.com/en-us/library/aa691335(v=vs.71).aspx
public SinglyLinkedList(params object[] values)
{
first = new SinglyLinkedListNode(null);
if(values.Length != 0)
{
for (int i = 0; i < values.Length; i++)
{
AddLast(values[i] as string);
}
}
}
public void AddLast(string value)
{
if(first == null)
{
first = new SinglyLinkedListNode(value);
}
else
{
last = new SinglyLinkedListNode(value);
}
}
// READ: http://msdn.microsoft.com/en-us/library/aa691335(v=vs.71).aspx
public SinglyLinkedList(params object[] values)
{
if (values.Length == 0)
{
first = new SinglyLinkedListNode(null);
}
else
{
first = new SinglyLinkedListNode(values[0] as string);
}
}
private string value; // same as using this.value
#endregion Fields
#region Constructors
public SinglyLinkedListNode(string value)
{
//throw new NotImplementedException();
this.value = value;
// Undeclared data members default to null, but...
this.next = null;
// Used by the visualizer:
allNodes.Add(this);
}
public void AddLast(string value)
{
if (firstNode == null)
{
firstNode = new SinglyLinkedListNode(value);
}
else
{
//Actually Attach new nodes to the end of the list
}
}
//Adds A Node to the beginning of to SLL
public void AddFirst(string value)
{
SinglyLinkedListNode node = first;
if (node.Value == null)
{
first = new SinglyLinkedListNode(value);
}
else
{
}
}
public void AddFirst(string value)
{
SinglyLinkedListNode newNode = new SinglyLinkedListNode(value);
if (this.First() == null)
{
AddLast(value);
}
else
{
newNode.Next = firstNode;
firstNode = newNode;
count++;
}
}
public void AddLast(string value)
{
if (this.First() == null)
{
first_node = new SinglyLinkedListNode(value);
} else {
var node = this.first_node;
while(!node.IsLast()) // What's another way to do this????
{
node = node.Next;
}
node.Next = new SinglyLinkedListNode(value);
}
}
public void AddFirst(string value)
{
if(Count() == 0)
{
first = new SinglyLinkedListNode(value);
}
else
{
SinglyLinkedListNode node = new SinglyLinkedListNode(value);
SinglyLinkedListNode storage = first;
first = node;
node.Next = storage;
}
}
public void AddFirst(string value)
{
if (firstNode == null)
{
firstNode = new SinglyLinkedListNode(value);
size += 1;
}
else
{
SinglyLinkedListNode newNextNode = firstNode;
firstNode = new SinglyLinkedListNode(value);
size += 1;
firstNode.Next = newNextNode;
}
}
public void AddAfter(string existingValue, string value)
{
SinglyLinkedListNode CurrentNode = firstNode;
SinglyLinkedListNode NodeToInsert = new SinglyLinkedListNode(value);
if (ExistingValueExists(existingValue))
{
while (CurrentNode != null)
{
if (CurrentNode.Value == existingValue)
{
NodeToInsert.Next = CurrentNode.Next;
CurrentNode.Next = NodeToInsert;
CurrentNode = NodeToInsert;
}
else
{
CurrentNode = CurrentNode.Next;
}
}
}
else
{
throw new ArgumentException();
}
}
