线性链表

线性链表的基本操作，代码如下：

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

namespace ConsoleApp7
{
    class Program
    {
        static void Main(string[] args)
        {


            {
                LinearList list = new LinearList(10);
                ILinearList line = list;
                line.Add(0, 12);
                line.Add(1, 20);
                line.Add(2, 4);
                line.Add(3, 9);
                Console.WriteLine("数组大小size: {0}", line.Size());
                Console.WriteLine("数组长度length: {0}", list.sList.Length);
                Console.WriteLine(line.Get(0));
                Console.WriteLine(line.Get(1));
                Console.WriteLine(line.Get(2));
                Console.WriteLine(line.Get(3));

                Console.WriteLine("排序后的数组为:");
                for (int i = 0; i < line.Size(); i++)
                {
                    Sort(line, i);
                }
                foreach (var item in list.sList)
                {
                    Console.Write(item + "  ");
                }
            }
           
            Console.Read();
        }

        static ILinearList Sort(ILinearList ST, int placeNum)
        {
            if (placeNum < 0 || placeNum >= ST.Size())
            {
                return ST;
            }
            int j = (int)ST.Get(placeNum);   //一轮排序中找到的最小元素
            int element = (int)ST.Get(placeNum); //要排序元素
            int elemplace = placeNum;     //要排序元素最终要放置的位置
            //12,20,4,9
            for (int i = placeNum + 1; i < ST.Size(); i++)
            {
                if (j > (int)ST.Get(i))
                {
                    j = (int)ST.Get(i);
                    elemplace = i;
                }
            }
            if (elemplace != 0)
            {
                ST.Set(placeNum, j);
                ST.Set(elemplace, element);
            }
            return ST;
        }
    }



    interface ILinearList
    {
        /// <summary>
        /// 是否为空
        /// </summary>
        /// <returns></returns>
        bool IsEmpty();
        /// <summary>
        /// 大小
        /// </summary>
        /// <returns></returns>
        int Size();
        /// <summary>
        /// 获取元素
        /// </summary>
        /// <param name="index">待获取的索引</param>
        /// <returns></returns>
        object Get(int index);
        /// <summary>
        /// 设置元素
        /// </summary>
        /// <param name="index">待获取的索引</param>
        /// <param name="elem">待设置的元素</param>
        /// <returns></returns>
        object Set(int index, object elem);
        /// <summary>
        /// 添加元素
        /// </summary>
        /// <param name="index">待添加的位置</param>
        /// <param name="elem">待添加的元素</param>
        /// <returns></returns>
        bool Add(int index, object elem);
        /// <summary>
        /// 移除元素
        /// </summary>
        /// <param name="index">待移除的索引</param>
        /// <returns></returns>
        Object Remove(int index);
        /// <summary>
        /// 清除所有元素
        /// </summary>
        void Clear();
    }

    internal class LinearList : ILinearList
    {
        public object[] sList = null;
        private const int defaultCapacity = 10;       // 数组容量
        private int size = 0;         //数组实际存储大小
        public LinearList(int capacity)
        {
            if (capacity <= 0)
            {
                sList = new object[defaultCapacity];
            }
            else
            {
                sList = new object[capacity];
            }

            this.size = 0;
        }
        public bool Add(int index, object elem)
        {

            //索引大于数组的长度，还是数组的容量
            //元素后移，插入
            if (index < 0 || index > size)
            {
                throw new Exception("插入位置有误");
            }
            //从新分配空间
            if (size == sList.Length)
            {
                object[] temp = sList;
                sList = new object[size * 2];
                for (int i = 0; i < temp.Length; i++)
                {
                    sList[i] = temp[i];
                }
            }
            //分析：1,2,3,4,5    长度为5的数组 , size = 5，  待插入数值为10 插入索引index = 2  插入后的值为   1，2，10，3，4,5     
            //首先移动index = size - 1 最后一位，以此从最后一位到index这个位置 
            for (int j = size - 1; j >= index; j--)
            {
                sList[j + 1] = sList[j];
            }
            sList[index] = elem;
            size++;
            return true;

        }

