C#实现单链表

【前置知识】

数据结构之链表

泛型

接口

类（属性、对C#构造器的理解）

（有了这些知识，代码很快就能看懂，这些知识不熟的话，要看好久）

【节点的构成】

新建一个类，用于存放节点类

namespace SingleLinkedList
{
    /// <summary>
    /// 单链表的节点
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class Node<T>
    {
        #region 节点的构成、属性
        private T data;//存储数据
        private Node<T> nextNode;//指针，指向下一个元素，存储了下一个节点的位置

        public T Data
        {
            get { return data; }
            set { data = value; }
        }

        public Node<T> NextNode
        {
            get { return nextNode; }
            set { nextNode = value; }
        } 
        #endregion

        #region 节点的构造器
        public Node()
        {
            data = default(T);
            nextNode = null;
        }

        //构造器重载
        public Node(T value)
        {
            data = value;
            nextNode = null;
        }

        public Node(Node<T> next)
        {
            nextNode = next;
        }
        
        //构造器链
        public Node(T value, Node<T> next):this(value)
        {
            nextNode = next;
        }
        #endregion

  
    }
}

【接口方法】

新建一个接口，规定单链表应该具有的方法

namespace SingleLinkedList
{
    interface IOperationMethod<T>
    {
        T this[int index] { get; }//重载“[]”操作符
        int GetLength();
        void Clear();
        bool IsEmpty();
        void Add(T element);
        void Insert(T element, int index);
        T Remove(int index);
        int Find(T element);
        void Sort();
    }
}

【单链表类】

新建一个类，用于存放单链表类，并实现接口方法

using System;

namespace SingleLinkedList
{
    class SLinkedList<T>:IOperationMethod<T>
    {
        private Node<T> header;
        private int count;

        public SLinkedList() 
        {
            header=new Node<T>();//创建头节点
            count = 0;
        } 

        #region 接口方法
        public T this[int index]
        {
            get
            {
                Node<T> temp = header;
                for (int i = 0; i <= index; i++)
                {
                    temp = temp.NextNode;
                }
                return temp.Data;
            }
        }

        public int GetLength()
        {
            return count;
        }

        public void Clear()
        {
            header = null;
            count = 0;
        }

        public bool IsEmpty()
        {
            return count == 0;
        }

        public void Add(T element)
        {
            Node<T> newNode=new Node<T>(element);//根据数据创建新的节点
            //如果头节点为空，则新节点为头节点
            if (header == null)
            {
                header = newNode;
            }
            else
            {//把新的节点放在末节点之后
                Node<T> temp = header;
                //访问到链表的末节点
                while (true)
                {
                    if (temp.NextNode != null)
                        temp = temp.NextNode;
                    else
                    {
                        break;
                    }
                }
                temp.NextNode = newNode;
            }
            count++;
        }

        public void Insert(T element, int index)
        {
            if(index>=count||index<0)
                return;
            Node<T> newNode=new Node<T>(element);
            Node<T> tempNode = header;
            for (int i = 0; i < index; i++)//获取index所对应节点的上一个节点
            {
                tempNode = tempNode.NextNode;
            }
            Node<T> indexNode = tempNode.NextNode;//index所对应的节点
            tempNode.NextNode = newNode;//temp节点的下一个节点为新节点
            newNode.NextNode = indexNode;//新节点的下一个节点为index节点
            count++;
        }

        public T Remove(int index)
        {
            T data = default(T);
            if (index >= count || index < 0)
                return data;

            Node<T> tempNode = header;
            for (int i = 0; i < index; i++)
            {
                tempNode = tempNode.NextNode;
            }
            data = tempNode.NextNode.Data;
            count--;
            if (index == count - 1)//考虑特殊情况，这种情况也可以省略
            {              
                tempNode.NextNode = null;
            }
            else
            {                
                Node<T> afterNode = tempNode.NextNode.NextNode;
                tempNode.NextNode = afterNode;
            }
            return data;

        }

        public int Find(T element)
        {
            int index = -1;
            Node<T> tempNode = header;
            for (int i = 0; i < count; i++)
            {
                tempNode = tempNode.NextNode;
                if (tempNode.Data.Equals(element))
                {
                    index = i;
                    break;
                }
            }
            return index;
        }

        public void Sort()
        {
            throw new NotImplementedException();
        }
#endregion
    }
}

【测试】

using System;
using System.Collections.Generic;

namespace SingleLinkedList
{
    class Program
    {
        static void Main(string[] args)
        {
            SLinkedList<int> sLinkedList=new SLinkedList<int>();
            int[] A=new int[20];
            Random ra=new Random();
            for (int i = 0; i < 20; i++)
            {
                int temp =  ra.Next(100);
                A[i] = temp;
                sLinkedList.Add(temp);
            }
            Console.WriteLine("单链表的结果:");
            sLinkedList.Insert(100,3);
            sLinkedList.Remove(20);
            int index= sLinkedList.Find(88);
            for (int i = 0; i < sLinkedList.GetLength(); i++)
            {
                Console.Write(sLinkedList[i]+" ");
            }
            Console.WriteLine("查找结果："+index);
            Console.WriteLine("对比数组的结果:");
            for (int i = 0; i < A.Length; i++)
            {
                Console.Write(A[i] + " ");
            }
            Console.ReadKey();
            
           
        }
    }
}

【输出结果】