Microsoft Visual C++/CLI Collections: Linked Lists

	Linked Lists

The .NET Framework's Linked List

Introduction

A linked list is a collection with the following rules:

Each item in the list is called a node (this is not an actual rule but a habit or a suggestion)

If the list is empty, it may have one item referred to as null
If the list was just empty, when a new node is added, that node becomes the first and last item
If the list has only one node, that node represents the first and the last item
If the list contains at least one node, whenever a new node is added, that new node is positioned as the last in the list. This is because the new node is added next to the existing node

If the list contains more than one node, each item holds a reference to the object next to it

In reality, there are various types of linked lists. A singly linked list is a one-way directional list where each item points (only) to the item next to it (in a somewhat right direction). The description we just gave is conform to a singly linked list. Another type is the doubly linked list:

Each item in the list is called a node (again, this is not a real rule)
If the list is empty, it may have one item referred to as null or two items referred to as nulls
If a new node is added to an empty list, that node is added as the first in the collection
If the list contains one node, that node has two references to itself: one reference as the next and the other reference as its previous
If the list contains two nodes:
- One node is the first. That first node holds a reference to the other node as its next
- The other node is the last. That last node holds a reference to the first node as its previous item
If the list contains more than two nodes:
- The first node holds a reference to the next node (in the right direction)
- The last node holds a reference to the node previous to it (in the left direction)
- Each node holds two references: one reference to the previous node and one reference to the next node

Nodes of a Linked List

The last type of linked list is called a circular linked list. This list is primarily created as either a singly linked list or a doubly linked list:

In a circular singly linked list, the list primarily follows the rules of a singly linked list. then:
- If the list has two nodes, the first node holds a reference to the other node as its next and its previous node
- If the list has more than one node:
  - The first node holds a reference to the last node as its previous object
  - The last node holds a reference to first node as its next

Circular Singly Linked List

In a doubly linked list, the list includes the rules of the doubly linked list and combines with those of the circular singly linked list:
- The first node has a reference to the last node as its previous node
- The last node has a reference to the first node as its next node
- Each node has two references: its previous and its next nodes

Circular Doubly Linked List

Creating a Linked List

Although you can create a linked list collection class from scratch, to assist you, the .NET Framework provides a class named LinkedList and that is a member of the System::Collections::Generic namespace. LinkedList is a generic collection class with three constructors. The default constructor allows you to create an empty linked list. Here is an example:

#include <windows.h>

#using <System.dll>
#using <System::Drawing.dll>
#using <System.Windows.Forms.dll>

using namespace System;
using namespace System::Drawing;
using namespace System::Windows::Forms;
using namespace System::Collections::Generic;

public ref class CExercise : public Form
{
public:
    Button ^ btnLinkedList;

    CExercise()
    {
	InitializeComponent();
    }

private:
    void InitializeComponent()
    {
        btnLinkedList = gcnew Button;
        btnLinkedList->Location = System::Drawing::Point(12, 12);
		btnLinkedList->AutoSize = true;
        btnLinkedList->Text = L"Linked List";
        btnLinkedList->Click += 
        	gcnew EventHandler(this, &CExercise::btnLinkedListClicked);

        Controls->Add(btnLinkedList);
        Text = L"Linked List Example";
        StartPosition = FormStartPosition::CenterScreen;
    }

    void btnLinkedListClicked(Object ^ sender, EventArgs ^ e)
    {
        LinkedList<double> ^ numbers = gcnew LinkedList<double>;
    }
};

int APIENTRY WinMain(HINSTANCE hInstance,
		     HINSTANCE hPrevInstance,
		     LPSTR lpCmdLine,
		     int nCmdShow)
{
    Application::Run(gcnew CExercise());

    return 0;
}

Another constructor allows you to create a linked using an existing list. Its syntax is:

public:
    LinkedList(IEnumerable<T>^ collection);

The argument can be a variable from any class that implements the IEnumerable<T> interface. Here is an example:

