大话数据结构第三章线性表线性表的链式存储结构（附C#单链表实现）

最新推荐文章于 2021-04-27 11:10:40 发布

码农小飞飞

最新推荐文章于 2021-04-27 11:10:40 发布

阅读量256

点赞数

分类专栏：大话数据结构学习笔记

本文链接：https://blog.csdn.net/songhuanfei2017/article/details/107816715

版权

大话数据结构学习笔记专栏收录该内容

21 篇文章 1 订阅

订阅专栏

线性表的顺序存储结构，最大的缺点就是插入和删除时需要移动大量元素。

线性表链式存储结构定义

为了表示每个数据元素 $a_{i}$ 与其直接后继数据元素 $a_{i+1}$ 之间的逻辑关系，对数据元素 $a_{i}$ 来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置）。我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称做指针或链。这两部分信息组成数据元素 $a_{i}$ 的存储映像，称为结点（Node）。

n个结点（ $a_{i}$ 的存储映像）链结成一个链表，即为线性表（ $a_{1 }$ , $a_{2}$ ,..., $a_{n}$ ）的链式存储结构，因此链表的每个结点中只包含一个指针域，所以叫做单链表。

我们把链表中第一个结点的存储位置叫做头指针。

我们规定，线性链表的最后一个结点指针为“空”（通常用NULL或“^”符号表示）。

有时，为了方便操作，会在单链表的第一个结点前附设一个结点，称为头结点。头结点的数据域可以不存储任何信息，头结点的指针域存储指向第一个结点的指针。

头指针与头结点的异同

头指针：

①头指针是指向第一个结点的指针，若链表有头结点，则是指向头结点的指针。

②头指针具有标识作用，所以常用头指针冠以链表的名字。

③无论链表是否为空，头指针均不为空。头指针是链表的必要元素。

头结点：

①头结点是为了操作的统一和方便而设立的，放在第一元素的结点之前，其数据域一般无意义（也可存放链表的长度）。

②有了头结点，对在第一元素结点前插入结点和删除第一结点，其操作与其它结点的操作就统一了。

③头结点不一定是链表必须要素。

线性表链式存储结构代码描述

Node

结点由存放数据元素的数据域和存放后继结点地址的指针域组成。

单链表的读取（用C#的LinkedList实现的，为了举例）

获得链表第i个数据的算法思路：

①声明一个指针p指向链表的第一个结点，初始化j从1开始。

②当j>i时，就遍历链表，让p的指针向后移动，不断指向下一结点，j累加1。

③若到链表末尾p为空，则说明第i个结点不存在；

④否则查找成功，返回结点p的数据。

//--

单链表的插入与删除

单链表的插入

单链表第i个数据插入结点的算法思路：

①声明一个指针p指向链表头结点，初始化j从1开始。

②当j<i时，就遍历表，让p的指针向后移动，不断指向下一结点，j累加1。

③若到链表末尾p为空，则说明第i个结点不存在。

④否则查找不成功，在系统中生成一个空结点s。

⑤将数据元素e赋值给s->data。

⑥单链表的插入标准语句s->next=p->next;p->next=s。

//--

单链表的删除

单链表第i个数据删除结点的算法思路：

①声明一指针p指向链表头指针，初始化j从1开始。

②当j<i时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加1。

③若到链表末尾p为空，则说明第i个结点不存在。

④否则查找成功，将欲删除的结点p->next赋值给q。

⑤单链表的删除标准语句p->next=q->next。

⑥将q结点中的数据赋值给e，作为返回。

⑦释放q结点。

//--

单链表的整表创建

思路：

①声明一指针p和计数器变量。

②初始化一空链表L。

③让L的头结点的指针指向NULL，即建立一个带头结点的单链表。

④循环：

1.生成一新结点赋值给p；

2.随机生成一数字赋值给p数据域p->data；

3.将p插入到头结点与前一新结点之间。（头插法）

//--

还有尾插法。

//--

单链表的整表删除

思路：

①声明一个结点p和q。

②将第一个结点赋值给p。

③循环：

1.将下一结点赋值给q；

2.释放p；

3.将q赋值给p。

//--

整体代码如下（C#实现）

Node

    public class Node<T>
    {
        public T Data;
        public Node<T> Next;

        public Node(T item)
        {
            this.Data = item;
            this.Next = null;
        }

        public Node()
        {
            this.Data = default(T);
            this.Next = null;
        }
    }

