第五节：链表剖析及自己手撸"单链表"实现基本操作(初始化、增、删、改等)

一. 基础

1. 前言

　　链式存储结构，又叫链表，逻辑上相邻，但是物理位置可以不相邻，因此对链表进行插入和删除时不需要移动数据元素，但是存取数据的效率却很低，分为三类：

(1).单(向)链表：存储数据元素时，除了存储数据元素本身的信息外，还有一个指针，指向他的后继节点，最后一个元素的指针不指向任何元素。

【C#中的代表：ListDictionary，基本上已经被弃用了，官方称建议存10个元素以下，很鸡肋】

(2).双(向)链表：在单链表的基础上加一个前驱指针，指向前一个元素，是链表可以双向查找，这种结构成为双链表。

【C#中的代表：LinkedList<T>】

 

 

 

 

(3).循环链表：将链表最后一个节点的指针指向第一个节点，这样就形成了一个环，这种数据结构叫做单向循环列表.另外还有双向循环列表.

PS：循环链表结构中从表的任一节点出发均可以找到表中的其他节点如果从表头节点出发，访问链表的最后一个节点，必须扫描表中所有节点。若循环链表的头指 针改用尾指针代替，则从尾指针出发不仅可以立即访问到最后一个节点，而且十分方便的找到第一个节点。

2. LinkedList<T>核心分析

　　首先LinkedList是一个双向链表!!,节点的存储类型为LinkedListNode<T>,可以通过node.Next和node.Previous获取下一个节点或前一个节点，添加节点的时候主要是基于 一个节点往前加或者往后加（AddBefore，AddAfter）.

(1).增加：AddFirst、AddLast、AddBefore、AddAfter

(2).删除：Remove、RemoveFirst、RemoveLast; 其中Remove是根据值反删节点(内部循环,慢啊)，也可以查出节点进行删除

(3).修改： node.Value = xxx;

(4).查询：

　　A. 获取第1个/最后一个节点：First 、Last (.Value 就获取值了)

　　B. 根据值反查节点： Find、FindLast (内部遍历，慢啊,链表的通病,查询慢)

　　C. 获取下一个节点: node.Next (node.Next.Value; 获取值了)

　　D. 获取前一个节点: node.Previous (node.Previous.Value; 获取值了)

　　E. 输出所有值: Foreach

(5).其它：Contains、Count

代码分享：

{
                LinkedList<int> list1 = new LinkedList<int>();
                list1.AddFirst(1);
                list1.AddLast(10);
                //找到节点
                LinkedListNode<int> node1 = list1.Find(10);
                Console.WriteLine($"node1的节点的值为:{node1.Value}");
                list1.AddBefore(node1, 9);
                list1.AddAfter(node1, 11);

                //此时在获取node1的前一个节点和后一个节点
                var node1Pre = node1.Previous;
                Console.WriteLine($"node1的前一个节点的值为:{node1Pre.Value}");
                var node1Next = node1.Next;
                Console.WriteLine($"node1的的后一个节点的值为:{node1Next.Value}");

                //修改节点的值
                node1Next.Value = 111;

                //继续增加
                list1.AddLast(14);
                list1.AddLast(15);
                list1.AddLast(16);
                list1.AddLast(17);
                list1.AddLast(18);

                //删除节点
                list1.Remove(16);
                var dNode = list1.Find(17);
                list1.Remove(dNode);
                //删除最后一个节点
                list1.RemoveLast();

                Console.WriteLine("全部输出");
                foreach (var item in list1)
                {
                    Console.WriteLine(item);
                }
            }

运行结果：

 

 

二. 提高

1.手撸单链表

　(1).首先要有一个节点类Node,需要能记录该节点的值Data,并且根据该节点能获取下一个节点Next.实例化的时候可以传值,也可以不传值

　(2).要有一个头结点作为基础、节点的个数;实例化的时候可以传值,也可以不传值.

　(3).先要编写一个方法GetNodeByIndex，根据索引来获取节点，实质上只能遍历，其它方法基本上都要基于它.

　(4).然后实现Add、Insert、RemoveAt、this[int index]、ToString等方法,需要注意的是越界问题、index=0问题、头结点为空的问题.

最终达到：获取一个节点，可以通过Data获取节点值，通过Next获取下一个节点,然后可以增删改查.

PS：单链表也好，双链表也罢，只要不是循环列表，尾节点的指针都是指向null.

Node节点代码

    /// <summary>
    /// 节点类
    /// </summary>
    public class Node<T>
    {
        public T _data;  // 存放节点数据
        public Node<T> _next; //存放下一个节点

        public Node()
        {

        }
        public Node(T data)
        {
            _data = data;
        }

        /// <summary>
        /// 数据的输出
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return _data.ToString();
        }

        //当前节点的数据
        public T Data
        {
            get
            {
                return _data;
            }
            set
            {
                _data = value;
            }
        }
        //下一个节点
        public Node<T> Next
        {
            get
            {
                return _next;
            }
            set
            {
                _next = value;
            }
        }
    }

单链表代码