void btnLinkedListClicked(Object ^ sender, EventArgs ^ e)
{
    List<double> ^ values = gcnew List<double>;
    values->Add(84.597);
    values->Add(6.47);
    values->Add(2747.06);
    values->Add(282.924);

    LinkedList<double> ^ numbers = gcnew LinkedList<double>(values);
}

Fundamental Operations on a Linked List

Introduction to a Node as an Object

As mentioned already, it is a tradition to call an item of a linked list as node. To define a node as a true object, the .NET Framework provides the LinkedListNode sealed class:

generic<typename T>
public ref class LinkedListNode sealed

This class has only properties, no member functions.

The Number of Nodes of a List

The LinkedList class starts as follows:

generic<typename T>
public ref class LinkedList : ICollection<T>, 
                              IEnumerable<T>,
                              ICollection,
                              IEnumerable,
                              ISerializable,
                              IDeserializationCallback

As you can see, the LinkedList class implements the ICollection interface. This gives it a Count property that produces the number of nodes. Here is an example:

void btnLinkedListClicked(Object ^ sender, EventArgs ^ e)
{
    List<double> ^ values = gcnew List<double>;
    values->Add(84.597);
    values->Add(6.47);
    values->Add(2747.06);
    values->Add(282.924);

    LinkedList<double> ^ numbers = gcnew LinkedList<double>(values);

    MessageBox::Show(L"There are " + numbers->Count.ToString() +
    		     L" numbers in the list",
                     L"Linked List",
                     MessageBoxButtons::OK, MessageBoxIcon::Information);
}

Linked List

Adding a Node

The primary operation to perform on a linked list is to add a new node to it. To support it, the LinkedList class is equipped with various member functions. One of them is named AddLast that is overloaded in two versions. One of them uses the following syntax:

public:
    LinkedListNode<T>^ AddLast(T value);

This member function expects the new value as argument. Here is an example of calling it:

#include <windows.h>

#using <System.dll>
#using <System::Drawing.dll>
#using <System.Windows.Forms.dll>

using namespace System;
using namespace System::Drawing;
using namespace System::Windows::Forms;
using namespace System::Collections::Generic;

public ref class CExercise : public Form
{
public:
    Button ^ btnLinkedList;

    CExercise()
    {
	InitializeComponent();
    }

private:
    void InitializeComponent()
    {
        btnLinkedList = gcnew Button;
        btnLinkedList->Location = System::Drawing::Point(12, 12);
		btnLinkedList->AutoSize = true;
        btnLinkedList->Text = L"Linked List";
        btnLinkedList->Click += gcnew EventHandler(this,
        				&CExercise::btnLinkedListClicked);

        Controls->Add(btnLinkedList);
        Text = L"Linked List Example";
        StartPosition = FormStartPosition::CenterScreen;
    }

    void btnLinkedListClicked(Object ^ sender, EventArgs ^ e)
    {
        LinkedList<double> ^ numbers = gcnew LinkedList<double>;

        numbers->AddLast(148.24);
    }
};

Another version of this member function is:

public:
    void AddLast(LinkedListNode<T>^ node);

This version expects a LinkedListNode object as argument. Here is an example of calling it:

void btnLinkedListClicked(Object ^ sender, EventArgs ^ e)
{
    LinkedList<double> ^ numbers = gcnew LinkedList<double>;
    LinkedListNode<double> ^ number = gcnew LinkedListNode<double>(148.24);

    numbers->AddLast(number);
}

In the same way, you can use this member function to add new items. Here are examples:

void btnLinkedListClicked(Object ^ sender, EventArgs ^ e)
{
    LinkedList<double> ^ numbers = gcnew LinkedList<double>;

    LinkedListNode<double> ^ number = gcnew LinkedListNode<double>(148.24);
    numbers->AddFirst(number);

    number = gcnew LinkedListNode<double>(35.75);
    numbers->AddLast(number);

    number = gcnew LinkedListNode<double>(2222.06);
    numbers->AddLast(number);

    number = gcnew LinkedListNode<double>(4.19);
    numbers->AddLast(number);

    number = gcnew LinkedListNode<double>(66.18);
    numbers->AddLast(number);
}

