Name Description

LinkedList<T>() Initializes a new instance of the LinkedList<T> class that

is empty.

LinkedList<T>(IEnumerable<T>) Initializes a new instance of the LinkedList<T> class that

contains elements copied from the
specifiedIEnumerable and has sufficient capacity to
accommodate the number of elements copied.

LinkedList<T>(SerializationInfo, Initializes a new instance of the LinkedList<T> class that

StreamingContext) is serializable with the specified
SerializationInfo and StreamingContext.

Name Description

Count Gets the number of nodes actually contained in the LinkedList<T>.

First Gets the first node of the LinkedList<T>.

Last Gets the last node of the LinkedList<T>.

Name Description

AddAfter(LinkedListNode<T>, Adds the specified new node after the specified existing
LinkedListNode<T>) node in the LinkedList<T>.

AddAfter(LinkedListNode<T>, T) Adds a new node containing the specified value after the
specified existing node in theLinkedList<T>.

AddBefore(LinkedListNode<T>, Adds the specified new node before the specified existing
LinkedListNode<T>) node in the LinkedList<T>.

AddBefore(LinkedListNode<T>, T) Adds a new node containing the specified value before the
specified existing node in theLinkedList<T>.

AddFirst(T) Adds a new node containing the specified value at the start
of the LinkedList<T>.

AddFirst(LinkedListNode<T>) Adds the specified new node at the start of

the LinkedList<T>.

AddLast(T) Adds a new node containing the specified value at the end
of the LinkedList<T>.

AddLast(LinkedListNode<T>) Adds the specified new node at the end of

the LinkedList<T>.

Clear Removes all nodes from the LinkedList<T>.

Contains Determines whether a value is in the LinkedList<T>.

CopyTo Copies the entire LinkedList<T> to a compatible one-

dimensional Array, starting at the specified index of the
target array.

Equals(Object) Determines whether the specified Object is equal to the

current Object. (Inherited from Object.)

Finalize Allows an object to try to free resources and perform other

cleanup operations before it is reclaimed by garbage
collection. (Inherited from Object.)

Find Finds the first node that contains the specified value.
FindLast Finds the last node that contains the specified value.

GetEnumerator Returns an enumerator that iterates through

the LinkedList<T>.

GetHashCode Serves as a hash function for a particular type. (Inherited

from Object.)

GetObjectData Implements
the System.Runtime.Serialization.ISerializable interface
and returns the data needed to serialize
the LinkedList<T> instance.

GetType Gets the Type of the current instance. (Inherited

from Object.)

MemberwiseClone Creates a shallow copy of the current Object. (Inherited

from Object.)

OnDeserialization Implements
the System.Runtime.Serialization.ISerializable interface
and raises the deserialization event when the deserialization
is complete.

Remove(T) Removes the first occurrence of the specified value from

the LinkedList<T>.

Remove(LinkedListNode<T>) Removes the specified node from the LinkedList<T>.

RemoveFirst Removes the node at the start of the LinkedList<T>.

RemoveLast Removes the node at the end of the LinkedList<T>.

ToString Returns a string that represents the current object. (Inherited

from Object.)
C# program that uses LinkedList

using System;
using System.Collections.Generic;

class Program
{
static void Main()
{
//
// Create a new linked list object instance.
//
LinkedList<string> linked = new LinkedList<string>();
//
// Use AddLast method to add elements at the end.
// Use AddFirst method to add element at the start.
//
linked.AddLast("cat");
linked.AddLast("dog");
linked.AddLast("man");
linked.AddFirst("first");
//
// Loop through the linked list with the foreach-loop.
//
foreach (var item in linked)
{
Console.WriteLine(item);
}
}
}

Output

first
cat
dog
man
C# program that finds nodes in LinkedList

using System;
using System.Collections.Generic;

class Program
{
static void Main()
{
// Create a new linked list.
//
LinkedList<string> linked = new LinkedList<string>();
//
// First add three elements to the linked list.
linked.AddLast("one");
linked.AddLast("two");
linked.AddLast("three");

// Insert a node before the second node (after the first node)
//
LinkedListNode<string> node = linked.Find("one");

linked.AddAfter(node, "inserted");
//
// Loop through the linked list.
//
foreach (var value in linked)
{
Console.WriteLine(value);
}
}
}

Output

one
inserted
two
three
using System;
using System.Text;
using System.Collections.Generic;

