数据结构(2):链表

在上一篇文章中，实现线性表中的顺序表，对于插入、删除操作比较频繁的数据来说，用顺序表就不是很经济了，这时候链表就排上用场
在C#中，直接使用指针来进行操作是比较麻烦的，不过引用可以在相当程度上代替指针，这也是C#中实现链表最简单的方法。
首先，使用引用来实现链表，通过两个类来实现的，一个事节点类，一个是链表类。主要实现了向末尾添加节点、指定位置插入节点、删除节点这些操作。

  class RefNode<T>  //节点类
    {
        public T data;
        public RefNode<T> Next;        

        public RefNode()
        {
            data = default(T);
            Next = null;
        }
        public RefNode(T dt)
        {
            data = dt;
            Next = null;
        }
    }
     class RefLinkList<T>
    {
        RefNode<T> HeadNode;
        public int Length;
        public RefLinkList()
        {
            HeadNode = new RefNode<T>();
        }

        public void Add(RefNode<T> data)    //在末尾添加节点
        {
            Length++;          
            if (HeadNode.Next == null)          //若链表为空
            {
                HeadNode.Next = new RefNode<T>();
                HeadNode.Next = data;         
            }
            else
            {
                var p = HeadNode.Next;
                while (p.Next != null)
                {
                    p = p.Next;
                }
                p.Next = new RefNode<T>();
                p.Next = data;
            }
        }
        public bool Get(int index, out RefNode<T> tp)  //获取指定序号的节点
        {
            if(index > Length || index < 0)                         //若序号超出范围
            {
                Console.WriteLine("序号超出范围！");
                tp = null;
                return false;
            }
            var p = HeadNode;
            for(int i = 0; i < index; i++)
            {
                p = p.Next;
            }
            tp = p;
            return true;
        }
        public bool Insert(int index, RefNode<T> node)//在指定位置插入节点
        {
            if(index > Length || index <= 0)
            {
                Console.WriteLine("索引超出范围");
                return false;
            }
            var current = new RefNode<T>();
            Get(index - 1, out current);
            var temp = current.Next;
            current.Next = node;
            node.Next = new RefNode<T>();
            node.Next = temp;
            Length++;
            return true;
        }
        public bool Delete(int index) //删除指定位置的节点
        {          
            var p = new RefNode<T>();

            if (Get(index - 1, out p))
            {
                var tp = new RefNode<T>();
                Get(index, out tp);

                if (tp.Next == null)
                    p.Next = null;
                else
                    p.Next = tp.Next;

                Length--;
                return true;
            }
            else
                return false;

        }

        public void Show()//显示链表
        {
            var p = HeadNode.Next;
            Console.WriteLine("There are {0} elements in this  linklist.");
            if(p == null)
            {
                Console.WriteLine("This Link list is a void list;");
            }
            while(p != null)
            {
                Console.WriteLine(p.data);
                p = p.Next;
            }
        }

    }

下面我们使用指针来实现。使用指针主要注意两点，一是使用指针的地方要用unsafe进行标识；二是指针不能指向不能确定内存大小的泛型类型。为了使指针实现的链表具有通用性，需要使用using来创建别名。即：

using ElemType = System.Int32;  //这里可以根据需要进行更改
struct PtrNode  //通过指针实现的链表
    {
        ElemType data;
        unsafe PtrNode* Next;       
    }

其余操作与引用是相似的，这里就不多说了。
最后，来讲讲静态链表。静态链表是没有指针的高级语言，为了获得链表的便利而想出的实现方法。这种方法有两个数据域，一个用于存储数据，一个用于描述下个节点的位置。描述节点位置的数据称为游标，这种方法又称为游标实现法。这里有两个特殊节点，第一个节点和最后一个节点（注意：不是链表的尾节点），这两个节点不存储数据。第一个节点的游标描述备用空间的第一个节点的位置，最后一个节点的游标存储链表第一个节点的位置。链表的尾节点的游标为0。具体实现如下：