We will come back to that member function.

Looking for a Node

Introduction

Because the LinkedList implements the ICollection interface, it inherits the Contains member function. As a reminder, its syntax is:

public:
    virtual bool Contains(T value) sealed;

This member function checks whether the linked list contains a node that has the value passed as argument. If that node is found, the member function returns true. Otherwise it returns false.

Finding a Node

While the Contains() member function is used to look for a value in a linked list, it only lets you know whether the value was found. If you want to get the actual node that has that value, you can call the Find() member function. Its syntax is:

public:
    LinkedListNode<T>^ Find(T value);

When this member function is called, it starts looking for the value in the linked list. If it finds it, it returns its node. Here is an example of calling it:

void btnLinkedListClicked(Object ^ sender, EventArgs ^ e)
{
    List<double> ^ values = gcnew List<double>;
    values->Add(84.597);
    values->Add(6.47);
    values->Add(2747.06);
    values->Add(282.924);

    LinkedList<double> ^ numbers = gcnew LinkedList<double>(values);
    LinkedListNode<double> ^ number = gcnew LinkedListNode<double>(148.24);
    numbers->AddFirst(number);

    number = gcnew LinkedListNode<double>(35.75);
    numbers->AddFirst(number);

    number = gcnew LinkedListNode<double>(2222.06);
    numbers->AddFirst(number);

    number = gcnew LinkedListNode<double>(4.19);
    numbers->AddFirst(number);

    number = gcnew LinkedListNode<double>(66.18);
    numbers->AddFirst(number);

    if( numbers->Find(2747.06) != nullptr )
        MessageBox::Show(L"2747.06 was found in the list.",
                         L"Linked List",
                         MessageBoxButtons::OK, MessageBoxIcon::Information);
    else
        MessageBox::Show(L"2747.06 is nowhere in the list.",
                         L"Linked List",
                         MessageBoxButtons::OK, MessageBoxIcon::Information);
}

Linked List

If there is more than one node with that value, the member function returns only the first node that has that value. If the list contains more than one node that has the value but you prefer to use the last node, you can call the FindLast() member function.

public:
    LinkedListNode<T>^ FindLast(T value);

Getting Each Node

As you can see, the LinkedList class doesn't implement the IList interface, which means it doesn't have an Item property. As we have seen with the AddLast() member function and as we will see in the next sections, each member function used to add a node is provided in two versions. One of the versions returns a LinkedListNode object. This means that, when performing an addition operation, you can get the returned value and do what you want with it.

The LinkedList class implements the IEnumerable interface. This makes it possible to use for each to get to access each node. This can be done as follows:

void btnLinkedListClicked(Object ^ sender, EventArgs ^ e)
{
    LinkedList<double> ^ numbers = gcnew LinkedList<double>;
        
    LinkedListNode<double> ^ number = gcnew LinkedListNode<double>(148.24);
    
    numbers->AddFirst(number);

    for each (double nbr in numbers)
            MessageBox::Show(nbr.ToString());
}

The Value of a Node

Probably the most important detail of a node is its value. To support it, the LinkedListNode class has a property named Value:

public T Value { get; set; }

Because this is a read-write property, you can use its write-accessory to specify or change its value. On the other hand, you can access the value of a node using this property.

Navigating Among the Nodes

The First and the Last Nodes

As mentioned already, a linked list has a first and a last nodes (some people or documentations call them the head and the tail). To identify the first node, the LinkedList class is equippped with a read-only property named First. Its syntax is:

public:
    property LinkedListNode<T>^ First
    {
	LinkedListNode<T>^ get();
    }

