链表（二）：单向链表

一、什么是单向链表

在动态分配内存空间时，最常使用的就是“单向链表”（Single Linked List）。一个单向链表节点基本上是由两个元素，即数据字段和指针所组成，而指针将会指向下一个元素在内存中的位置，如下图所示：

在“单向链表”中，第一个节点是“链表头指针”，指向最后一个节点的指针设为NULL，表示它是“链表尾”，不指向任何地方。例如列表A={a、b、c、d、x}，其单向链表的数据结构如下图所示：

由于单向链表中所有节点都知道节点本身的下一个节点在哪里，但是对于前一个节点却没有办法知道，所以在单向链表的各种操作中，“链表头指针”就显得相当重要，只要存在链表头指针，就可以遍历整个链表，进行加入和删除节点等操作。

注意：除非必要，否则不可移动链表头指针。

通常在其他程序设计语言中，如C或C++语言，是以指针（pointer）类型来处理链表类型的数据结构。由于在C#程序设计语言中没有指针类型，因此可以把链表声明为类（class）。例如要模拟链表中的节点，必须声明如下的Node类，这里使用泛型：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SingleLinkedListDemo
{
    /// <summary>
    /// 链表节点类
    /// </summary>
    public class Node<T>
    {
        /// <summary>
        /// 数据字段
        /// </summary>
        public T Data { get; set; }

        /// <summary>
        /// 指针 指向下一个元素
        /// </summary>
        public Node<T> Next { get; set; }

        /// <summary>
        /// 无参构造函数
        /// </summary>
        public Node()
        {
            // 赋默认值
            this.Data = default(T);
            this.Next = null;
        }

        /// <summary>
        /// 只传递数据字段的构造函数，指针默认为null
        /// </summary>
        /// <param name="value"></param>
        public Node(T value)
        {
            this.Data = value;
            this.Next = null;
        }

        /// <summary>
        /// 同时传递数据和指针的构造函数
        /// </summary>
        /// <param name="value"></param>
        /// <param name="next"></param>
        public Node(T value,Node<T> next)
        {
            this.Data = value;
            this.Next = next;
        }

        /// <summary>
        /// 只传递指针的构造函数
        /// </summary>
        /// <param name="next"></param>
        public Node(Node<T> next)
        {
            this.Next = next;
        }
    }
}

接着可以声明链表SingleLinkedList类，该类定义两个Node<T>类型的节点指针，分别指向链表的第一个节点和最后一个节点：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SingleLinkedListDemo
{
    public class SingleLinkedList<T>
    {
        /// <summary>
        /// 头节点
        /// </summary>
        private Node<T> HeadNode;

        /// <summary>
        /// 尾节点
        /// </summary>
        private Node<T> LastNode;

        // 定义类中其它方法，增加节点、删除节点、移动节点等
    }
}

如果链表中的节点不只记录单一数值，例如每一个节点除了有指向下一个节点的指针字段外，还包括学生的姓名、学号、成绩，则其链表如下图所示：

如果是这种链表，我们可以先定义一个Student类，里面包括姓名、学号、成绩，然后Node节点里面使用泛型Node<Student>。下面我们以学生为例讲解如何创建一个单向链表。

1、建立单向链表

现在我们使用C#语言的链表处理以下学生的成绩问题。

首先我们必须声明节点的数据类型，让每一个节点包含一个数据，并且包含指向下一个节点的指针，使所有的数据都能被串在一起形成一个列表结构，最终链表如下图所示：

下面我们详细说明建立上图所示的单向链表的步骤：

1、建立一个新的节点，如图所示：

2、这时链表是空的，所以讲链表的first即last指针字段都指向新创建的节点newNode，如图所示：

3、建立另外一个新的节点，如图所示：

4、将上面的两个节点串起来，使用下面的代码：

last.next=newNode;
last=newNode;

如图所示：

5、重复上面的3、4步骤，将所有的节点都连接起来，最终链表结构如图所示：

由于列表中所有节点都知道节点本身的下一个节点在哪里，但是对于前一个节点却没有办法知道，所以“头节点”就显得非常重要。

无论如何，只要有头节点存在，就可以对整个列表进行遍历、加入、删除、查找等操作。而之前建立的节点若没有串接起来就会形成无人管理的节点，并一直占用内存空间。因此在建立列表时必须有一个列表指针指向头节点，并且在没有必要的情况下不可以移动列表首指针。

