数据结构之基于无序链表的集合和映射

使用代码实现自定义的集合类

   #region 链表类
    public class MyLinkedList<T>
    {
        //当前链表类记录这个链表的头部类
        private Node head;
        //链表的节点数量
        private int N;
        public MyLinkedList()
        {
            N = 0;
            //因为一开始链表没有元素，所以头部节点指向空。
            head = null;
        }



        /// <summary>
        /// 链表节点数量
        /// </summary>
        public int Count
        {
            get { return N; }
        }
        /// <summary>
        /// 链表是否为空
        /// </summary>
        public bool IsEmpty
        {
            get { return N == 0; }
        }

        public void Add(int index, T e)
        {
            if (index < 0 || index > N)
            {
                throw new Exception("非法索引");
            }

            if (index == 0)
            {
                //新的头部节点
                //1:添加新节点
                //Node node = new Node(e);
                ////2：将新添加的头结点的箭头指向原先头结点
                //node.next = head;
                ////3：现在的头结点信息赋给类的头结点字段，记录下来。
                //head = node;
                //其实上面三步可以结合到一步中，
                head = new Node(e, head);
            }
            else
            {
                //添加非头部节点
                //1.需要找到插入位置的上一个节点，对于链表来说就要从头部节点开始一步一步的查找了
                Node pre = head;
                //一步一步遍历找到前一个节点信息
                for (int i = 0; i < index - 1; i++)
                {
                    pre = pre.next;
                }
                //1：将前一节点的下一节点信息赋值给当前节点对象的下一节点字段，目的是为了让当前节点能够链接到下一节点
                Node node = new Node(e);
                node.next = pre.next;
                //2：前一节点链接到新插入的节点 此时链表已经重新完成
                pre.next = node;
                //上面代码也可以合成一句
                //   pre.next = new Node(e, pre.next);

            }
            //链表的元素加一
            N++;
        }

        public void AddFirst(T e)
        {
            Add(0, e);
        }

        public void AddLast(T e)
        {
            Add(N, e);
        }

        /// <summary>
        /// 节点类  不让外部知道此类，设为私有
        /// </summary>
        private class Node
        {
            //当前节点
            public T e;
            //当前节点的下一节点
            public Node next;
            public Node(T e, Node next)
            {
                this.e = e;
                this.next = next;
            }
            public Node(T e)
            {
                this.e = e;
            }

        }


        public T Get(int index)
        {
            if (index < 0 || index >= N)
            {
                throw new Exception("非法索引");
            }

            Node currentNode = head;//从头结点开始查找
            for (int i = 0; i < index; i++)
            {
                currentNode = currentNode.next;
            }

            return currentNode.e;
        }


        public T GetFirst()
        {
            return Get(0);
        }
        public T GetLast()
        {
            return Get(N - 1);
        }

        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="index"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        public void Set(int index, T e)
        {
            if (index < 0 || index >= N)
            {
                throw new Exception("非法索引");
            }

            Node currentNode = head;//从头结点开始查找
            for (int i = 0; i < index; i++)
            {
                currentNode = currentNode.next;
            }

            currentNode.e = e; ;
        }
        /// <summary>
        /// 查找链表中是否存在此元素
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>
        public bool Contains(T e)
        {
            Node current = head;
            while (current != null)
            {
                if (current.e.Equals(e))
                {
                    return true;
                }

                current = current.next;
            }

            return false;
        }
        /// <summary>
        /// 可以重写tostring打印方法
        /// 打印出链表信息
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            StringBuilder stringBuilder = new StringBuilder();
            Node cur = head;
            while (cur != null)
            {
                stringBuilder.Append(cur.e + "->");
                cur = cur.next;
            }
            stringBuilder.Append("null");
            return stringBuilder.ToString();

        }

        #region 删除节点

        public T Remove(int index)
        {
            if (index < 0 || index > N)
            {
                throw new Exception("非法索引");
            }

            if (index == 0)
            {
                Node delNode = head;
                //直接将原头部节点指向的下一节点的信息存储到头部节点的字段上，直接这样就能删除原头部节点了
                head = delNode.next;
                N--;
                return delNode.e;
            }
            else
            {
                Node pre = head;
                //找到删除节点的前一节点信息
                for (int i = 0; i < index - 1; i++)
                {
                    pre = pre.next;
                }
                Node delNode = pre.next;
                //1：z将前一节点的指向做更改
                pre.next = delNode.next;
                N--;
                return delNode.e;
            }
        }

        public T RemoveFirst()
        {
            return Remove(N);
        }

        #endregion
        #region 删除节点  根据值节点查找

        public void Remove(T e)
        {
            if (head == null)
            {
                return;
            }

            if (head.e.Equals(e))
            {
                //删除的是头结点
                head = head.next;
                N--;
            }
            else
            {
                Node current = head;
                Node pre = null;
                while (current != null)
                {
                    if (current.e.Equals(e))
                    {
                        break;
                    }

                    pre = current;
                    current = current.next;

                }

                if (current != null)
                {
                    pre.next = current.next.next;
                    N--;
                }
            }

        }

        #endregion
    }
    #endregion

    interface ISet<E>
    {
        int Count { get; }
        bool IsEmpty { get; }
        void Add(E e);
        void Remove(E e);
        bool Contains(E e);

    }

  class LinkedListISet<E> : ISet<E>
    {
        private MyLinkedList<E> list;
        public LinkedListISet()
        {
            list = new MyLinkedList<E>();
        }



        public int Count { get { return list.Count} }
        public bool IsEmpty { get { return list.IsEmpty } }
        /// <summary>
        /// 基于无序链表的集合的添加方法
        /// </summary>
        /// <param name="e"></param>
        public void Add(E e)
        {
            if (!list.Contains(e))
            {
                list.AddFirst(e);
            }
        }

        public bool Contains(E e)
        {
            return list.Contains(e);
        }

        public void Remove(E e)
        {
            list.Remove(e);
        }
    }