The last node is represented by a read-only property of the same name and that, too, is a LinkedListNode object:

public:
    property LinkedListNode<T>^ Last
    {
    	LinkedListNode<T>^ get();
    }

Here are examples of accessing these properties:

void btnLinkedListClicked(Object ^ sender, EventArgs ^ e)
{
    LinkedList<double> ^ numbers = gcnew LinkedList<double>;

    LinkedListNode<double> ^ number = gcnew LinkedListNode<double>(148.24);
    numbers->AddFirst(number);

    number = gcnew LinkedListNode<double>(35.75);
    numbers->AddFirst(number);

    number = gcnew LinkedListNode<double>(2222.06);
    numbers->AddFirst(number);

    number = gcnew LinkedListNode<double>(4.19);
    numbers->AddFirst(number);

    number = gcnew LinkedListNode<double>(66.18);
    numbers->AddFirst(number);

    MessageBox::Show(L"The value of the first node is " + numbers->First->Value);
    MessageBox::Show(L"The value of the last node is " + numbers->Last->Value);
}

The Next and Previous Nodes

To access a node that is next to an existing node, you must first know what node is used as reference. To let you access the next node, the LinkedListNode class is equipped with a read-only property named Next:

public:
    property LinkedListNode<T>^ Next
    {
    	LinkedListNode<T>^ get ();
    }

To let you access the node previous to an existing one, the LinkedListNode class is equipped with the read-only Previous property:

public:
    property LinkedListNode<T>^ Previous
    {
    	LinkedListNode<T>^ get ();
    }

Remember that in both cases, you need a node as reference.

Creating Nodes

Adding the First Node

When dealing with a linked list, you have many options on how to add a new node. As mentioned already, a linked list has a first node, a last node, and one or more nodes between them. All nodes have and use some references with regards to the node(s) close to them. Based on this, when adding a new node, you have to specify whether you want it as the first node, the last node, the node before a certain node, or the node after a certain one. The LinkedList class easily supports all these operations with very little effort on your part.

We saw that you could call the AddFirst() member function to add a new node. In reality, there is no such a thing as simply adding a new node to a linked list (the concept of a linked list is based on the fact that nodes are "linked"). When a linked list has just been created and it is empty, it holds a reference to a null node. There is nothing you can do with that node and you don't need to do anything with it. To start adding nodes, you have the option of setting it as the first or the last item. This would not make any difference because there is no other node in the list.

After adding a node, it becomes a reference that new nodes can use. If you call the AddFirst() member function, the new node would be added before any existing node in the collection.

Adding the Last Node

By contrast, you can call a member function named AddLast. It is overloaded with versions whose syntaxes are:

public:
    LinkedListNode<T>^ AddLast(T value);
    void AddLast(LinkedListNode<T>^ node);

When you call this member function, the value or node you pass will be added as the last item in the list. Here is an example:

#include <windows.h>

#using <System.dll>
#using <System.Drawing.dll>
#using <System.Windows.Forms.dll>

using namespace System;
using namespace System::Drawing;
using namespace System::Windows::Forms;
using namespace System::Collections::Generic;