我们可以在程序中会声明Node类和SignleLinkedList类，在SignleLinkedList类中，定义了两个Node类型的节点指针，分别指向链表的第一个节点和最后一个节点。另外，该类中还需要声明下面的两个方法：

方法名称	功能描述
public bool IsEmpty()	用来判断当前的链表是否为空链表
public void Add(T item)	用来将指定的节点插入到当前的链表

下面我们以一个具体的例子来讲解如何创建一个单向链表。需求如下：

设计一个C#程序，可以让用户输入数据来添加学生数据节点，以建立一个单向链表。一共输入5位学生的成绩来建立单向链表，然后遍历单向链表中的每一个节点来打印输出学生的信息。

我们先建立Node节点类，这里使用泛型，利于扩展：

namespace SingleLinkedListDemo
{
    /// <summary>
    /// 链表节点类
    /// </summary>
    public class Node<T>
    {
        /// <summary>
        /// 数据字段
        /// </summary>
        public T Data { get; set; }

        /// <summary>
        /// 指针 指向下一个元素
        /// </summary>
        public Node<T> Next { get; set; }

        /// <summary>
        /// 无参构造函数
        /// </summary>
        public Node()
        {
            // 赋默认值
            this.Data = default(T);
            this.Next = null;
        }

        /// <summary>
        /// 只传递数据字段的构造函数，指针默认为null
        /// </summary>
        /// <param name="value"></param>
        public Node(T value)
        {
            this.Data = value;
            this.Next = null;
        }

        /// <summary>
        /// 同时传递数据和指针的构造函数
        /// </summary>
        /// <param name="value"></param>
        /// <param name="next"></param>
        public Node(T value,Node<T> next)
        {
            this.Data = value;
            this.Next = next;
        }

        /// <summary>
        /// 只传递指针的构造函数
        /// </summary>
        /// <param name="next"></param>
        public Node(Node<T> next)
        {
            this.Next = next;
        }
    }
}

我们创建一个Student类，用来存放学生信息：

namespace SingleLinkedListDemo
{
    /// <summary>
    /// 学生类
    /// </summary>
    public class Student
    {
        /// <summary>
        /// 学号
        /// </summary>
        public int Number { get; set; }

        /// <summary>
        /// 姓名
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 成绩
        /// </summary>
        public int Score { get; set; }

        public Student(int number,string name,int score)
        {
            Number = number;
            Name = name;
            Score = score;
        }
    }
}

最后创建SignleLinkedList类，代码如下：

using System.Collections.Generic;

namespace SingleLinkedListDemo
{
    /// <summary>
    /// 单向链表类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class SingleLinkedList<T>
    {
        /// <summary>
        /// 存放所有链表节点的集合
        /// </summary>
        public List<Node<T>> ListNode { get; set; }

        /// <summary>
        /// 构造函数
        /// </summary>
        public SingleLinkedList()
        {
            ListNode = new List<Node<T>>();
        }

        /// <summary>
        /// 头节点
        /// </summary>
        private Node<T> HeadNode;

        /// <summary>
        /// 尾节点
        /// </summary>
        private Node<T> LastNode;

        /// <summary>
        /// 判断当前链表是否为空链表
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return HeadNode == null;
        }

        /// <summary>
        /// 插入节点
        /// </summary>
        public void AddNode(T item)
        {
            // 新建一个节点
            Node<T> newNode = new Node<T>(item);
           
            // 判断头节点是否为null,如果为null，那么新建的节点就是头节点，同时也是尾节点
            if (IsEmpty())
            {
                // 如果是空链表，则将头节点和尾节点都指向新建的节点
                HeadNode = newNode;
                LastNode = newNode;
            }
            else
            {
                // 尾节点的指针指向新建的节点
                // 新建的节点变为尾节点
                LastNode.Next = newNode;
                LastNode = newNode;
            }
            // 将新建的节点添加到集合中
            ListNode.Add(newNode);
        }
    }
}

在Main方法里面调用：

using System;
using System.Collections.Generic;

namespace SingleLinkedListDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            int num;
            string name;
            int score;

            Console.WriteLine("请输入5位学生的成绩:");
            SingleLinkedList<Student> linkedList = new SingleLinkedList<Student>();
            for (int i = 0; i < 5; i++)
            {
                Console.Write("请输入学号：");
                num = int.Parse(Console.ReadLine());
                Console.Write("请输入姓名：");
                name = Console.ReadLine();
                Console.Write("请输入成绩：");
                score = int.Parse(Console.ReadLine());
                Student student = new Student(number: num, name: name, score: score);
                linkedList.AddNode(student);
                Console.WriteLine("----------------");
            }

            Console.WriteLine();
            Console.WriteLine("输出学生成绩信息");
            List<Node<Student>> list = linkedList.ListNode;
            foreach (var item in list)
            {
                Console.WriteLine($"学号： {item.Data.Number},姓名： {item.Data.Name},成绩： {item.Data.Score}");
                Console.WriteLine();
            }

            Console.ReadKey();
        }
    }
}