LinkList

 public class LinkList<T>
    {
        public Node<T> Head;//单链表头

        /// <summary>
        /// 构造单链表
        /// </summary>
        public LinkList()
        {
            Clear();
        }

        /// <summary>
        /// 获取单链表的长度
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            Node<T> p = Head;
            int length = 0;
            while (p != null)
            {
                p = p.Next;
                length++;
            }
            return length;
        }

        /// <summary>
        /// 判断单链表是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            if (Head == null)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 清空单链表
        /// </summary>
        public void Clear()
        {
            Head = null;
        }

        /// <summary>
        /// 显式单链表
        /// </summary>
        public void Display()
        {
            if (IsEmpty())
            {
                Console.WriteLine("IsEmpty");
                return;
            }
            Node<T> A = new Node<T>();
            A = Head;
            while (A != null)
            {
                Console.WriteLine(A.Data.ToString());
                A = A.Next;
            }
        }

        /// <summary>
        /// 获得当前位置单链表中结点的值
        /// </summary>
        /// <param name="i">结点位置</param>
        /// <returns></returns>
        public T GetNodeValue(int i)
        {
            if (IsEmpty() || i < 1 || i > GetLength())
            {
                Console.WriteLine("Error");
                return default(T);
            }

            Node<T> p = new Node<T>();
            p = Head;
            int j = 1;
            while (p.Next != null && j < i)
            {
                p = p.Next;
                j++;
            }

            return p.Data;
        }

        /// <summary>
        /// 增加单链表插入的位置
        /// </summary>
        /// <param name="item">结点内容</param>
        /// <param name="i">结点插入的位置</param>
        public void Insert(T item, int i)
        {
            if (IsEmpty() || i < 1 || i > GetLength())
            {
                Console.WriteLine("Error");
                return;
            }

            if (i == 1)
            {
                Node<T> h = new Node<T>(item);
                h.Next = Head;
                Head = h;
                return;
            }

            Node<T> A = new Node<T>();
            Node<T> B = new Node<T>();
            B = Head;
            int j = 1;
            while (B.Next != null && j < i)
            {
                A = B;
                B = B.Next;
                j++;
            }

            if (j == i)
            {
                Node<T> C = new Node<T>(item);
                A.Next = C;
                C.Next = B;
            }
        }

        /// <summary>
        /// 删除单链表结点
        /// </summary>
        /// <param name="i">删除结点位置</param>
        public void Delete(int i)
        {
            if (IsEmpty() || i < 1 || i > GetLength())
            {
                Console.WriteLine("Error");
                return;
            }

            Node<T> A = new Node<T>();
            if (i == 1)
            {
                A = Head;
                Head = Head.Next;
                return;
            }

            Node<T> B = new Node<T>();
            B = Head;
            int j = 1;
            while (B.Next != null && j < i)
            {
                A = B;
                B = B.Next;
                j++;
            }

            if (j == i)
            {
                A.Next = B.Next;
            }
        }

        /// <summary>
        /// 增加新元素到单链表末尾（尾插法）
        /// </summary>
        /// <param name="item">结点数据</param>
        public void AddLast(T item)
        {
            Node<T> tail = new Node<T>(item);
            if (IsEmpty())
            {
                Head = tail;
                return;
            }

            Node<T> A = new Node<T>();
            A = Head;
            while (A.Next != null)
            {
                A = A.Next;
            }

            A.Next = tail;
        }

        /// <summary>
        /// 增加新元素到单链表头部（头插法）
        /// </summary>
        /// <param name="item"></param>
        public void AddFirst(T item)
        {
            Node<T> h = new Node<T>(item);
            if (IsEmpty())
            {
                Head = h;
                return;
            }

            h.Next = Head;
            Head = h;
        }

        /// <summary>
        /// 单链表反转
        /// </summary>
        public void Reverse()
        {
            if (IsEmpty() || GetLength() == 1)
            {
                return;
            }

            Node<T> newNode = null;
            Node<T> curNode = Head;
            Node<T> tempNode = new Node<T>();

            while (curNode != null)
            {
                tempNode = curNode.Next;
                curNode.Next = newNode;
                newNode = curNode;
                curNode = tempNode;
            }
            Head = newNode;
        }

        /// <summary>
        /// 输出单链表中间值
        /// </summary>
        /// <returns></returns>
        public void DisplayMiddleVale()
        {
            if (IsEmpty())
            {
                Console.WriteLine("IsEmpty");
                return;
            }

            Node<T> temp = Head;
            Node<T> A = Head;
            Node<T> B = Head;

            while (B != null && B.Next != null)
            {
                temp = A;
                A = A.Next;
                B = B.Next.Next;
            }

            if (B != null)
            {
                Console.WriteLine("MiddleVale = " + A.Data.ToString());
            }
            else
            {
                Console.WriteLine("MiddleVale = " + temp.Data.ToString() + "," + A.Data.ToString());
            }
        }
    }

单链表结构与顺序存储结构优缺点

存储分配方式：

1.顺序存储结构用一段连续存储单元依次存储线性表的数据元素。

2.单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素。

时间性能：

①查找

1.顺序存储结构O(1)。

2.单链表O(n)。

②插入和删除

1.顺序存储结构需要平均移动表长一半的元素，时间为O(n)。

2.单链表在线出某位置的指针后，插入和删除时间仅为O(1)。

空间性能：