public ref class CExercise : public Form
{
public:
    Button  ^ btnLinkedList;
    ListBox ^ lbxLinkedList;

    CExercise()
    {
	InitializeComponent();
    }

private:
    void InitializeComponent()
    {
        btnLinkedList = gcnew Button;
        btnLinkedList->Location = System::Drawing::Point(12, 12);
		btnLinkedList->AutoSize = true;
        btnLinkedList->Text = L"Linked List";
        btnLinkedList->Click += gcnew EventHandler(this,
        				&CExercise::btnLinkedListClicked);

        lbxLinkedList = gcnew ListBox();
        lbxLinkedList->Location = System::Drawing::Point(12, 40);
        lbxLinkedList->Height = 140;

        Controls->Add(btnLinkedList);
		Controls->Add(lbxLinkedList);
        Text = L"Linked List Example";
        StartPosition = FormStartPosition::CenterScreen;
    }

    void btnLinkedListClicked(Object ^ sender, EventArgs ^ e)
    {
        List<double> ^ values = gcnew List<double>;
    	values->Add(84.597);
    	values->Add(6.47);
    	values->Add(2747.06);
    	values->Add(282.924);

    	LinkedList<double> ^ numbers = gcnew LinkedList<double>(values);
    	LinkedListNode<double> ^ number = gcnew LinkedListNode<double>(148.24);
    	numbers->AddFirst(number);

    	number = gcnew LinkedListNode<double>(35.75);
    	numbers->AddFirst(number);

    	numbers->AddLast(2747.06);

    	number = gcnew LinkedListNode<double>(2222.06);
    	numbers->AddFirst(number);

    	number = gcnew LinkedListNode<double>(4.19);
    	numbers->AddFirst(number);

    	number = gcnew LinkedListNode<double>(66.18);
    	numbers->AddFirst(number);

    	for each (double dbl in numbers)
            lbxLinkedList->Items->Add(dbl);
    }
};

int APIENTRY WinMain(HINSTANCE hInstance,
		     HINSTANCE hPrevInstance,
		     LPSTR lpCmdLine,
		     int nCmdShow)
{
    Application::Run(gcnew CExercise());

    return 0;
}

Linked List

Inserting a Node Before a Referenced One

A linked list supports the concept of inserting a node but not exactly like traditional collections do it. With a linked list, you must add a node before or after an existing node used as reference.

Behind the scenes, before inserting a node, you must identify the position where you want to put it. That is, you must identify what node you will use as reference:

Inserting a New node Before a Node

In this case, you want to insert a new node before the Other Node. Behind the scenes, the reference between the two existing nodes must be brocken. Then the new node points to the Other Node as its next and the Other Node points at the New Node as its previous:

Inserting a New node Before a Node

After the new node has been added, it must point to the previous node (Some Node in our example) as its previous item. The previous node (Some Node in our example) must now point to the new node as its next item:

As you may imagine, to insert a node, you must provide two pieces of information: a reference to the node that will succeed the new node, and the new node (or its value). If the referenced node is the first item of the list, the new node would become the new first object.

To assist you with this operation, the LinkedList class provides a member function named AddBefore. This member function is overloaded with two versions whose syntaxes are:

public:
    LinkedListNode<T>^ AddBefore(LinkedListNode<T>^ node, T value);
    void AddBefore(LinkedListNode<T>^ node, LinkedListNode<T>^ newNode);

In both cases, you pass the first argument as an existing node. In the first case, you directly pass the value to be positioned before node. Here is an example:

void btnLinkedListClicked(Object ^ sender, EventArgs ^ e)
{
    List<double> ^ values = gcnew List<double>;
    values->Add(84.597);
    values->Add(6.47);
    values->Add(2747.06);
    values->Add(282.924);

    LinkedList<double> ^ numbers = gcnew LinkedList<double>(values);
    LinkedListNode<double> ^ number = gcnew LinkedListNode<double>(148.24);
    numbers->AddFirst(number);

    number = gcnew LinkedListNode<double>(35.75);
    numbers->AddFirst(number);

    numbers->AddLast(2747.06);

    LinkedListNode<double> ^ number222206 = gcnew LinkedListNode<double>(2222.06);
    numbers->AddLast(number222206);

    number = gcnew LinkedListNode<double>(4.19);
    numbers->AddFirst(number);

    number = gcnew LinkedListNode<double>(66.18);
    numbers->AddBefore(number222206, number);

    number = gcnew LinkedListNode<double>(275.775);
    numbers->AddLast(number);

    for each (double dbl in numbers)
        lbxLinkedList->Items->Add(dbl);
}

Linked List

In the second case, you must pass the LinkedListNode object that will be inserted the node.

Inserting a Node After a Referenced One