程序运行结果：

2、单向链表节点的删除

在单向链表类型的数据结构中，若要在链表中删除一个节点，则根据所删除节点的位置会有以下三种不同的情况。

1、删除链表的第一个节点

如果是删除链表中的第一个节点，只要把链表的头指针指向第二个节点即可，如图所示：

程序参考代码：

if(first.data == delNode.data)
    first=first.next;

2、删除链表内的中间节点

如果是删除链表内的中间节点，那么只要将删除节点的前一个节点的指针，指向要删除节点的下一个节点即可，如图所示：

 程序参考代码：

3、删除链表的最后一个节点

如果是删除链表的最后一个节点，那么只要将指向最后一个节点的指针，直接指向null即可，如图所示：

程序参考代码

我们还是以上面的例子进行讲解在链表中删除节点。输入学号，如果学号存在，则在链表中删除，然后打印出当前链表中的节点。如果学号不存在，则给出提示信息。要结束输入时，请输入“-1”，此时打印出链表中的节点信息。

这时上面创建的泛型类就不符合需求了，我们重新创建一个节点类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SingleLinkedListDemo
{
    /// <summary>
    /// 演示删除节点使用的节点类
    /// </summary>
    public class StudentNode
    {
        /// <summary>
        /// 学号
        /// </summary>
        public int Number { get; set; }

        /// <summary>
        /// 姓名
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 成绩
        /// </summary>
        public int Score { get; set; }

        /// <summary>
        /// 指针 指向下一个元素
        /// </summary>
        public StudentNode Next { get; set; }

        public StudentNode(int number,string name,int score)
        {
            Number = number;
            Name = name;
            Score = score;
        }
    }
}

链表类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SingleLinkedListDemo
{
    public class StudentLinkedList
    {

        public List<StudentNode> ListNode { get; set; }


        public StudentLinkedList()
        {
            ListNode = new List<StudentNode>();
        }


        /// <summary>
        /// 头节点
        /// </summary>
        public StudentNode HeadNode;

        /// <summary>
        /// 尾节点
        /// </summary>
        public StudentNode LastNode;

        /// <summary>
        /// 判断当前链表是否为空链表
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return HeadNode == null;
        }

        /// <summary>
        /// 添加节点
        /// </summary>
        /// <param name="node"></param>
        public void AddNode(StudentNode node)
        {
            StudentNode newNode = node;
            // 判断头节点是否为null,如果为null，那么新建的节点就是头节点，同时也是尾节点
            if (IsEmpty())
            {
                // 如果是空链表，则将头节点和尾节点都指向新建的节点
                HeadNode = newNode;
                LastNode = newNode;
            }
            else
            {
                // 尾节点的指针指向新建的节点
                // 新建的节点变为尾节点
                LastNode.Next = newNode;
                LastNode = newNode;
            }
            // 将新建的节点添加到集合中
            ListNode.Add(newNode);
        }

        /// <summary>
        /// 打印
        /// </summary>
        public void Print()
        {
            StudentNode current = HeadNode;
            while (current != null)
            {
                Console.WriteLine("[" + current.Number + " " + current.Name + " " + current.Score + "]");
                current = current.Next;
            }
            Console.WriteLine();
        }

        /// <summary>
        /// 删除节点
        /// </summary>
        /// <param name="delNode"></param>
        public void DeleteNode(StudentNode delNode)
        {
            StudentNode newNode;
            StudentNode tmpNode;

            // 如果删除的是第一个节点
            if(HeadNode.Number==delNode.Number)
            {
                // 头指针指向第二个节点
                HeadNode = HeadNode.Next;
            }
            else if(LastNode.Number==delNode.Number)
            {
                // 删除的是最后一个节点
                newNode = HeadNode;
                // 循环找到最后一个节点的前一个节点
                // 当退出循环的时候newNode就是最后一个节点的前一个节点
                while(newNode.Next!=LastNode)
                {
                    // 指针后移，指向下一个节点
                    newNode = newNode.Next;
                }
                // 最后一个节点的前一个节点的next赋值为null
                newNode.Next = null;
                LastNode = newNode;
            }
            else
            {
                // 删除的是中间的节点
                newNode = HeadNode;
                tmpNode = HeadNode;
                // 循环找到要删除的节点
                // 循环退出时tmpNode节点就是要删除节点的前一个节点,newNode节点就是要删除的节点
                while(newNode.Number!=delNode.Number)
                {
                    tmpNode = newNode;
                    // 后移，指向下一个节点
                    newNode = newNode.Next;
                }
                // 要删除节点的前一个节点的next指向删除节点的下一个节点
                tmpNode.Next = newNode.Next;
            }
        }

    }
}

