蓝桥杯省赛冲刺---数据结构基础-链表

实验介绍

我们这门课是算法，这里所讲的数据结构倾向于实战，大家不要拘泥于具体的写法，而重在学习原理，和使用方式，我们所需要的是简洁、实用和快速。我们这节课主要目标学会三种链表的原理与实现，学会灵活地运用，能够不依赖于模板根据题目独立写出各类链表。

我们不是数据结构教程，经典的数据结构采用 C 或 C++ 采用模板类进行编写，但是非常不适合竞赛使用，几行代码硬是能写成十几行，提高了复用性但是浪费了书写时间。所以并不适合竞赛，竞赛追求效率、accept 和简洁。

知识点

• 单链表实现原理与应用
• 双向链表实现原理与应用
• 循环链表实现原理与应用

为什么使用链表

相信大家在这之前已经学过数组，无论是 C++,Java,Python 还是其它语言大都会有数组这一概念，好用吗？很好用，所谓数组其实就是线性表的顺序存储形式的原理，我们来看一下链表的定义并对比一下链式存储与顺序存储的存储方式。

什么是链表

链表是线性表的链式存取的数据结构，是一种链式存取的数据结构，是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：数据域（数据元素的映象）+ 指针域（指示后继元素存储位置），数据域就是存储数据的存储单元，指针域就是连接每个结点的地址数据。 相比于线性表顺序结构，操作复杂。

似乎定义是有些晦涩难懂，我们用两张图来对比一下数组也就是线性表的顺序存储结构和链表在内存中存储 1-9 号元素的形式：

• 顺序存储

• 链式存储

思考一下：

线性表的数据存储方式的内存地址是顺序的，链式存储的数据的内存地址的有什么规律呢？

事实上链式存储的内存地址的是随机分配的，他们每个节点地址之间是没有任何关联的。而且在每个新的节点在产生之前，我们都是不知道他的地址的。

链表初体验

通过上面的介绍，大家可能还是不太能理解为什么要使用链表或者还不懂什么是链表，我们用一个题目来引入。

小王子有一天迷上了排队的游戏，桌子上有标号为 1-10 按顺序摆放的 10 个玩具，现在小王子想将它们按自己的喜好进行摆放。小王子每次从中挑选一个好看的玩具放到所有玩具的最前面。已知他总共挑选了 M 次，每次选取标号为 X 的玩具放到最前面，求摆放完成后的玩具标号。

给出一组输入，M=8 共计排了 8 次，这 8 次的序列为 9，3，2，5，6，8，9，8。 求最终玩具的编号序列。

我们首先梳理一下基本的模拟方法的思路，这个题该怎么去解答：

1. 首先我们要开一个长度为 11 的数组，因为下标要从 1 开始所以 0 — 10 共计 11 个元素。

a[11]={0,1,2,3,4,5,6,7,8,9,10}

1. 然后根据题意我们要写一个查找函数：

//伪代码形式
int Funciton 查找(X)
{
    range i in(1, 10) //循环从x位置到2号位置

        if data[i] == x : //找到X返回
                          return i
                              end if end range
}

我们简单描述一下这个过程:

首先是步进查找比如查找值为 5 元素的下标：

找到元素后返回下标，值为 5。

1. 最后我们找到元素后要进行插入操作。

void Function 移动(L)
{ //移动函数

    //拿走了X,X在L位置,所以将L-1向后移动到L,依次向后移动空处最前面的位置
    temp = data[L]

        range i in(L, 2)      //循环从L位置到2号位置
        data[i] = data[i - 1] //向后移动
        end range

            data[i] = temp
}

我们还是以 5 为例，要把 5 移到到首位，肯定不是把 5 放到第一位就行。

讲到这里，大部分同学肯定会写出如下代码：

//伪代码形式
int Funciton 查找(X){
    range i in (1,10) //循环从x位置到2号位置

        if data[i]==x : //找到X返回
            return i
        end if
    end range
}

void Function  移动(L){ //移动函数


    //拿走了X,X在L位置,所以将L-1向后移动到L,依次向后移动空处最前面的位置
    temp=data[L]

    range i in (L,2) //循环从L位置到2号位置
        data[i]=data[i-1]  //向后移动
    end range

    data[i]=temp
}

void Main()
{
    输入 M
    range in (1,M) //循环M次
        输入 X
        L=查找(X)
        移动(L)
    end range

}

这样每次调用移动函数即可，M=8 调用 8 次函数，每次传入 X 找到位置后,即可得到正确答案。

如果我们规定每次循环的时间复杂度为 1 的话，这次花费了我们多少时间呢？

• X=9 查找 9 循环了 9 次 移动花费了 9 次 此时序列为 9,1,2,3,4,5,6,7,8,10
• X=3 查找 3 循环了 4 次 移动花费了 4 次 此时序列为 3,9,1,2,4,5,6,7,8,10

我们看到每次都花费了大量时间去移动。如果我们采用链表去存储呢，会是什么样子呢。

我们来模拟一下过程:

• 这是初始序列

第一次输入 X=9:

• 执行查询操作:

• 执行删除操作

给 9 前面结点的指针赋值为 9 的指针，再将 9 删除。

• 执行插入操作：

新建一个结点, data 部分为 9 ,将结点插入链表的首部

相比之下后者执行的操作更少，速度更快，那我们给出该题目的一个标准的答案及详细解析。

题目解析

我们学了前面那么多的知识点，我们来动手解答一下小王子的问题了。

• 首先，我们使用链表的话，要先给出结点的定义，上面讲到链表的形式。

结点定义：

struct Node
{
    int data;
    Node *next;
}

• 第二步，我们要先构成一个这样的链表：head-> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> 10

Node * head=new Node; //先生成头结点

void init()
    {
        head->next = nullptr; //形成空链，由上文已知单链表最后一个结点的指针为空。

        for (int i = 10; i >= 1; i--)
        {
            Node *temp = new Node;
            temp->data = i;

            temp->next = head->next;
            head->next = temp;
        }
    }

    //由于我们后边会用到插入函数，其实我们可以写成插入函数的形式

    void insert(int x)
    {
        Node* temp=new Node;
        temp->data=x;

        temp->next=head->next;
        head->next=temp;
    }
    void init(){//为了美观，我们写个初始化函数
        head->next=nullptr; //无论用什么方式，都不能省略该语句，不然无法正