Instead of inserting a node before an existing one, you can add it after one. The approach is logically the same as inserting a node before another, except that the sequence is reversed. First, identify the node that will be used as reference. Start the process to add the new node after that one. Behind the scenes, the referenced node will point to the new node as its next and the new node will point to the existing node as its previous:

Inserting a New node After an Existing Node

After the new node as been added, it will point to the node after it as its next. The other node will point to the new node as its previous:

If the new node is added after the last node, the new node will become the new last node.

To let you insert a node after an existing node, the LinkedList class is equipped with a member function named AddAfter. It comes in two versions and their syntaxes are:

public:
    LinkedListNode<T>^ AddAfter(LinkedListNode<T>^ node, T value;);
    void AddAfter(LinkedListNode<T>^ node, LinkedListNode<T>^ newNode);

The arguments follow the same description as the AddBefore() member function, only in reverse. Here is an example:

void btnLinkedListClicked(Object ^ sender, EventArgs ^ e)
{
    List<double> ^ values = gcnew List<double>;
    values->Add(84.597);
    values->Add(6.47);
    values->Add(2747.06);
    values->Add(282.924);

    LinkedList<double> ^ numbers = gcnew LinkedList<double>(values);
    LinkedListNode<double> ^ number = gcnew LinkedListNode<double>(148.24);
    numbers->AddFirst(number);

    LinkedListNode<double> ^ number3575 = gcnew LinkedListNode<double>(35.75);
    numbers->AddFirst(number3575);

    numbers->AddLast(2747.06);

    LinkedListNode<double> ^ number222206 = gcnew LinkedListNode<double>(2222.06);
    numbers->AddLast(number222206);

    number = gcnew LinkedListNode<double>(4.19);
    numbers->AddFirst(number);

    number = gcnew LinkedListNode<double>(66.18);
    numbers->AddBefore(number222206, number);

    number = gcnew LinkedListNode<double>(275.775);
    numbers->AddAfter(number3575, number);

    for each (double dbl in numbers)
        lbxLinkedListOriginal->Items->Add(dbl);

    numbers->RemoveFirst();
    numbers->RemoveLast();

    for each (double dbl in numbers)
        lbxLinkedListOther->Items->Add(dbl);
}

Linked List

Deleting Nodes

Deleting the First or Last Node

When it comes time to delete a node, you have many options, such as deleting the first or the last node of the list. To let you delete the first node, the LinkedList class provides the RemoveFirst() member function. Its syntax is:

public void RemoveFirst();

As you can see, this member function takes no argument. When it is called:

If the list is empty, the compiler throws an InvalidOperationException exception:

Invalid Operation Exception

If the list contains one node, that node gets deleted
If the list contains more than one node, the first one gets deleted

To delete the last node, you can call the RemoveLast() member function whose syntax is:

public:
    void RemoveFirst();

This member function follows the same logic as the RemoveFirst() member function, only in reverse. Here are examples of calling these methods:

using System;
using System.Windows.Forms;
using System.Collections.Generic;

public class LinkedListExample : Form
{
    Button btnLinkedList;
    ListBox lbxLinkedListOriginal;
    ListBox lbxLinkedListOther;

    public LinkedListExample()
    {
        InitializeComponent();
    }

    private void InitializeComponent()
    {
        btnLinkedList = new Button();
        btnLinkedList.Location = new System.Drawing.Point(12, 12);
        btnLinkedList.Text = "Linked List";
        btnLinkedList.Click += new EventHandler(btnLinkedListClicked);

        lbxLinkedListOriginal = new ListBox();
        lbxLinkedListOriginal.Location = new System.Drawing.Point(12, 40);
        lbxLinkedListOriginal.Size = new System.Drawing.Size(75, 160);

        lbxLinkedListOther = new ListBox();
        lbxLinkedListOther.Location = new System.Drawing.Point(100, 40);
        lbxLinkedListOther.Size = new System.Drawing.Size(75, 160);

        Controls.Add(btnLinkedList);
        Controls.Add(lbxLinkedListOriginal);
        Controls.Add(lbxLinkedListOther);
        Text = "Linked List";
        StartPosition = FormStartPosition.CenterScreen;
    }