Main方法里面调用：

using System;
using System.Collections.Generic;

namespace SingleLinkedListDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 创建一个单向链表
            //int num;
            //string name;
            //int score;

            //Console.WriteLine("请输入5位学生的成绩:");
            //SingleLinkedList<Student> linkedList = new SingleLinkedList<Student>();
            //for (int i = 0; i < 5; i++)
            //{
            //    Console.Write("请输入学号：");
            //    num = int.Parse(Console.ReadLine());
            //    Console.Write("请输入姓名：");
            //    name = Console.ReadLine();
            //    Console.Write("请输入成绩：");
            //    score = int.Parse(Console.ReadLine());
            //    Student student = new Student(number: num, name: name, score: score);
            //    linkedList.AddNode(student);
            //    Console.WriteLine("----------------");
            //}

            //Console.WriteLine();
            //Console.WriteLine("输出学生成绩信息");
            //List<Node<Student>> list = linkedList.ListNode;
            //foreach (var item in list)
            //{
            //    Console.WriteLine($"学号： {item.Data.Number},姓名： {item.Data.Name},成绩： {item.Data.Score}");
            //    Console.WriteLine();
            //} 
            #endregion

            #region 删除单向链表中的节点
            Random rand = new Random();
            StudentLinkedList list = new StudentLinkedList();
            int i, j, findword = 0;
            int[,] data = new int[12, 10];
            String[] name = new String[] { "Allen", "Scott",
                "Marry", "Jon", "Mark", "Ricky", "Lisa",
                "Jasica", "Hanson", "Amy", "Bob", "Jack" };
            Console.WriteLine("学号 成绩  学号 成绩  学号 成绩  学号  成绩
 ");
            // 链表里面添加12个节点
            for (i = 0; i < 12; i++)
            {
                data[i, 0] = i + 1;
                data[i, 1] = (Math.Abs(rand.Next(50))) + 50;
                StudentNode node = new StudentNode(data[i, 0], name[i], data[i, 1]);
                list.AddNode(node);
            }
            // 分三行输出
            for (i = 0; i < 3; i++)
            {
                for (j = 0; j < 4; j++)
                    Console.Write("[" + data[j * 3 + i, 0] + "]  [" + data[j * 3 + i, 1] + "]  ");
                Console.WriteLine();
            }
            while (true)
            {
                Console.Write("请输入要删除成绩的学生学号，结束输入-1： ");
                findword = int.Parse(Console.ReadLine());
                if (findword == -1)
                    break;
                else
                {
                    StudentNode current = new StudentNode(list.HeadNode.Number, list.HeadNode.Name, list.HeadNode.Score);
                    current.Next = list.HeadNode.Next;
                    while (current.Number != findword) current = current.Next;
                    list.DeleteNode(current);
                }
                Console.WriteLine("删除后成绩的链表，请注意！要删除的成绩其学生的学号必须在此链表中
");
                list.Print();
            }
            #endregion

            Console.ReadKey();
        }
    }
}

程序运行结果：

3、单向链表插入新节点

在单向链表中插入新节点，如同一列火车中加入新的车厢，有三种情况：加到第一个节点之前、加到最后一个节点之后以及加到此链表中间任一位置。

1、新节点插入第一个节点之前

将新节点插入到第一个节点之前，新节点即成为此链表的首节点，只需要把新节点的指针指向链表原来的第一个节点，再把链表头指针指向新节点即可，如图所示：

2、新节点插入最后一个节点之后

将新节点插入到最后一个节点之后，只需要把链表的最后一个节点的指针指向新节点，新节点的指针在指向null即可，如图所示：

3、新节点插入链表中间位置

例如插入的节点是在X和Y之间，只需要将X节点的指针指向新节点，如图所示：

然后将新节点的指针指向Y节点即可，如图所示：

下面我们以泛型Node类为例，讲解如何插入节点

using System;
using System.Collections.Generic;

