// 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 AddAfter(string existingValue, string newValue)
{
int testForValue = -1;
//throw new NotImplementedException();
for (var i = 0; i < this.Count(); i++)
{
if (this.ElementAt(i) == existingValue)
{
testForValue = i;
break;
}
}
if (testForValue < 0)
{
throw new ArgumentException();
}
var placeHolderList = new SinglyLinkedList();
for (var q = 0; q < this.Count(); q++)
{
placeHolderList.AddLast(this.ElementAt(q));
if (q == testForValue)
{
placeHolderList.AddLast(newValue);
}
}
first_node = new SinglyLinkedListNode(placeHolderList.First());
for (var w = 1; w < placeHolderList.Count(); w++)
{
this.AddLast(placeHolderList.ElementAt(w));
}
}
public void AddAfterItemThatDoesntExist()
{
SinglyLinkedList list = new SinglyLinkedList();
list.AddLast("foo");
list.AddLast("bar");
list.AddAfter("cat", "grille");
}
public void AddFirstOnEmptyList()
{
SinglyLinkedList list = new SinglyLinkedList();
list.AddFirst("foo");
string[] expected = new string[] { "foo" };
CollectionAssert.AreEqual(expected, list.ToArray());
}
// 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 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 ConstructorWithOneArgument()
{
SinglyLinkedList list = new SinglyLinkedList("foo");
var expected = new string[] { "foo" };
//throw new ArgumentException(list.ToArray().ToString());
CollectionAssert.AreEqual(expected, list.ToArray());
}
public void SortingWithInt()
{
SinglyLinkedList<int> list = new SinglyLinkedList<int>(new int[] { 4, 1, 3, 2 });
list.Sort();
int[] expected = { 1, 2, 3, 4 };
CollectionAssert.AreEqual(expected, list.ToArray());
}
// 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 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 BuildSort()
{
if (!IsSorted())
{
SinglyLinkedList sortedList = new SinglyLinkedList(firstNode.Value);
}
}
public void AddAfterLastItem()
{
SinglyLinkedList list = new SinglyLinkedList();
list.AddLast("foo");
list.AddLast("bar");
list.AddAfter("bar", "grille");
var expected = new string[] { "foo", "bar", "grille" };
CollectionAssert.AreEqual(expected, list.ToArray());
}
public void AddFirstOnLongerList()
{
SinglyLinkedList list = new SinglyLinkedList();
list.AddLast("foo");
list.AddLast("bar");
list.AddFirst("grille");
var expected = new string[] { "grille", "foo", "bar" };
CollectionAssert.AreEqual(expected, list.ToArray());
}
public void CaitlinsArrayCount()
{
SinglyLinkedList list = new SinglyLinkedList();
list.AddLast("foo");
list.AddLast("bar");
list.AddLast("grille");
string[] lexpected = new string[] { "foo", "bar", "grille" };
int expected = lexpected.Length;
string[] lactual = list.ToArray();
int actual = lactual.Length;
Assert.AreEqual(expected, actual);
}
public void AddAfter()
{
SinglyLinkedList list = new SinglyLinkedList();
list.AddLast("foo");
list.AddLast("grille");
// NOTE: This assert isn't necessary. It is merely here to remind you of / verify the state of the list prior to inserting the new node.
var expected = new string[] { "foo", "grille" };
CollectionAssert.AreEqual(expected, list.ToArray());
list.AddAfter("foo", "bar");
expected = new string[] { "foo", "bar", "grille" };
CollectionAssert.AreEqual(expected, list.ToArray());
}
// READ: http://msdn.microsoft.com/en-us/library/6x16t2tx.aspx
public string this[int i]
{
get {return this.ElementAt(i); }
set
{
var placeholder = new SinglyLinkedList();
for (var k = 0; k < this.Count(); k++)
{
if (i == k)
{
placeholder.AddLast(value); //if this is the position this is the new value and don't save the existing value.
}else
{
placeholder.AddLast(this.ElementAt(k));
}
}
first_node = new SinglyLinkedListNode(placeholder.First());//assign first node to be the new list
for (var j = 1; j < placeholder.Count(); j++)
{
this.AddLast(placeholder.ElementAt(j));//add the remaining values in list
}
}
}
public void AddAfter(string existingValue, string value)
{
//Find the place of existingValue
int position = IndexOf(existingValue);
if (position == -1)//if not in list throw exception
{
throw new ArgumentException();
}
var placeholder = new SinglyLinkedList(); //assigns a new list to hold values
for (var i = 0; i < this.Count(); i++)
{
placeholder.AddLast(this.ElementAt(i));
if (i == position)
{
placeholder.AddLast(value); //find the correct position and add new value
}
}
first_node = new SinglyLinkedListNode(placeholder.First());//assign first node to be the new list
for (var j = 1; j < placeholder.Count(); j++)
{
this.AddLast(placeholder.ElementAt(j));//add the remaining values in list
}
}
public void ToStringOnSingleItemList()
{
SinglyLinkedList list = new SinglyLinkedList();
list.AddLast("foo");
Assert.AreEqual("{ \"foo\" }", list.ToString());
}
public void ListRemoveWithDuplicateNodes()
{
SinglyLinkedList list = new SinglyLinkedList("foo", "bar", "grille", "bar");
list.Remove("bar");
var expected = new string[] { "foo", "grille", "bar" };
CollectionAssert.AreEqual(expected, list.ToArray());
}
public void ToStringOnEmptyList()
{
SinglyLinkedList list = new SinglyLinkedList();
Assert.AreEqual("{ }", list.ToString());
}
public void ToStringOnMultipleItemList()
{
SinglyLinkedList list = new SinglyLinkedList();
list.AddLast("foo");
list.AddLast("bar");
list.AddLast("grille");
Assert.AreEqual("{ \"foo\", \"bar\", \"grille\" }", list.ToString());
}
public void ToArrayOnSingleItemList()
{
SinglyLinkedList list = new SinglyLinkedList();
list.AddLast("foo");
string[] expected = new string[] { "foo" };
CollectionAssert.AreEqual(expected, list.ToArray());
}
public void ToArrayOnEmptyList()
{
SinglyLinkedList list = new SinglyLinkedList();
string[] expected = new string[] { };
CollectionAssert.AreEqual(expected, list.ToArray());
}
public void SortUnsortedList()
{
SinglyLinkedList list = new SinglyLinkedList("foo", "bar");
list.Sort();
var expected = new string[] { "bar", "foo" };
CollectionAssert.AreEqual(expected, list.ToArray());
}
public void CountChangesOnRemoval()
{
SinglyLinkedList list = new SinglyLinkedList("foo", "bar", "grille");
list.Remove("foo");
Assert.AreEqual(2, list.Count());
list.Remove("bar");
Assert.AreEqual(1, list.Count());
list.Remove("grille");
Assert.AreEqual(0, list.Count());
}
public void SortEmptyList()
{
SinglyLinkedList list = new SinglyLinkedList();
list.Sort();
var expected = new string[] { };
CollectionAssert.AreEqual(expected, list.ToArray());
}
public void ConstructorWithMultipleArguments()
{
SinglyLinkedList list = new SinglyLinkedList("foo", "bar", "grille");
var expected = new string[] { "foo", "bar", "grille" };
CollectionAssert.AreEqual(expected, list.ToArray());
}
public void ListRemoveLastItemFromList()
{
SinglyLinkedList list = new SinglyLinkedList("foo", "bar", "grille");
list.Remove("grille");
var expected = new string[] { "foo", "bar" };
CollectionAssert.AreEqual(expected, list.ToArray());
}
public void CountEmptyList()
{
SinglyLinkedList list = new SinglyLinkedList();
Assert.AreEqual(0, list.Count());
}
public void ListRemoveNonExistentNode()
{
SinglyLinkedList list = new SinglyLinkedList("foo", "bar", "grille");
list.Remove("cat");
var expected = new string[] { "foo", "bar", "grille" };
CollectionAssert.AreEqual(expected, list.ToArray());
}