    private void btnLinkedListClicked(object sender, EventArgs e)
    {
        List<double> values = new List<double>();
        values.Add(84.597);
        values.Add(6.47);
        values.Add(2747.06);
        values.Add(282.924);

        LinkedList<double> numbers = new LinkedList<double>(values);
        LinkedListNode<double> number = new LinkedListNode<double>(148.24);
        numbers.AddFirst(number);

        LinkedListNode<double> number3575 = new LinkedListNode<double>(35.75);
        numbers.AddFirst(number3575);

        numbers.AddLast(2747.06);

        LinkedListNode<double> number222206 = new LinkedListNode<double>(2222.06);
        numbers.AddLast(number222206);

        number = new LinkedListNode<double>(4.19);
        numbers.AddFirst(number);

        number = new LinkedListNode<double>(66.18);
        numbers.AddBefore(number222206, number);

        number = new LinkedListNode<double>(275.775);
        numbers.AddAfter(number3575, number);

        foreach (double dbl in numbers)
            lbxLinkedListOriginal.Items.Add(dbl);

        numbers.RemoveFirst();
        numbers.RemoveLast();

        foreach (double dbl in numbers)
            lbxLinkedListOther.Items.Add(dbl);
    }
}

public class Exercise
{
    public static int Main()
    {
        Application.Run(new LinkedListExample());
        return 0;
    }
}

Linked List

Removing a Node by Value

There are two ways you can delete an item inside the collection. This can be done using the Remove() member function. It comes in two versions. If you know the exact value of the item you want to remove, you can call the follwing version of that member function:

public:
    virtual bool Remove(T value) sealed;

When calling this member function, pass the value to delete. The compiler would first look for a node that has that value:

If there is a node with that value in the list, it would be deleted
If there is no node with that value, nothing would happen (the compiler would not throw an exception)

An alternative is to delete a node based on its reference. To do this, use the following version:

public:
    void Remove(LinkedListNode<T>^ node);

When calling this member function, pass a reference to the node you want to delete.

Here is an example:

void btnLinkedListClicked(Object ^ sender, EventArgs ^ e)
{
    List<double> ^ values = gcnew List<double>;
    values->Add(84.597);
    values->Add(6.47);
    values->Add(2747.06);
    values->Add(282.924);

    LinkedList<double> ^ numbers = gcnew LinkedList<double>(values);
    LinkedListNode<double> ^ number = gcnew LinkedListNode<double>(148.24);
    numbers->AddFirst(number);

    LinkedListNode<double> ^ number3575 = gcnew LinkedListNode<double>(35.75);
    numbers->AddFirst(number3575);

    numbers->AddLast(2747.06);

    LinkedListNode<double> ^ number222206 = gcnew LinkedListNode<double>(2222.06);
    numbers->AddLast(number222206);

    number = gcnew LinkedListNode<double>(4.19);
    numbers->AddFirst(number);

    number = gcnew LinkedListNode<double>(66.18);
    numbers->AddBefore(number222206, number);

    LinkedListNode<double> ^ number275775 = gcnew LinkedListNode<double>(275.775);
    numbers->AddAfter(number3575, number275775);

    for each (double dbl in numbers)
        lbxLinkedListOriginal->Items->Add(dbl);

    numbers->Remove(number275775);

    for each (double dbl in numbers)
        lbxLinkedListOther->Items->Add(dbl);
}

Linked List

Clearing a Linked List

Clearing a list consists of deleting all of its item. To do this, you could continuous call one of the versions of the Remove() member function. A faster solution is to call the Clear() member function. Its syntax is:

public:
    virtual void Clear() sealed;