数据结构与算法之单链表

代码实现：

	internal interface ISingleLinkedList<T>
    {
        /// <summary>
        /// 获取单链表的长度
        /// </summary>
        /// <returns></returns>
        int GetLength();

        /// <summary>
        /// 清空单链表
        /// </summary>
        void Clear();

        /// <summary>
        /// 单链表是否为空
        /// </summary>
        /// <returns></returns>
        bool IsEmpty();

        /// <summary>
        /// 在单链表末尾追加节点
        /// </summary>
        /// <param name="item"></param>
        void Append(T item);

        /// <summary>
        /// 在指定位置添加节点
        /// </summary>
        /// <param name="item"></param>
        /// <param name="i"></param>
        void Insert(T item, int i);

        /// <summary>
        /// 删除指定位置的节点
        /// </summary>
        /// <param name="i"></param>
        void Delete(int i);

        /// <summary>
        /// 获取指定位置的节点
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        T GetElem(int i);
    }
    
    public class Node<T>
    {
        private T? data;

        /// <summary>
        /// 数据域
        /// </summary>
        public T? Data
        {
            get { return data; }
            set { data = value; }
        }

        private Node<T>? next;

        /// <summary>
        /// 指针域
        /// </summary>
        public Node<T>? Next
        {
            get { return next; }
            set { next = value; }
        }

        public Node()
        {
            data = default(T);
            next = null;
        }
        
        public Node(T data)
        {
            this.data = data;
        }

        public Node(Node<T> node)
        {
            next = node;
        }

        public Node(T data,Node<T> node)
        {
            this.data = data;
            next = node;
        }
    }

	internal class SingleLinkedList<T> : ISingleLinkedList<T>
    {
        private Node<T>? head;

        public Node<T>? Head
        {
            get { return head; }
            set { head = value; }
        }

        public void Append(T item)
        {
            Node<T> node = new Node<T>(item);
            if (head == null)
            {
                head = node;
                return;
            }
            Node<T>? buffer = head;

            while(buffer?.Next != null)
            {
                buffer = buffer?.Next;
            }

            buffer.Next = node;
        }

        public void Clear()
        {
            head = null;
        }

        public void Delete(int i)
        {
            if (head == null || this.GetLength() < i || i <= 0)
            {
                return;
            }

            if (i == 1)
            {
                head = head.Next;
                return;
            }

            int count = 1;
            Node<T> buffer = head;
            while (buffer.Next != null)
            {
                if (count == i - 1)
                {
                    buffer.Next = buffer.Next?.Next;
                    break;
                }
                count++;
                buffer = buffer.Next;
            }
        }

        public T GetElem(int i)
        {
            if (i <= 0 || i > GetLength())
            {
                return default(T);
            }
            Node<T>? buffer = head;
            while (true) 
            {
                i--;
                if (i <= 0)
                {
                    return buffer.Data;
                }
                buffer = buffer?.Next;
            }
            return default(T);
        }

        public int GetLength()
        {
            int count = 0;
            if (head == null)
            {
                return count;
            }
            count = 1;
            Node<T> buffer = head;
            while(buffer.Next != null)
            {
                buffer = buffer.Next;
                count++;
            }
            return count;
        }

        public void Insert(T item, int i)
        {
            if (i > GetLength() + 1 || i <= 0) 
            {
                return;
            }
            Node<T>? newNode = new Node<T>(item);

            if (i == 1)
            {
                newNode.Next = head;
                head = newNode;
                return;
            }
            Node<T>? buffer = head;
            Node<T>? buffer2;
            while(true)
            {
                i--;
                if (i <= 1)
                {
                    buffer2 = buffer.Next;
                    buffer.Next = newNode;
                    newNode.Next = buffer2;
                    break;
                }
                buffer = buffer.Next;
            }
        }

        public bool IsEmpty()
        {
            return head == null;
        }
    }