public class Example

{
public static void Main()
{
// Create the link list.

string[] words = { "the", "fox", "jumped", "over", "the", "dog" };

LinkedList<string> sentence = new LinkedList<string>(words);

Display(sentence, "The linked list values:");

Console.WriteLine("sentence.Contains(\"jumped\") = {0}",
sentence.Contains("jumped"));

//This code example produces the following output:

//
//The linked list values:
//the fox jumped over the dog

// Add the word 'today' to the beginning of the linked list.

sentence.AddFirst("today");
Display(sentence, "Test1: Add 'today' to beginning of the list:");

//Test 1: Add 'today' to beginning of the list:

//today the fox jumped over the dog

// Move the first node to be the last node.

LinkedListNode<string> mark1 = sentence.First;
sentence.RemoveFirst();
sentence.AddLast(mark1);
Display(sentence, "Test 2: Move first node to be last node:");

//Test 2: Move first node to be last node:

//the fox jumped over the dog today

// Change the last node be 'yesterday'.

sentence.RemoveLast();
sentence.AddLast("yesterday");
Display(sentence, "Test 3: Change the last node to 'yesterday':");

//Test 3: Change the last node to 'yesterday':

//the fox jumped over the dog yesterday
 // Move the last node to be the first node.
mark1 = sentence.Last;
sentence.RemoveLast();
sentence.AddFirst(mark1);
Display(sentence, "Test 4: Move last node to be first node:");
//Test 4: Move last node to be first node:
//yesterday the fox jumped over the dog

// Indicate, by using parentheisis, the last occurence of 'the'.

sentence.RemoveFirst();
LinkedListNode<string> current = sentence.FindLast("the");
IndicateNode(current, "Test 5:Indicate last occurence of 'the':");

//Test 5: Indicate last occurence of 'the':

//the fox jumped over (the) dog

// Add 'lazy'and'old' after 'the'(the LinkedListNode named

current).
sentence.AddAfter(current, "old");
sentence.AddAfter(current, "lazy");
IndicateNode(current, "Test 6: Add 'lazy' and 'old' after
'the':");

//Test 6: Add 'lazy' and 'old' after 'the':

//the fox jumped over (the) lazy old dog

// Indicate 'fox' node.

current = sentence.Find("fox");
IndicateNode(current, "Test 7: Indicate the 'fox' node:");
//Test 7: Indicate the 'fox' node:
//the (fox) jumped over the lazy old dog

// Add 'quick' and 'brown' before 'fox':

sentence.AddBefore(current, "quick");
sentence.AddBefore(current, "brown");
IndicateNode(current, "Test 8: Add 'quick' and 'brown'
before 'fox':");
//Test 8: Add 'quick' and 'brown' before 'fox':
//the quick brown (fox) jumped over the lazy old dog
 // Keep a reference to the current node, 'fox',
// and to the previous node in the list. Indicate the
'dog' node.
mark1 = current;
LinkedListNode<string> mark2 = current.Previous;
current = sentence.Find("dog");
IndicateNode(current, "Test 9: Indicate the 'dog' node:");
//Test 9: Indicate the 'dog' node:
//the quick brown fox jumped over the lazy old (dog)

// The AddBefore method throws an InvalidOperationException

// if you try to add a node that already belongs to a list.
Console.WriteLine("Test 10: Throw exception by adding node (fox)
already in the list:");

//Test 10: Throw exception by adding node (fox) already

in the list:
//Exception message: The LinkedList node belongs a
LinkedList.

try
{
sentence.AddBefore(current, mark1);
}
catch (InvalidOperationException ex)
{
Console.WriteLine("Exception message: {0}",
ex.Message);
}
Console.WriteLine();

// Remove the node referred to by mark1, and then add it

// before the node referred to by current.
// Indicate the node referred to by current.
sentence.Remove(mark1);
sentence.AddBefore(current, mark1);
IndicateNode(current, "Test 11: Move a referenced node
(fox) before the current node (dog):");
//Test 11: Move a referenced node (fox) before the
current node (dog):
//the quick brown jumped over the lazy old fox (dog)
// Remove the node referred to by current.
sentence.Remove(current);
IndicateNode(current, "Test 12: Remove current node (dog)
and attempt to indicate it:");

//Test 12: Remove current node (dog) and attempt to

indicate it:
//Node 'dog' is not in the list.

// Add the node after the node referred to by mark2.

sentence.AddAfter(mark2, current);
IndicateNode(current, "Test 13: Add node removed in test
11 after a referenced node (brown):");
//Test 13: Add node removed in test 11 after a
referenced node (brown):
//the quick brown (dog) jumped over the lazy old fox

// The Remove method finds and removes the

// first node that that has the specified value.
sentence.Remove("old");
Display(sentence, "Test 14: Remove node that has the value
'old':");
//Test 14: Remove node that has the value 'old':
//the quick brown dog jumped over the lazy fox

// When the linked list is cast to ICollection(Of String),

// the Add method adds a node to the end of the list.
sentence.RemoveLast();
ICollection<string> icoll = sentence;
icoll.Add("rhinoceros");
Display(sentence, "Test 15: Remove last node, cast to
ICollection, and add 'rhinoceros':");
//Test 15: Remove last node, cast to ICollection, and
add 'rhinoceros':
//the quick brown dog jumped over the lazy rhinoceros
 Console.WriteLine("Test 16: Copy the list to an array:");
//Test 16: Copy the list to an array:
//the
//quick
//brown
//dog
//jumped
//over
//the
//lazy
//rhinoceros

// Create an array with the same number of

// elements as the inked list.
string[] sArray = new string[sentence.Count];
sentence.CopyTo(sArray, 0);

foreach (string s in sArray)

{
Console.WriteLine(s); }

// Release all the nodes.

sentence.Clear();

Console.WriteLine();
Console.WriteLine("Test 17: Clear linked list. Contains
'jumped' = {0}",
//Test 17: Clear linked list. Contains 'jumped' = False
//

sentence.Contains("jumped"));

Console.ReadLine();
}

private static void Display(LinkedList<string> words, string

test)
{
Console.WriteLine(test);
foreach (string word in words)
{
Console.Write(word + " ");
}
Console.WriteLine();
Console.WriteLine();
}
 private static void IndicateNode(LinkedListNode<string> node,
string test)
{
Console.WriteLine(test);
if (node.List == null)
{
Console.WriteLine("Node '{0}' is not in the list.\n",
node.Value);
return;
}

StringBuilder result = new StringBuilder("(" + node.Value

+ ")");
LinkedListNode<string> nodeP = node.Previous;

while (nodeP != null)

{
result.Insert(0, nodeP.Value + " ");
nodeP = nodeP.Previous;
}

node = node.Next;
while (node != null)
{
result.Append(" " + node.Value);
node = node.Next;
}

Console.WriteLine(result);
Console.WriteLine();
}}

//This code example produces the following output:

//
//The linked list values:
//the fox jumped over the dog

//Test 1: Add 'today' to beginning of the list:

//today the fox jumped over the dog

//Test 2: Move first node to be last node:

//the fox jumped over the dog today

//Test 3: Change the last node to 'yesterday':

//the fox jumped over the dog yesterday

//Test 4: Move last node to be first node:

//yesterday the fox jumped over the dog
//Test 5: Indicate last occurence of 'the':
//the fox jumped over (the) dog

//Test 6: Add 'lazy' and 'old' after 'the':

//the fox jumped over (the) lazy old dog

//Test 7: Indicate the 'fox' node:

//the (fox) jumped over the lazy old dog

//Test 8: Add 'quick' and 'brown' before 'fox':

//the quick brown (fox) jumped over the lazy old dog

//Test 9: Indicate the 'dog' node:

//the quick brown fox jumped over the lazy old (dog)

//Test 10: Throw exception by adding node (fox) already in the list:
//Exception message: The LinkedList node belongs a LinkedList.

//Test 11: Move a referenced node (fox) before the current node
(dog):
//the quick brown jumped over the lazy old fox (dog)

//Test 12: Remove current node (dog) and attempt to indicate it:
//Node 'dog' is not in the list.

//Test 13: Add node removed in test 11 after a referenced node

(brown):
//the quick brown (dog) jumped over the lazy old fox

//Test 14: Remove node that has the value 'old':

//the quick brown dog jumped over the lazy fox

//Test 15: Remove last node, cast to ICollection, and add

'rhinoceros':
//the quick brown dog jumped over the lazy rhinoceros

//Test 16: Copy the list to an array:

//the
//quick
//brown
//dog
//jumped
//over
//the
//lazy
//rhinoceros

//Test 17: Clear linked list. Contains 'jumped' = False

//