namespace SingleLinkedListDemo
{
    /// <summary>
    /// 单向链表类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class SingleLinkedList<T>
    {
        /// <summary>
        /// 存放所有链表节点的集合
        /// </summary>
        public List<Node<T>> ListNode { get; set; }

        /// <summary>
        /// 构造函数
        /// </summary>
        public SingleLinkedList()
        {
            ListNode = new List<Node<T>>();
        }

        /// <summary>
        /// 头节点
        /// </summary>
        private Node<T> HeadNode;

        /// <summary>
        /// 尾节点
        /// </summary>
        private Node<T> LastNode;

        /// <summary>
        /// 判断当前链表是否为空链表
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return HeadNode == null;
        }

        /// <summary>
        /// 新增节点
        /// </summary>
        public void AddNode(T item)
        {
            // 新建一个节点
            Node<T> newNode = new Node<T>(item);
           
            // 判断头节点是否为null,如果为null，那么新建的节点就是头节点，同时也是尾节点
            if (IsEmpty())
            {
                // 如果是空链表，则将头节点和尾节点都指向新建的节点
                HeadNode = newNode;
                LastNode = newNode;
            }
            else
            {
                // 尾节点的指针指向新建的节点
                // 新建的节点变为尾节点
                LastNode.Next = newNode;
                LastNode = newNode;
            }
            // 将新建的节点添加到集合中
            ListNode.Add(newNode);
        }

        /// <summary>
        /// 插入节点
        /// </summary>
        /// <param name="item">要插入的节点的值</param>
        /// <param name="index">要插入节点的位置</param>
        public void InsertNode(T item,int index)
        {
            // 创建新的节点
            Node<T> newNode = new Node<T>(item);
            //Node<T> tmpNode = new Node<T>(item);

            // 判断当前链表是否为空链表
            if(IsEmpty())
            {
                HeadNode = newNode;
                LastNode = newNode;
            }
            else
            {
                // 插入第一个节点
                if(index==0)
                {
                    // 新节点执行现在的头节点
                    newNode.Next = HeadNode;
                    // 新节点变为新的头节点
                    HeadNode = newNode;
                }
                else if(index==GetLinkedListLength()-1)
                {
                    // 插入尾节点
                    // 定义一个临时节点tempNode指向HeadNode
                    Node<T> tempNode = HeadNode;
                    // 循环找到尾节点
                    while(true)
                    {
                        // 如果tempNode的next不为null，说明当前节点不是尾节点，则后移
                        if(tempNode.Next!=null)
                        {
                            // 当前tempNode后移
                            tempNode = tempNode.Next;
                        }
                        else
                        {
                            // tempNode的next为null，说明tempNode节点是尾节点，则退出循环
                            break;
                        }
                    }
                    // tempNode是尾节点，则将尾节点的next指向新的节点
                    tempNode.Next = newNode;
                }
                else
                {
                    #region 插入中间位置
                    // 定义临时节点指向头节点
                    Node<T> tempNode = HeadNode;
                    // 经过index-1次循环后移，tempNode移动到要插入位置的前一个节点
                    for (int i = 0; i <=index-1; i++)
                    {
                        // tempNode节点每次后移一个位置
                        tempNode = tempNode.Next;
                    }
                    // 要插入位置的前一个节点
                    Node<T> preNode = tempNode;
                    // 要插入位置的节点
                    Node<T> currentNode = preNode.Next;
                    // 修改next指向，前一个节点指向新节点
                    preNode.Next = newNode;
                    // 新节点指向当前位置的节点
                    newNode.Next = currentNode;
                    #endregion
                }
            }
        }

        /// <summary>
        /// 获取链表长度
        /// </summary>
        /// <returns></returns>
        public int GetLinkedListLength()
        {
            // 长度
            int length = 0;
            if(HeadNode==null)
            {
                length = 0;
            }
            else
            {
                Node<T> tempNode = HeadNode;
                // 循环
                while(true)
                {
                    if(tempNode.Next!=null)
                    {
                        // 当前临时节点后移到下一个节点
                        tempNode = tempNode.Next;
                        // 长度自增
                        length++;
                    }
                    else
                    {
                        // 说明循环到了尾节点，退出循环
                        length++;
                        break;
                    }
                }
            }
            return length;
        }

        /// <summary>
        /// 打印
        /// </summary>
        public void Print()
        {
            //StudentNode current = HeadNode;
            //while (current != null)
            //{
            //    Console.WriteLine("[" + current.Number + " " + current.Name + " " + current.Score + "]");
            //    current = current.Next;
            //}

            Node<T> current = HeadNode;
            while (current != null)
            {
                Console.Write( current.Data+"  ");
                current = current.Next;
            }
            Console.WriteLine();
        }
    }
}