测试代码：

class Program
    {
        static void Main(string[] args)
        { 
            //假设words包含了很多单词
            List<string> words = new List<string>();
            LinkedListISet<string> linkedListISet = new LinkedListISet<string>();
            foreach (var item in words)
            {
                linkedListISet.Add(item); 
            } 

           Console.WriteLine(); 
        }

    }

从上面代码能看出来这个性能是很慢的，因为每次添加的时候都要看一下这个单词是否已经包含了，每次看是否包含的时候都要从链表的头到尾遍历一次。可以使用映射解决问题。

下面创建一个自定义的字典类：

    

   interface IDictionary<Key, Value>
    {
        int Count { get; }
        bool IsEmpty { get; }
        void Add(Key key, Value value);
        void Remove(Key key);
        bool ContainsKey(Key key);
        Value Get(Key key);
        void Set(Key key, Value value);

    }







/// <summary>
    /// 具有键值的链表类
    /// </summary>
    /// <typeparam name="Key"></typeparam>
    /// <typeparam name="Value"></typeparam>
    class LinkedListKeyValue<Key, Value>
    {
        /// <summary>
        /// 节点
        /// </summary>
        private class Node
        {
            public Key key;
            public Value value;
            public Node next;
            public Node(Key key, Value value, Node next)
            {
                this.key = key;
                this.value = value;
                this.next = next;
            }
            /// <summary>
            /// 重写输出
            /// </summary>
            /// <returns></returns>
            public override string ToString()
            {
                return key.ToString() + ":" + value.ToString();
            }

        }

        private Node head;
        public int N;
        public LinkedListKeyValue()
        {
            head = null;
            N = 0;
        }

        public int Count { get { return N; } }
        public bool IsEmpty { get { return N == 0; } }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        private Node GetNode(Key key)
        {
            Node cur = head;
            while (cur != null)
            {
                if (cur.key.Equals(key))
                    return cur;

                cur = cur.next;
            }

            return null;
        }

        public void Add(Key key, Value value)
        {
            Node node = GetNode(key);
            if (node == null)
            {
                head = new Node(key, value, head);
            }

        }

        public bool Contains(Key key)
        {
            return GetNode(key) != null;
        }

        public Value Get(Key key)
        {
            Node node = GetNode(key);
            if (node == null)
            {
                throw new ArgumentException($"键{key}不存在");
            }
            else
            {
                return node.value;
            }

        }

        public void Set(Key key, Value value)
        {
            Node node = GetNode(key);
            if (node == null)
                throw new Exception();
            node.value = value;
        }
        public void Remove(Key key)
        {
            if (head == null)
            {
                return;
            }

            if (head.key.Equals(key))
            {
                //删除的是头结点
                head = head.next;
                N--;
            }
            else
            {
                Node current = head;
                Node pre = null;
                while (current != null)
                {
                    if (current.key.Equals(key))
                    {
                        break;
                    }

                    pre = current;
                    current = current.next;

                }

                if (current != null)
                {
                    pre.next = current.next.next;
                    N--;
                }
            }

        }

    }


    /// <summary>
    /// 实现自定义的字典类
    /// </summary>
    /// <typeparam name="Key"></typeparam>
    /// <typeparam name="Value"></typeparam>
    public class LinkedListDictionary<Key, Value> : IDictionary<Key, Value>
    {

        private LinkedListKeyValue<Key, Value> list;
        public LinkedListDictionary()
        {
            list = new LinkedListKeyValue<Key, Value>();
        }

        public int Count { get { return list.Count; } }

        public bool IsEmpty { get { return list.IsEmpty; } }

        public void Add(Key key, Value value)
        {
            list.Add(key, value);
        }

        public bool ContainsKey(Key key)
        {
            return list.Contains(key);
        }

        public Value Get(Key key)
        {
            return list.Get(key);
        }

        public void Remove(Key key)
        {
            list.Remove(key);
        }

        public void Set(Key key, Value value)
        {
            list.Set(key, value);
        }
    }

但是就算是这样性能还是很慢的，所以我们可以使用基于有序数组的集合和映射来解决这个问题，有时间再深入，简单来说就是查找元素这块是用二分查找算法实现的，所以比基于无序链表的集合和映射在查找元素方法上性能更强。