/// <summary>
    /// 手写单链表
    /// </summary>
    public class MySingleLinkedList<T>
    {
        private Node<T> _header;  //头结点
        private int _count;  //元素个数
        public MySingleLinkedList()
        {

        }
        public MySingleLinkedList(T data)
        {
            _header = new Node<T>(data);
            _count++;
        }
        //只能读
        public int Count
        {
            get
            {
                return _count;
            }       
        }
        /// <summary>
        /// 根据索引获取元素
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public Node<T> GetNodeByIndex(int index)
        {
            if (index < 0 || index>=_count)
            {
                throw new ArgumentOutOfRangeException("索引越界");
            }
            Node<T> tempNode = _header;
            //当index为0的时候，不进入for循环
            for (int i = 0; i < index; i++)
            {
                tempNode = tempNode.Next;
            }
            return tempNode;
        }

        //索引器获取和设置数据
        public T this[int index]
        {
            get
            {
                return GetNodeByIndex(index).Data;
            }
            set
            {
                GetNodeByIndex(index).Data = value;
            }
        }

        /// <summary>
        /// 添加元素(最后)
        /// </summary>
        /// <param name="data"></param>
        public void Add(T data)
        {
            Node<T> newNode = new Node<T>(data);
            if (_header==null)  //表示添加的是第一个节点
            {
                _header = newNode;
            }
            else
            {
                var lastNode = GetNodeByIndex(_count - 1);
                lastNode.Next = newNode;
            }       
            _count++;
        }

        /// <summary>
        /// 插入元素
        /// </summary>
        /// <param name="index">索引</param>
        /// <param name="data">数据</param>
        public void Insert(int index,T data)
        {
            if (index < 0||index>_count)
            {
                throw new ArgumentOutOfRangeException("索引越界");
            }
            var newNode = new Node<T>(data); //新节点
            if (index==0)
            {
                //头结点为空，直接插入头结点即可
                if (_header==null)
                {
                    _header = newNode;
                }
                //头结点有元素，需要把头结点的位置让出来
                else
                {
                    newNode.Next = _header;
                    _header = newNode;
                }
            }
            else
            {
                var preNode = GetNodeByIndex(index-1);  //查找插入位置的前驱节点
                var nextNode = preNode.Next;            //插入位置的后继节点
                preNode.Next = newNode;        //前驱结点的后继节点为新节点
                newNode.Next = nextNode;       //新节点的后继节点执行原来前驱的后继
            }
            _count++;             
        }

        /// <summary>
        /// 根据索引删除元素
        /// </summary>
        /// <param name="index">索引</param>
        public void RemoveAt(int index)
        {
            if (index < 0 || index >= _count)
            {
                throw new ArgumentOutOfRangeException("索引越界");
            }
            if (index==0)  //删除头结点
            {
                if (_header==null)
                {
                    throw new ArgumentOutOfRangeException("索引越界");
                }
                _header = _header.Next;
            }
            else
            {
                var preNode = GetNodeByIndex(index - 1); //删除节点的前驱节点
                if (preNode.Next==null)
                {
                    throw new ArgumentOutOfRangeException("索引越界");
                }
                preNode.Next = preNode.Next.Next;     //如果删除的是最后一个节点，那么它的前一个节点指向null
            }
            _count--;
        }
        /// <summary>
        /// 元素输出
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            string s = "";
            Node<T> temp = _header;
            while (temp != null)
            {
                s += temp.ToString() + " ";
                temp = temp.Next;
            }
            return s;
        }

    }

测试代码

            {
                Console.WriteLine("--------------------------手撸单链表测试---------------------------");
                MySingleLinkedList<int> mlist = new MySingleLinkedList<int>();
                mlist.Add(0);
                mlist.Add(1);
                mlist.Add(3);
                mlist.Add(4);
                mlist.Add(5);
                mlist.Add(6);
                mlist.Insert(0, 100);
                Console.WriteLine(mlist.ToString());
                mlist.RemoveAt(4);
                mlist[1] = 999;
                Console.WriteLine(mlist.ToString());
                for (int i = 0; i < mlist.Count; i++)
                {
                    Console.WriteLine(mlist[i]);
                }
                mlist.Insert(5, 555);
                Console.WriteLine(mlist.ToString());
                mlist.RemoveAt(0);
                Console.WriteLine(mlist.ToString());
            }

运行结果

 

2.链表优缺点

优点

　　(1).需要空间就申请，不需要就释放，空间有效利用。

　　(2).插入和删除只需要修改几个指针，方便快捷。

　　(3).双链表双向搜索，简化算法复杂度。

缺点

　　(1).算法实现复杂抽象,需要额外内存空间保存节点的逻辑关系。

　　(2).只能顺序访问，访问速度慢。

　　(3).可能会把节点存放到托管堆的任意角落，垃圾回收需要更多开销。

 

 

 

 

 

!

• 作       者 : Yaopengfei(姚鹏飞)
• 博客地址 : http://www.cnblogs.com/yaopengfei/
• 声     明1 : 如有错误，欢迎讨论，请勿谩骂^_^。
• 声     明2 : 原创博客请在转载时保留原文链接或在文章开头加上本人博客地址，否则保留追究法律责任的权利。