Main方法中调用：

using System;
using System.Collections.Generic;

namespace SingleLinkedListDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 创建一个单向链表
            //int num;
            //string name;
            //int score;

            //Console.WriteLine("请输入5位学生的成绩:");
            //SingleLinkedList<Student> linkedList = new SingleLinkedList<Student>();
            //for (int i = 0; i < 5; i++)
            //{
            //    Console.Write("请输入学号：");
            //    num = int.Parse(Console.ReadLine());
            //    Console.Write("请输入姓名：");
            //    name = Console.ReadLine();
            //    Console.Write("请输入成绩：");
            //    score = int.Parse(Console.ReadLine());
            //    Student student = new Student(number: num, name: name, score: score);
            //    linkedList.AddNode(student);
            //    Console.WriteLine("----------------");
            //}

            //Console.WriteLine();
            //Console.WriteLine("输出学生成绩信息");
            //List<Node<Student>> list = linkedList.ListNode;
            //foreach (var item in list)
            //{
            //    Console.WriteLine($"学号： {item.Data.Number},姓名： {item.Data.Name},成绩： {item.Data.Score}");
            //    Console.WriteLine();
            //} 
            #endregion

            #region 删除单向链表中的节点
            //Random rand = new Random();
            //StudentLinkedList list = new StudentLinkedList();
            //int i, j, findword = 0;
            //int[,] data = new int[12, 10];
            //String[] name = new String[] { "Allen", "Scott",
            //    "Marry", "Jon", "Mark", "Ricky", "Lisa",
            //    "Jasica", "Hanson", "Amy", "Bob", "Jack" };
            //Console.WriteLine("学号 成绩  学号 成绩  学号 成绩  学号  成绩");
            //// 链表里面添加12个节点
            //for (i = 0; i < 12; i++)
            //{
            //    data[i, 0] = i + 1;
            //    data[i, 1] = (Math.Abs(rand.Next(50))) + 50;
            //    StudentNode node = new StudentNode(data[i, 0], name[i], data[i, 1]);
            //    list.AddNode(node);
            //}
            //// 分三行输出
            //for (i = 0; i < 3; i++)
            //{
            //    for (j = 0; j < 4; j++)
            //        Console.Write("[" + data[j * 3 + i, 0] + "]  [" + data[j * 3 + i, 1] + "]  ");
            //    Console.WriteLine();
            //}
            //while (true)
            //{
            //    Console.Write("请输入要删除成绩的学生学号，结束输入-1： ");
            //    findword = int.Parse(Console.ReadLine());
            //    if (findword == -1)
            //        break;
            //    else
            //    {
            //        StudentNode current = new StudentNode(list.HeadNode.Number, list.HeadNode.Name, list.HeadNode.Score);
            //        current.Next = list.HeadNode.Next;
            //        while (current.Number != findword) current = current.Next;
            //        list.DeleteNode(current);
            //    }
            //    Console.WriteLine("删除后成绩的链表，请注意！要删除的成绩其学生的学号必须在此链表中
");
            //    list.Print();
            //}
            #endregion

            #region 单向链表中插入节点
            SingleLinkedList<int> linkedList = new SingleLinkedList<int>();
            linkedList.AddNode(1);
            linkedList.AddNode(45);
            linkedList.AddNode(56);
            linkedList.AddNode(389);
            List<Node<int>> list = linkedList.ListNode;
            Console.WriteLine("插入前链表元素");
            linkedList.Print();
            Console.WriteLine();
            // 插入头节点之前
            linkedList.InsertNode(57, 0);
            Console.WriteLine("插入头节点后链表元素");
            linkedList.Print();
            Console.WriteLine();
            // 插入尾节点之后
            linkedList.InsertNode(123, linkedList.GetLinkedListLength()-1);
            Console.WriteLine("插入尾节点后链表元素");
            linkedList.Print();
            Console.WriteLine();
            // 插入中间节点
            int index= new Random().Next(0, linkedList.GetLinkedListLength() - 1);
            linkedList.InsertNode(935, index);
            Console.WriteLine("插入中间节点后链表元素");
            linkedList.Print();
            Console.WriteLine();
            #endregion
            Console.ReadKey();
        }
    }
}

程序运行结果：

GitHub地址：git@github.com:JiangXiaoLiang1988/SingleLinkedList.git