class StaticNode<T> //静态链表节点
    {
        public T data;
        public int cur;
        public bool IsEnd;
        public StaticNode()
        {
            data = default(T);
            cur = 0;
            IsEnd = false;
        }
    }
 class StaticLinkList<T>
    {
        const int MaxSize = 1000;
        private int length;
        public StaticNode<T>[] Data;

        public StaticLinkList()
        {
            Data = new StaticNode<T>[MaxSize];
            for (int i = 0; i < MaxSize; i++)
                Data[i] = new StaticNode<T>();
            for (int i = 0; i < MaxSize - 1; i++)
                Data[i].cur = i + 1;
            Data[MaxSize -1 ].cur = 0;                  //目前静态链表为空
            length = 0;
        }

        public int GetLocation(int index)  //得到第index个元素的位置
        {
            if (index > length || index <= 0)//序号超出范围或序号为零
            {
                Console.WriteLine("序号为零或序号大于链表长度！");
                return 0;
            }
            int i = Data[MaxSize - 1].cur;
            int count = 1;
            while(count < index)
            {
                count++;
                i = Data[i].cur;
            }
            return i;
        }

        public bool Add(T Elem)   //向表尾添加数据
        {
            if (Data[0].cur == MaxSize - 1)  //若链表已满
                return false;
            if (Data[MaxSize - 1].cur == 0)  //若插入的是第一个节点，则更新第一个节点的值
                Data[MaxSize - 1].cur = 1;
            int i = Data[0].cur;
            int prior = 0;          
            Data[i].data = Elem;       
            Data[0].cur = Data[i].cur;
            if (length >= 1)
            {
                prior = GetLocation(length);
                Data[prior].cur = i;
            }
            Data[i].cur = 0;
            length++;
            return true;
        }
        public bool Insert(T Elem, int index) //在第index个位置上插入
        {
            if(index <= 0 || index > length)
            {
                Console.WriteLine("索引超出范围！");
                return false;
            }
            if (length >= MaxSize - 2)
            {
                Console.WriteLine("链表已满！");
                return false;
            }
            int tp = GetLocation(index);
            int j = Data[0].cur;
            Data[0].cur = Data[j].cur;
            Data[j].data = Elem;
            Data[j].cur = tp;
            if(index != 1)                   //若插入位置不是第一个节点
            {
                int prior = GetLocation(index - 1);
                Data[prior].cur = j;
            }
            else
            {
                Data[MaxSize - 1].cur = j;           //插入位置是第一个节点
            }
            length++;
            return true;

        }
        public bool Delete(int index) //删除第index个元素
        {
            if(index > length || index <= 0)
            {
                Console.WriteLine("索引超出范围！");
                return false;
            }
            if(index == 1)   //若删除的是第一个节点
            {
                int j = Data[MaxSize - 1].cur;
                Data[MaxSize - 1].cur = Data[j].cur;
                Data[j].cur = Data[0].cur;
                Data[0].cur = j;
                length--;
                return true;
            }
            else if(index == length) //若删除的是尾节点
            {
                int prior = GetLocation(index - 1);
                int tp = Data[prior].cur;
                Data[tp].cur = Data[0].cur;
                Data[0].cur = tp;
                Data[prior].cur = 0;
                length--;
                return true;
            }
            else
            {
                int prior = GetLocation(index - 1);
                int next = GetLocation(index + 1);
                int tp = Data[prior].cur;
                Data[tp].cur = Data[0].cur;
                Data[0].cur = tp;
                Data[prior].cur = next;
                length--;
                return true;
            }
        }

        public int Length()
        {
            return length;
        }

        public void Show()
        {
            Console.WriteLine("This list have {0} elements.", Length());
            int tp = Data[MaxSize - 1].cur;
            while(tp != 0)
            {
                Console.WriteLine(Data[tp].data);
                tp = Data[tp].cur;
            }
        }
    }