        public void Clear()
        {
            for (int i = 0; i < sList.Length; i++)
            {
                sList[i] = null;
            }
            size = 0;
        }

        public object Get(int index)
        {
            ThrowExe(index);
            return sList[index];
        }


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

        public object Remove(int index)
        {
            //1,2,3,4,5    index = 2   移除值为3的元素，后面的元素 4，5前移
            ThrowExe(index);
            object removeNumber = sList[index];

            for (int i = index; i < sList.Length - 1; i++)
            {
                sList[i] = sList[i + 1];
            }
            sList[size - 1] = null;
            size--;
            return removeNumber;
        }

        public object Set(int index, object elem)
        {
            ThrowExe(index);

            var old = sList[index];
            sList[index] = elem;
            return old;
        }

        public int Size()
        {
            return size;
        }

        public bool RangeCheck(int index)
        {
            if (index < 0 || index >= size)
            {
                return false;
            }
            return true;
        }

        private void ThrowExe(int index)
        {
            if (!RangeCheck(index))
            {
                throw new Exception("参数不合法");
            }
        }

    }


    /// <summary>
    /// 结点类
    /// </summary>
    class Node
    {
        public object nodeValue;
        public Node next;
        public Node()
        {
            nodeValue = null;
            next = null;
        }

        public Node(object nodeValue)
        {
            this.nodeValue = nodeValue;
            next = null;
        }
        public Node(object nodeValue, Node next)
        {
            this.nodeValue = nodeValue;
            this.next = next;
        }
    }

    class SingleLinkedList:ILinearList
    {
        public Node Head { get; set; }       //单链表
        public SingleLinkedList() { 
        
        }

        public SingleLinkedList(Node head)
        {
            this.Head = head;
        }

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

        public int Size()
        {
            int size = 0;
            Node p = Head;
            while (p != null)
            {
                size++;
                p = p.next;
            }
            return size;
        }

        public object Get(int index)
        {
            ILinearList list = this;
            if(index < 0 || index > list.Size() - 1)
            {
                throw new IndexOutOfRangeException("索引越界!");
            }
            Node p = Head;
            for (int i = 0; i < index; i++)
            {
                p = p.next;
            }
            return p.nodeValue;
        }

        public object Set(int index, object elem)
        {
            ILinearList list = this;
            if (index < 0 || index > list.Size() - 1)
            {
                throw new IndexOutOfRangeException("索引越界!");
            }
            Node p = Head;
            for (int i = 0; i < index; i++)
            {
                p = p.next;
            }
            object oldValue = p.nodeValue;
            p.nodeValue = elem;
            return oldValue;
        }

        public bool Add(int index, object elem)
        {
            ILinearList list = this;
            if (index < 0 || index > list.Size())
            {
                throw new IndexOutOfRangeException("索引越界!");
            }

            if(Head == null)
            {
                Head = new Node(elem);
            }
            else
            {
                Node p = Head;
                for (int i = 0; i < index - 1; i++)
                {
                    p = p.next;
                }
                p.next = new Node(elem,p.next);
            }
            return true;
        }

        public object Remove(int index)
        {
            object oldValue = null;
            if(index >=0 && Head != null)
            {
                if(index == 0)
                {
                    oldValue = Head.nodeValue;
                    Head = Head.next;
                }
                else
                {
                    Node p = Head;
                    for (int i = 0; i < index - 1 && p.next != null; i++)
                    {
                        p = p.next;
                    }
                    if (p.next != null)
                    {
                        oldValue = p.next.nodeValue;
                        p.next = p.next.next;
                    }
                }
                
            }
            return oldValue;
        }

        public void Clear()
        {
            Head = null;
        }
    }
}