文档摘要：一年级新入校的学生姩龄多为6周岁孩子们个个活泼可爱，聪明伶俐大部分学生对学习充满兴趣，有较强烈的求知欲和上进心但由于年龄和心理认知的关系，他们在学习上、生活上缺乏自制力有待于培养良好的学习习惯。除此他们接受学前教育也参差不齐。现将学生具体情况分析如下：

线性表:零个或多个数据元素的有限序列

门外家长都挤在大门口与门里的小孩子的井然有序，形成了鲜明对比哎，有时大人的所作所为其实还不如孩子。

线性表（List）：零个或多个数据元素的有限序列

除第一个元素外每一个元素有且只有一个直接前驱元素，除了最后一个元素外每一个元素有且只有┅个直接后继元素，数据元素之间的关系是一对一的关系

在较复杂的线性表中，一个数据元素可以由若干个数据项组成

3.3线性表的抽象数據类型 45

有时我们想知道某个小朋友（比如麦兜）是否是班级的同学老师会告诉我说，没有麦兜是在春田花花幼儿园里。这种查找某个え素是否存在的操作很常用

线性表的创建和初始化过程.
线性表重置为空衰的操作.
以根据位序得到数据元素也是一种 很重要的线性表操作.
查找某个元 素是否存在的操作很常用。
获得线性表长度的问 题也很普遍
插入数据和删除 数据都是必须的操作。

线性表的抽象数据类型定義如下:

要实现两个线性表集合 A 和 B 的并集操作即要使得集合 A=AU B。 说白 了就是把存在集合 B 中但并不存在 A 中的数据元素插入到 A 中即可。

仔细分析一下这个操作发现我们只要循环集合 B 中的每个元素，判断当前元紫 是否存在 A 中若不存在，则插入到 A 中即可 思路应该是很容易想到嘚。
我们假设 U 表示集合 A Lb 表示集合 8，则实现的代码如下:
这里我们对于 union 操作，用到了前面线性表基本操作 ListLength、GetE坠m、 LocateElem、 Listlnsert 等可见，对于复杂的個性化的操作其实就是把基本操作组合起来实现的。

3.4线性表的顺序存储结构 47

他每次一吃完早饭就冲着去了图书馆挑一个好地儿，把他書包里的书一本一本的按座位放好，长长一排九个座硬是被他占了。

线性表的顺序存储结构指的是用一段地址连续的存储单元依次存储线性表的数据元素。

在内存中占据一定的内存空间然后把相同数据类型的数据元素依次存放在这块空地中

既然线性表的每个数据元素的类型都相同，所以可以用 C 语言 (其他语言也相同)的一维数组来实现顺序存储结构 即把第一个数据元素存到数组下 标为 0 的位置中，接着紦线性表相邻的元素存储在数组中相邻的位置

描述顺序存储结构需要三个属性:
存储空间的起始位置：数组data，它的存储位置就是存储空间嘚存储位置
线性表的最大存储容量：数组长度MaxSize
线性表的当前长度：length
存储器中的每个存储单元都有自己的编号这个编号称为地址

3.4.3数据长度與线性表长度区别 48

数组长度：是存放线性表的存储空间的长度，存储分配后这个量是一般是不变 的
线性表长度：是线性表中数据元素的個数，随着线性表插入和删除操作的进行 这个量是变化的。

在任意时刻线性表的长度应该小于等于数组的长度。

可Java语言中的数组却是從 0 开始第一个下标的于是线性表的第 i 个元素是要存储在数组 下标为 i-1 的位置，即数据元素的序号和存放它的数组下标之间存在对应关系：
鼡数组存储顺序表意味着要分配回走长度的数组空间由于线位表中可以进行插 入和删除操作，因此分配的数组空间要大于等于当前线性表的长度

存储器中的每个存储单元都有自己的编号，这个编号称为地址
由于每个数据元素，不管它是整型、实型还是字符型它都是需要占 用一定的存储单元空间的。假设占用的是 c 个存储单元那么线性表中第 i+l 个数据 元素的存储位置和第 i 个数据元素的存储位置满足下列關系 (LOC 表示获得存储位置
通过这个公式，你可以随时算出线性表中任意位置的地址不管它是第一个还是 最后一个，都是相同的时间 那么峩们对每个线性表位置的存入或者取出数据， 对于 计算机来说都是相等的时间2 也就是一个常数因此用我们算法中学到的时间复杂度 的概念来说，它的存取时间性能为 0(1)我们通常把具有这一特点的存储结构称为随机存取结构。

3.5顺序存储结构的插入与删除 50

春运时去买火车票夶家都排队排着好好的，这时来了一个美女：“可否让我排在你前面”这可不得了，后面的人像蠕虫一样全部都得退后一步。

如果插叺位置不合理抛出异常
如果线性表长度大于等于数组长度，则抛出异常或动态增加容量
从最后一个元素开始向前遍历到第i个位置分别將它们都向后移动一个位置
将要插入元素填入位置i处

如果删除位置不合理，抛出异常
从删除元素位置开始遍历到最后一个元素位置分别將它们都向前移动一个位置
插入或删除时，平均移动次数和最中间的那个元素移动次数相等为(n-1)/2

插入和删除时，时间复杂度为O(n)

对于统性袤嘚顺序存储结构来说如果我们要实现 GetElem 操作，即将线性表 L 中的第 i 个位置元素值返回其实是非常简单的。 就程序而言只要 i 的数值在数组丅标范围内，就是把数组第 i-l 下标的值返回即可

*获取第i个位置的元素值

数组第 i-l 下标插入新的值
线性表的顺序存储结构，在插入数据时的实現过程
? 如果插入位置不合理抛出异常;
? 如果线性表长度大于等于数组长度，则抛出异常或动态增加容量;
? 从最后一个元素开始向前遍曆到第 i 个位置分别将它们都向后移动一个位 置;
? 将要插入元素填入位置 i 处;

* 在第i个位置插入新元素

最好的情况：如果元素要插入到最后一個位置， 此时时间复杂度为 O(1)因为不需要移动元素的，就如同来了一个新人要正常排队 当然是排在最后 ， 不影响任何 人

最坏情况 ：如果元素要插入到第一个位置，那就意味着要移动所有的元素向后所以这个时间复杂度为 O(n)。

平均的情况：由于元素插入到第 i 个位置需要迻动 n-i 个元素。 根据概率原理 每个位置插入或删除元素的可能性是相同的，也就说位置靠 前移动元萦多，位置靠后 移动元素少。最终岼均移动次数和最中间的那个元素的 移动次数相同为(n-1)/2

平均时间复杂度还是 O(n)。

线性表的顺序存储结构删除元素的过程
? 如果线性表长度为0则不能进行删除
? 如果删除位置不合理，抛出异常
? 从删除元素位置开始遍历到最后一个元素位置分别将它们都向前移动一 个位置;

* 删除第i个位置的元素，并用e返回其值

最好的情况：如果要删除最后一个元素 此时时间复杂度为 O(1)。因为不需要移动元素的就如同最后一个排队的人离开 ， 不影响任何 人

最坏情况 ：如果要删除第一个元素，那就意味着要移动所有的元素向前所以这个时间复杂度为 O(n)。

平均的凊况：删除第 i 个位置需要移动 n-i 个元素。 根据概率原理 每个位置插入或删除元素的可能性是相同的，也就说位置靠 前移动元萦多，位置靠后 移动元素少。最终平均移动次数和最中间的那个元素的 移动次数相同为(n-1)/2

平均时间复杂度还是 O(n)。

线性表的顺序存储结构在存、 讀数据时，不管是哪个位置时间 复杂度都是 0(1); 而插入或删除时，时间复杂度都是 O(n)这就说明 ，它比较适合元素个数不大变化而更多是存取数据的应用。

3.5.4线性表顺序存储结构的优缺点 54

无须为表示表中元素之间的逻辑关系而增加额外的存储空间
可以快速地存取表中任一位置的え素

插入和删除操作需要移动大量元素
当线性表长度变化较大时难以确定存储空间的容量
造成存储空间的”碎片”

* 1.初始化时，应考虑数組大小为负的情况 * 2.在各操作中当涉及到位置i时，都应考虑i位置不合理的情况 * 3.插入操作中需考虑线性表已满的情况 * 删除、获取操作中，需考虑线性表为空的情况 * 4.插入删除操作中均应考虑插入或删除位置为表尾情况 * 5.插入删除操作中，别忘了最后要改变表长 * 1.插入删除位置为表尾时没有判断语句，循环部分也不会执行判断是否在表尾会不会显得画蛇添足？ * （《大话》一书中进行了该判断） * 2.RuntimeException类型在逻辑异常時使用因为异常暂时还没学很好，用法是否正确 * 3.查找元素时，是否使用equals()方法比较合适 * 1.可进一步添加add方法，直接在表尾添加新的元素 * 2.鈳添加整表打印输出的方法 * 若初始化时未声明大小则默认设置为20 * 判断线性表是否为空 *获取第i个位置的元素值 * 查找元素,返回值为该元素位置，0代表查找失败 * 在第i个位置插入新元素 * 删除第i个位置的元素并用e返回其值 * 返回线性表的元素个数

基本数据类型和引用类型各写了一个測试代码。

//System.out.println("——————————插入几个位置错误的情况——————————"); System.out.println("——————————插入1到5,并读取内容——————————"); System.out.println("——————————查找0、5、8是否在表中——————————");

——————————插入1到5,并读取内容——————————
——————————查找0、5、8是否在表中——————————
0
——————————删除2、5——————————

System.out.println("——————————插入1到5,并读取内容——————————"); System.out.println("——————————查找小A、小E、小龙是否在表中——————————");

——————————插入1到5,并读取内容——————————
——————————查找小A、小E、小龙是否在表中——————————
小A的位置：查找成功！
小E的位置：查找成功！
小龙的位置：查找失败！
0
——————————删除小E、小B——————————

3.6线性表的链式存储结構 55

反正也是要让相邻元素间留有足够余地那干脆所有元素都不要考虑相邻位置了，哪有空位就到哪里而只是让每个元素知道它下一个え素的位置在哪里。

3.6.1顺序存储结构不足的解决办法 55

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

要解决这个问题，我们就得考虑一下导致这个问题的原因.
为什么当插入和删除时就要移动大量元素，仔细分析后发现原因就在于楿邻 两元素的存储位置也具有邻居关系。它们编号是 1 2, 3,…, n ，它们在内存中的位 置也是挨着的中间没有空隙， 当然就无法快速介入而删除后， 当中就会留出空 隙自然需要弥补。问题就出在这里

我们反正也是要让相邻元素间留有足够余地，那干脆所有的元素都 不要考虑楿邻位置了哪有空位就到哪里，而只是让每个元素知道包下一个元素的位 置在哪里这样，我们可以在第一个元素时就知道第二个元素的位置(内存地址) , 而找到包 ; 在第二个元素时，再找到第三个元素的位置(内存地址)这样所有的元素 我们就都可以通过遍历而找到。

3.6.2线性表鏈式存储结构定义 56

线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素这组存储单元可以是连续的，也可以是鈈连续的这就意味着，这些数据元素可以存在内存未被占用的任意位置

链式结构中除了要存储数据元素信息外，还要存储它的后继元素的存储地址
我们把存储数据元素信息的域称为数据域 把存储直接后 继位置的域称为指针域。 指针域中存储的信息称做指针或链 这两蔀分信息组成数据 元素 ai 的存储映像，称为结点 (Node)
n 个结点 (al 的存储映像) 链结成一个链衰，即为线性表 (a1 a2,…, an) 的链 式存储结构，因为此链表的每个結点中只包含一个指针域所以叫做单链表。单链表 正是通过每个结点的指针域将线性表的数据元素按其逻辑次序链接在一起：

链表中第┅个结点的存储位置叫做头指针那么整个链袤的存取就必须是从头指针开始进行了 。 之后的每一个结点其实就是上一个的后继指针指姠的位置，最后一个结点的指针为null

为了更加方便地对链表进行操作，有时会在单链表的第一个结点前附设一个结点称为头结点，头结點的数据域可以不存储任何信息也可以存储如线性表的长度等附加信息，头结点的指针域存储指向第一个结点的指针

3.6.3头指针与头结点的異同 58

头指针与头结点的异同：

头指针是指链表指向第一个结点的指针若链表有头结点，则是指向头结点的指针
头指针具有标识作用所鉯常用头指针冠以链表的名字
无论链表是否为空，头指针均不为空头指针是链表的必要元素

头结点是为了操作的统一和方便而设立的，放在第一元素的结点之前其数据域一般无意义（也可存放链表的长度）
有了头结点，对在第一元素结点前插入结点和删除第一结点其操作与其它结点的操作就统一了
头结点不一定是链表必须要素

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

若钱’性表为空袭，则头结点的指针域为"空"
這里我们大概地用图示表达了内存中单链表的存储状态。看着满图的省略号 “……” 你就知道是多么不方便。而我们真正关心的:它是在內存中的实际位置吗? 不是的这只是它所表示的线性表中的数据元素及数据元素之间的逻辑关系。所以我 们改用更方便的存储示意图来表礻单链表：
若带有头结点的单链表：

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

单链表中查找某一个元素，必须要從头开始找

获得链表第i个数据的算法思路：
1.声明一个结点p指向链表第一个结点初始化j从1开始
2.当j<i时，就遍历链表让p的指针向后移动，不斷指向下一结点j累加1,
3.若到链表末尾p为空，则说明第i个元素不存在
4.否则查找成功返回结点p的数据

* 获取第i个结点（包括第0个结点，头结点） * 获取第i个结点的数据(包括头结点)

说白了就是从头开始找，直到第 i 个元素为止由于这个算法的时间复杂度取 决于 i 的位置，当 i=l 时则不需遍历，第一个就取出数据了而当 i=n 时则遍历 n-1 次才可以。 因此最坏情况的时间复杂度是 O(n)

3.8单链表的插入与删除 61

本来是爸爸左牵着妈妈的手、右牵着宝宝的手在马路边散步。突然迎面走来一美女爸爸失神般地望着，此情景被妈妈逮个正着于是扯开父子俩，拉起宝宝的左手僦快步朝前走去

在ai和ai+1之间插入一个数据，只需要

对于单链裴的表头和表尾的特殊情况操作是相同的：

单链表第i个数据插入结点的算法思路：
1.声明一结点p指向链表第一个结点，初始化j从1开始
2.当j<i时就遍历链表，让p的指针向后移动不断指向下一结点，j累加1
3.若到链表末尾p为涳则说明第i个元素不存在
4.否则查找成功，在系统中生成一个空结点s

* 第i个位置插入新的元素

在ai-1和ai+1之间删除ai结点只需要
单链表第i个数据删除结点的算法思路：
1.声明一结点p指向链表第一个结点，初始化j从1开始
2.当j<i时就遍历链表，让p的指针向后移动不断指向下一个节点，j累加1
3.若到链表末尾p为空则说明第i个元素不存在
4.否则查找成功，将欲删除的结点p->next赋值给q
6.将q结点中的数据赋值给e作为返回

* 删除第i个位置元素，並返回其值

分析一下刚才我们讲解的单链表插入和删除算法我们发现，官们其实都是由两 部分组成;第一部分就是遍历查找第 i 个元素；第②部分就是插入和删除元素

单链表在查询、插入和删除操作上的时间复杂度都是O(n)，如果在我们 不知道第 1 个元素的指针位置，星在链表數据结构在插入和删除操作上与线性表的顺 序存储结构是没有太大优势的。但是如果需要从第i个位置插入10个元素，对于顺序存储结构意味着每一次插入都需要移动n-i个元素，每次都是O(n)而单链表，只需要在第一次时找到第i个位置的指针，此时为O(n)接下来的时间复杂度嘟是O(1)，所以对于插入或者删除数据越频繁的操作单链表的效率优势就越是明显。

3.9单链表的整表创建 66

顺序存储结构的创建其实就是一个數组的初始化，即声明一个类型 和大小的数组并赋值的过程而单链表和顺序存储结构就不一样，它不像顺序存储结 构这么集中官可以佷散，是一种动态结构对于每个链表来说，它所占用空间的大 小和位置是不需要预先分配划定的可以根据系统的情况和实际的需求即時生成。

所以创建单链表的过程就是一个动态、生成链表的过程即从"空表"的初始状态起，依次建立各元素结点并逐个插入链表。

单链表整表创建的算法思路：
1.声明一结点p和计数器变量i
3.让L的头结点的指针指向NULL即建立一个带头结点的单链表
随机生成一数字赋值给p的数据域p->data
將p插入到头结点与前一新结点之间（头插法，始终让新结点在第一的位置）也可以将p插入到终端结点的后面（尾插法）

我们把每次新结點都插在终端结点的后面，这种 算法称之为尾插法

注意 list2与 lastnode 的关系， list2 是指整个单链衰而 lastnode是指向尾结点的变量， lastnode 会随着循环 不断地变化结點而 list2 则是随着循环增长为一个多结点的链表。

3.10单链表的整表删除 69

单链表整表删除的算法思路如下：
2.将第一个结点赋值给p

* 清空线性表(自己編写的) * 清空线性表(书中改写)

* 1.《大话数据结构》中没有线性表的长度但提到可以存储于头节点的数据域中。 * 本程序的线性表长度存放于count变量中线性表长度可以使程序比较方便。 * 2.程序中第i个位置代表第i个结点，头结点属于第0个结点 * 3.因为链表为泛型整表创建采用整型（随機整数做元素），所以有出现一些类型转换 * 4.Java程序的方法一般以小写开头但为和书上一致，程序中方法采用了大写开头 * 1.count在增删元素时要加一或减一千万别忘了 * 2.清空线性表要每个元素都null * 判断线性表是否为空 * 清空线性表(自己编写的) * 清空线性表(书中改写) * 获取第i个结点（包括第0个結点，头结点） * 获取第i个结点的数据(包括头结点) * 查找元素0代表查找失败 * 第i个位置插入新的元素 * 删除第i个位置元素，并返回其值 System.out.println("——————————插入1到5,并读取内容——————————"); System.out.println("——————————查找0、2、10是否在表中——————————");

——————————插入1到5,并读取内容——————————
第5个位置的值为：10
——————————查找0、2、10是否在表中——————————
0
——————————删除2、10——————————

System.out.println("——————————插入1到5,并读取内容——————————"); System.out.println("——————————查找小A、小E、小龙是否在表中——————————");

——————————插入1到5,并读取内容——————————
——————————查找小A、小E、小龙是否在表中——————————
小龙的位置：查找失败！
0
——————————删除小E、小B——————————

3.11单鏈表结构与顺序存储结构优缺点 70

顺序存储结构用一段连续的存储单元依次存储线性表的数据元素
单链表采用链式存储结构用一组任意的存储单元存放线性表的元素

顺序存储结构需要平均移动表长一半的元素，时间为O(n)
单链表在线出某位置的指针后插入和删除时间仅为O(1)

顺序存储结构需要预分配存储空间，分大了浪费，分小了易发生上溢
单链表不需要分配存储空间只要有就可以分配，元素个数也不受限制

? 若线性表需要频繁查找很少进行插入和删除操作时，宜采用顺序存储结 构若需要频繁插入和删除时，宜采用单链表结构比如说游戲开发中， 对于用户注册的个人信息除了注册时插入数据外，绝大多数情况都是读取所以应该考虑用顺序存储结构 。而游戏中的玩家嘚武器或者装备列 表随着玩家的游戏过程中，可能会随时增加或删除此时再用顺序存储 就不大合适了，主事链表结构就可以大展拳脚当然，这只是简单的类比 现实中的软件开发，要考虑的问题会复杂得多

? 当线性表中的元素个数变化较大或者根本不知道有多大时，最好用单链表结构 这样可以不需要考虑存储空间的大小问题。而如果事先知道线性表的大致长度比如一年 12 个月，一周就是星期一至煋期日共七天这种用 顺序存储结构效率会高很多。

对于一些语言如basic、fortran等早期的编程高级语言，由于没有指针这链表结构，按照前面峩们的讲法它就没法实现了。怎么办呢

用数组描述的链表叫做静态链表（数组中的元素由两个数据域组成，data和cur）也就是说，数组的烸 个下标都对应一个data和一个 curo数据域data，用来存放数据元素 也就是通常我 们要处理的数据;而游标 cur 相当于单链表中的 next 指针，存放该元素的后繼在数组中的下标

数组元素由两个数据域data和cur组成：data存放数据元素；cur相当于单链表中的next指针，称为游标

为了我们方便插入数据，我们通瑺会把数组建立得大一些以便有一些空闲空间 可以便于插入时不至于溢出。

//初始化的数组状态--将一维数组nodes中各个分量链接成一个备用链表

另外我们对数组第一个和最后一个元素作为特殊元素处理不存数据。我们通常 把未被使用的数组元素称为备用链表

数组中的第一个え素（下标为0）的cur存放备用链表的第一个结点的下标（即下一个元素插入存放的位置），数组的最后一个元素的cur则存放第一个有数值的元素的下标（即存放链头的位置）相当于单链表中的头结点作用，当整个链表为空时则为 0²。
此时的图示相当于初始化的数组状态对应於StaticLinkList初始化方法

假设我们已经将数据存入静态链表，比如分别存放着"甲"、 “乙”、 “丁”、“戊”、 “己”、“庚"等数据
此时"甲"这里就存囿下一元素"乙” 的游标 2，"乙"则存有下一元素"丁"的 下标 3

而"庚"是最后一个有值元素，所以它的 cur 设置为 0

而最后一个元素的 cur 则因"甲"是第一有值え素而存有它的下标为 1。

而第一个元素则因空闲空间的第一个元素下标为 7 所以宫的 cur 存有 7。

将元素”丙”插入到”乙”和”丁”之间

静态鏈表中要解决的是: 如何用静态模拟动态链表结构的存储空间的分配需要 时申请， 无用时释放

我们前面说过，在动态链表中结点的申請和释放分别借用 malloc ()和 free() 两个函数来实现。在静态链表中操作的是数组，不存在像动态链表的结点申请和 释放问题所以我们需要自己实现這两个函数，才可以做插入和删除的操作

为了辨明数组中哪些分量未被使用，解决的办法是将所有未被使用过的及已被删 除的分量用游標链成一个备用的链表 每当进行插入时，便可以从备用链装上取得第 一个结点作为待插入的新结点

* 返回可分配结点下标 * 若备用空间链表非空，则返回分配的结点下标否则返回0 int i= nodes[0].cur; //当前数组第一个元素的cur存的值，就是要返回的第一个备用 空闲的下标 //由于要拿出一个分量来使鼡了所以我们就得把它的下一个分量用来做备用

这段代码有意思，一方面它的作用就是返回一个下标值这个值就是数组头元素 的cur存的苐一个空闲的下标。从上面的图示例子来看其实就是返回 7。

那么既然下标为 7 的分量准备要使用了就得有接替者，所以就把分量 7 的 cur. 值赋徝给头元素也就是把 8 给 space[O].cur，之后就可以继续分配新的空闲分量 实现类似 malloc()函数的作用。

现在我们如果需要在"乙"和"丁" 之间插入一个值为"丙"嘚元素，按照以 前顺序存储结构的做法应该要把"丁"、“戊”、“己”、"庚"这些元素都往后移一 位。 但目前不需要因为我们有了新的手段。

新元素 “丙”想插队是吧?可以，你先悄悄地在队伍最后一排第 7 个游标位置待 着我一会就能帮你搞定。我接着找到了"乙"告诉他，伱的 cur 不是游标为 3 的 "丁"了这点小钱，意思意思你把你的下一位的游标改为 7 就可以了。"乙"叹了 口气收了钱把 cur值改了。此时再回到"丙"那里说你把你的 cur 改为 3. 就这 样，在绝大多数人都不知道的情况下整个排队的次序发生了改变

p=maxSize-1;//p首先是最后一个元素的下标，也就是开始第一个囿值元素的位置

就这样我们实现了在数组中，实王归之移动元素却插入了数据的操作

* 获取第i个元素的下标

和前面一样，删除元素时原来是需要释放结点的函数 free 0。现在我们也得自 己实现它:

* 删除第i个位置的结点 * 将下标为i元素回收到备用链表中

意思就是"甲"现在要走这个位置就空出来了，也就是未来如果有新人来， 最优先考虑这里所以原来的第一个空位分量，即下标是 8 的分量它降级了，把 8 给" 甲"所在下標为 1 的分量的 cur 也就是 space[l].cur=space[O].cur=8

而 space[O].cur=k=l 其实就是让这个删除的位置成为第一个优先空位，把它存人第一个元素的 cur 中

* 1.数组第一个元素的cur为备用链表第一个結点下标 * 数组最后一个元素的cur为第一个有数据的元素的下标，相当于头结点 * 最后一个有值元素的 cur为0 * 2.插入删除操作时获取第i-1个元素的 下標时，应注意i-1=0的情况 * 3.注释中的“位置”指的是在链表中的位置“下标”代表数组中的下标，勿搞混 * 4.程序关键：获取下标在数组层面上操作 * 5.程序中主要写了插入删除操作，其余基本操作与之前文章类似 * 1.泛型数组的建立 * 获取第i个元素的下标 * 返回可分配结点下标 * 插入操作,i代表苐i个位置而不是下标 * 注意插入到第一个位置的特殊性 * 删除第i个位置的结点 * 将下标为i元素回收到备用链表中 * 返回静态链表的长度 System.out.println("——————————插入1到5,并读取内容——————————");

——————————插入1到5,并读取内容——————————
——————————删除小B、小E——————————

在插入和删除操作时，只需要修改游标不需要移动元素，从而改进了在顺序存储结构中的插入和刪除操作需要移动大量元素的缺点

没有解决连续存储分配带来的表长难以确定的问题
失去了顺序存储结构随机存储的特性

总的来说静态鏈表其实是为了给没有指针的高级语言设计的一种实现单链袭能 力的方法。尽管大家不一定会用得上但这样的思考方式是非常巧妙的，應该理解其 思想以备不时之需。

这个轮回的思想很有意思它强调了不管你今生是穷是富，如果持续行善积德下辈子就会好过，反之僦会遭到报应

将单链表中终端结点的指针端由空指针改为指向头指针，就使整个单链表形成一个环这种头尾相接的单链表称为单循环鏈表，简称循环链表 (circular linked list) 。

循环链表解决了一个很麻烦的问题 如何从当中一 个结点出发，访问到链表的全部结点

为了使空链表与非空链表处理一致，我们通常设一个头结点当然 ， 这并不是 说循环链表一定要头结点，这需要注意

循环链表带有头结点的空链表：
其实循環链袭和单链表的主要差异就在于循环的判断条件土，原沫是判断 p->next 是否为空现在则是 p -> next 不等于头结点，则循环未结束

在单链表中，我们囿了头结点时我们可以用 0(1)的时间访问第一个结点，但对 于要访问到最后一个结点却需要 O(n)时间，因为我们需要将单链表全部扫描一遍
囿没有可能用 0(1)的时间由链表指针访问到最后一个结点呢?当然可以。
不过我们需要改造一下这个循环链粟不用头指针，而是用指向终端结點的尾指针来表示循环链表(如图 3.13.5 所示) 此时查找开始结点和终端结点都很方便了。
从上圈中可以看到终端结点用尾指针 rear 指示，则查找终端结点是 0(1) 而开 始结点，其实就是 rear->neJ?->next其时间复杂也为 0(1)。

举个程序的例子要将两个循环链袭合并成一个表时，有了尾指针就非常简单 了 比如下面的这两个循环链衰，它们的尾指针分别是 rearA 和 rearB
要想把它们合井只需要如下的操作即可

就像每个人的人生一样，欲收获就得付代價双向链表既然是比单链表多了如可以反向遍历查找等的数据结构，那么也就需要付出一些小的代价

双向链表是在单链表的每个结点Φ，再设置一个指向其前驱结点的指针域所以在双向链表中的结点都有两个指针域， 一个指向直接后继另一个指向直接前驱。

既然单鏈表也可以有循环链衰那么双向链表当然也可以是循环表。
双向链表的循环带头结点的空链表

非空的循环的带头结点的双向链表如下图所示
由于这是双向链表那么对于链表中的某一个结点 p，它的后继的前驱是谁?当 然还是它自己它的前驱的后继自然也是Z 自己，即:

双向链表是单链表中扩展出来的结构所以宫的很多操作是和单链裴相同的，比 如求长度的 ListLength 查找元素的 GetElem，较得元素位置的 LocateElem 等这些 操作都只要涉及一个方向的指针即可，另一指针多了也不能提供什么帮助

双向链表既然是比单链 表多了如可以反向遍历查找等数据结构，那么也就需要付出一些小的代价:在插入和 删除时需要更改两个指针变景。
双向链表在插入和删除时需要更改两个指针变量
我们现在假设存储元素 e 的结点为s，要实现将结点 s 插入到结点 p 和 p -> next 之间需要下面几步

好了简单总结一下，双向链衰相对于单链表来说要更复杂一些，毕竟官多叻 prior 指针对于插入和删除时，需要格外小心另外它由于每个结点都需要记录两份 指针，所以在空间上是要占用略多一些的不过，由于咜良好的对称性使得对某个 结点的前后结点的操作，带来了方便可以有效提高算法的时间性能。说白了就是 用空间来换时间。

* 在第i個位置插入元素 System.out.println("——————————插入1到5,并读取内容——————————");

——————————插入1到5,并读取内容——————————
——————————删除小A、小E——————————

在阅读过他人的博客后发现自己的查找方法没有利用好双链表的特性，偅写查找方法如下：

* Java 实现的双向链表 // 双向链表“节点”对应的结构体 // 创建“表头”。注意：表头没有存储数据！ // 初始化“节点个数”为0 // 返回链表是否为空 // 获取第index位置的节点的值 // 获取第1个节点的值 // 获取最后一个节点的值 // 将节点插入到第index位置之前 // 将节点插入第一个节点处 // 将節点追加到链表的末尾 // 删除最后一个节点 * Java 实现的双向链表。 // 双向链表操作int数据 // 双向链表是否为空 // 打印出全部的节点 // 双向链表是否为空 // 打印絀全部的节点 // 双向链表是否为空 // 打印出全部的节点

这一章我们主要讲的是线性衰。
先它的定义线性表是零个或多个具有相同类型的数據元素的有限序列。然 后谈了线性表的抽象数据类型如它的一些基本操作。

之后我们就线性表的两大结构做了讲述先讲的是比较容易嘚顺序存储结构，指 的是用一段地址连续的存储单元依次存储线性表的数据元素通常我们都是用数组来 实现这一结构。

后来是我们的重點由顺序存储结构的插入和删除操作不方便，引出了链式存储 结构它具有不受固定的存储空间限制，可以比较快捷的插入和删除操作嘚特点

然 后我们分别就链式存储结构的不同形式，如单链表、循环链表和双向链袤做了讲解 另外我们还讲了若不使用指针如何处理链裴结构的静态链表方法。

总的来说线性表的这两种结构(如图 3-15-1 所示)其实是后面其他数据结构的 基础，把它们学明白了对后面的学习有着臸关重要的作用。

如果你觉得上学读书是受罪假设你可以活到80岁，其实你最多也就吃了20年苦用人生四分之一的时间来换取其余时间的圉福生活，这点苦不算啥

栈是限定仅在表尾进行插入和删除操作的线性表。 队到是只允许在一端进行插入操作、 而在另一端进行删除操莋的线性表

想想看，在你准备用枪的时候突然这手枪明明有子弹却打不出来，这不是要命吗

类似的很多软件，比如word、photoshop等都有撤消（undo）的操作，也是用栈这种思想方式来实现的

栈（stack）是限定仅在表尾进行插入和删除操作的线性表

我们把允许插入和删除的一端称为栈頂 (top) ，另一端称为栈底 (bottom) 不含任何数据元素的棋称为空栈。 栈是一种后进先出（Last In First Out）的线性表简称LIFO结构。

首先它是一个统性表也就是说，棧元素具有线性关系即前驱后继关系。只不过它是一种特殊的线性表而已定义中说是在线性表的表尾进行插入和删除操作，这里表尾昰指栈顶而不是栈底。

它的特殊之处就在于限制了这个线性表的插入和删除位置它始终只在栈顶进 行。这也就使得栈底是固定的最先进栈的只能在栈底。

栈的插入操作叫作进栈，也称压栈、入栈
栈的删除操作，叫做出栈也有的叫做弹栈。

这个最先进栈的元素昰不是就只能是最后出栈呢?
答案是不一定，要看什么情况栈对线性表的插入和删除的位置进行了限制 ，并没有对元素进出的时间进行限淛也就是说，在不是所有元素都进栈的情况下事先进去的元素 也可以出栈，只要保证是栈顶元素出栈就可以

举例来说，如果我们现茬是有 3 个整型数字元素 1、 2、 3 依次进栈会有哪些出栈次序呢?
? 第一种: 1 、 2、 3 进，再 3、 2、 1 出这是最简单的最好理解的一种，出栈次序为 321
? 苐二种: 1 进， 1 出 2 进. 2 出， 3 进 3 出。也就是进一个就出一个出栈次序为 123。

有没有可能是 312 这样的次序出钱呢?答案是肯定不会因为 3 先出栈，就意味 着 3 曾经进栈，既然 3 都进栈了那也就意味着， 1 和 2 已经进栈了此时， 2 一 定是在 1 的上面就是更接近栈顶，那么出栈只可能是 321不然鈈满足 123 依次进 栈的要求，所以此时不会发生 1 比 2 先出栈的情况
从这个简单的例子就能看出，只是 3 个元素就有 5 种可能的出枝次序，如果元 素数量多其实出梭的变化将会更多的。这个知识点一定要弄明白

4.3栈的抽象数据类型 91

对于栈来讲，理论上线性表的操作特性它都具备鈳由于它的特殊性，所以针对 它在操作上会有些变化特别是插入和删除操作，我们改名为 push 和 pop英文直译 的话是压和弹，更容易理解你僦把官当成是弹夹的子弹压人和弹出就好记忆了，我 们一般叫进栈和出栈
由于栈本身就是一个线性表，那么上一章我们讨论了线性表的順序存储和链式存 储对于栈来说，也是同样适用的

4.4栈的顺序存储结构及实现 92

既然栈是线性表的特例，那么栈的顺序存储其实也是线性表顺序存储的简化我 们简称为顺序栈。 线性表是用数组来实现的想想看，对于栈这种只能一头插入删除 的线性表来说用数组哪一端來作为栈顶和栈底比较好?
对，没错下标为 0 的一端作为栈底比较好，因为首元素都存在栈底变化最 小，所以让它作栈底

我们定义一个 top 變量来指示栈顶元素在数组中的位置，枝顶的 top 可以变大变小若存储栈的长度为 StackSize，则栈顶位置 top 必须小于StackSize 当栈存在一个元素时，top 等于 0因此通常把空栈的判定条件定为 top 等于-1。

若现在有一个栈 StackSize 是 5 ，则栈普通情况、空栈和栈满的情况示意图如图：

4.4.2栈的顺序存储结构进栈操作 93

4.4.3栈嘚顺序存储结构出栈操作 94

两者没有涉及到任何循环语句因此时间复杂度均是O(1)。

* 问题：构造器中泛型数组创建是否有更好的方法？

两个夶学室友毕业同时到北京工作他们都希望租房时能找到独自住的一室户或一室一厅，可找来找去发现实在是承受不起。

其实栈的顺序存储还是很方便的因为它只准栈顶迸出元素，所以不存在线性表 插入和删除时需要移动元素的问题不过它有一个很大的缺陷，就是必須事先确定数组存储空间大小万一不够用了，就需要编程手段来扩展数组的容量非常麻烦。 对 于一个栈我们也只能尽量考虑周全，設计出合适大小的数组来处理但对于两个相 同类型的栈，我们却可以做到最大限度地利用其事先开辟的存储空间来进行操作

如果我们囿两个相同类型的栈，我们为它们各自开辟了数组空间 极有可能是第一个栈已经满了，再进栈就溢出了而另一个栈还有很多存储空间涳 闲。 这又何必呢?我们完全可以用一个数组来存储两个栈只不过需要点小技巧。

数组有两个端点两个栈有两个栈底，让一个栈的栈底為 数组的始端即下标为 0 处，另一个栈为栈的末端即下标为数组长度 n-l 处。这样两个栈如果增加元素，就是两端点向中间延伸
其实关鍵思路是:它们是在数组的两端，向中间靠拢 topl 和 top2 是栈1 和栈 2 的栈顶指针，可以想象只要它们俩不见面，两个栈就可以一直使用
从这里也僦可以分析出来，栈 1 为空时就是 topl 等于一 1 时;而当 top2 等于 n 时，即是栈 2 为空时那什么时候栈满呢?

想想极端的情况，若栈2 是空栈栈 1 的 topl 等于 n-l 时，僦是栈 1 满了 反 之，当栈 1 为空栈时top2 等于 0 时，为栈 2 满 但更多的情况，其实就是我刚才 说的两个栈见面之时，也就是两个指针之间相差 1 時即 回top1 + 1 == top2 为栈满。

两栈共享空间的结构的代码如下:

事实上使用这样的数据结构，通常都是当两个栈的空间需求有相反关系时也 就是一個栈增长时另一个栈在缩短的情况。就像买卖股票一样你买入时，一定是有 一个你不知道的人在做卖出操作. 有人赚钱就一定是有人赔錢。这样使用两栈共享 空间存储方法才有比较大的意义. 否则两个栈都在不停地增长那很快就会因栈满而 溢出了。

当然这只是针对两个具有相同数据类型的栈的一个设计上的技巧，如果是不相同数据类型的栈这种办法不但不能更好地处理问题，反而会使问题变得更复杂大 家要注意这个前提。

* 栈的顺序储存结构（两栈共享空间）

4.6栈的链式存储结构及实现 97

栈的链式存储结构简称为链栈。

栈只是栈顶来做插入和删除操作栈顶放在链表的头部还是尾部呢?由于单链表有头指针，而栈顶指针也是必须的那干吗不让它俩合二为一呢，所以比较恏的办法是把栈顶放在单链表的头部另外，都已经有了栈顶在头部了单链表中比较常用的头结点也就失去了意义，通常对于链栈来说是不需要头结点的。
对于链栈来说基本不存在栈满的情况，除非内存已经没有可以使用的空间如 果真的发生，那此时的计算机操作系统已经面临死机崩溃的情况而不是这个链栈是否溢出的问题。

但对于空栈来说链表原定义是头指针指向空， 那么链栈的空其实就是top=null 嘚时候
链栈的结构代码如下 :

链栈的操作绝大部分都和单链表类似，只是在插入和删除上特殊一些。

4.6.2栈的链式存储结构进栈操作 98

对于链棧的进栈push 操作假设元素值为 e 的新结点是s， top 为栈顶指针示 意图如图

node.next=top;//把当前的栈顶元素赋值给新结点的直接后继

4.6.3栈的链式存储结构出栈操莋 99

至于链栈的出栈 pop 操作，也是很简单的三句操作. 假设变量 p 用来存储要删除 的栈顶结点将栈顶指针下移一位，最后释放 p 即可如图

top=top.next;//使得栈頂指针下移一位，指向后一结点 node.next=top;//把当前的栈顶元素赋值给新结点的直接后继

链栈的进栈push 和出校 pop 操作都根简单没有任何循环操作，时间复雜度均为O(1)

顺序栈与链栈在时间复杂度上是一样的，均为O(1)

对于空间性能顺序栈需要事先确定一个固定的长度，可能会存在内存空间浪费嘚问题但它的优势是存取时定位很方便，而链栈则要求每个元素都有指针域这同时也增加了一些内存开销，但对于栈的长度无限制

如果栈的使用过程中元素变化不可预料有时很小，有时非常大那么最好是用链栈，反之如果它的变化在可控范围内，建议使用顺序栈

囿的同学可能会觉得用数组或链表直接实现功能不就行了吗?干吗要引入栈这样的数据结构呢?这个问题问得好。

其实这和我们明明有两只腳可以走路干吗还要乘汽车、火车、飞机一样。理论 上陆地上的任何地方，你都是可以靠双脚走到的可那需要多少时间和精力呢?我 們更关注的是到达而不是如何去的过程。

栈的引人简化了程序设计的问题划分了不同关注层次，使得思考范围缩小更 加聚焦于我们要解决的问题核心。反之像数组等，因为要分散精力去考虑数组的下 标增减等细节问题反而掩盖了问题的本质。

所以现在的许多高级语訁比如 )ava、 C#等都有对栈结构的封装， 你可以不用关 注它的实现细节就可以直接使用 Stack 的 push 和 pop 方法，非常方便

4.8栈的应用——递归 100

当你往镜子湔面一站，镜子里面就有一个你的像但你试过两面镜子一起照吗？如果a、b两面镜子相互面对面放着你往中间一站，嘿两面镜子里都囿你的千百个“化身”。

栈有一个很重要的应用:在程序设计语言中实现了递归

一个经典的递归例子:斐被那契数列 (Fibonacci) 。

说如果兔子在出生两個月后就有繁殖能力， 一对兔子每个月能生出一对小兔子 来假设所有兔都不死，那么一年以后可以繁殖多少对兔子呢?
我们拿新出生的┅对小兔子分析一下;第一个月小兔子没有繁殖能力所以还是 一对i 两个月后，生下一对小兔子数共有两对; 三个月以后老兔子又生下一对，因 为小兔子还没有繁殖能力 所以一共是三对……依次类推可以列出下表(
表中数字 1， 1 , 2, 3 , 5, 8 , 13…构成了一个序列这个数列有个十分明显的 特点，那是:前面相邻两项之和构成了后一项

先考虑一下，如果我们要实现这样的数列用常规的迭代的办法如何实现?假设我 们需要打印出前 40 位嘚斐波那契数到数代码如下:
但其实我们的代码， 如果用递归来实现还 可以更简单。
函数怎么可以自己调用自己?听起来有些难以理解鈈过你可以不要把一个递归 函数中调用自己的函数看作是在调用自己，而就当它是在调另一个函数只不过，这个函数和自己长得一样而巳

在高级语言中，调用自己和其他函数并没有本质的不同我们把一个直接调用自 己或通过一系列的调用语句间接地调用自己的函数，稱做递归函数

当然，写递归程序最怕的就是陷入永不结束的无穷递归中 所以， 每个递归定义 必须至少有一个条件满足时递归不再进荇，即不再引用自身而是返回值退出 比如 刚才的伊j子，总有一次递归会使得 i<2 的这样就可以执行 return i 的语句而不用继续递归了。

对比了两种實现斐波那契的代码 选代和递归的区别是:迭代使用的是循环结构，递归使用的是选择结构递归能使程序的结构更清晰、更简洁、更容噫让人理 解，从而减少读懂代码的时间但是大量的递归调用会建立函数的副本，会耗费大量 的时间和内存选代则不需要反复调用函数囷占用额外的内存。因此我们应该视不同 情况选择不同的代码实现方式

那么我们讲了这么多递归的内容，和栈有什么关系呢?这得从计算機系统的内部 说起
前面我们已经看到递归是如何执行它的前行和退回阶段的。递归过程退回的顺序它前行顺序的逆序在退回过程中，鈳能要执行某些动作包括恢复在前行过程中 存储起来的某些数据。

这种存储某些数据并在后面又以存储的逆序恢复这些数据，以提供の后使用的 需求显然很符合钱这样的数据结构，因此 编译器使用植实现递归就没什么好惊讶的了。

简单的说就是在前行阶段，对于烸一层递归函数的局部变量、参数值以及返 回地址都被压入栈中。在退回阶段位于栈顶的局部变量、 参数值和返回地址被弹 出，用于返回调用层次中执行代码的其余部分也就是’恢复了调用的状态。

当然对于现在的高级语言，这样的递归问题是不需要用户来管理这個栈的 一切都由系统代劳了。

4.9栈的应用——四则运算表达式求值 104

4.9.1后缀（逆波兰）表示法定义 104

栈的现实应用也很多我们再来重点讲一个仳较常见的应用:数学表达式的求值。

括号都是成对出现的有左括号就一定会有右括号，对于多 重括号最终也是完全嵌套匹配的。 这用棧结构正好合适只有碰到左括号，就将此 左括号进枝不管表达式有多少重括号，反正遇到左括号就进栈而后面出现右括号 时，就让棧顶的左括号出栈 期间让数字运算，这样最终有括号的表达式从左到右 巡查一遍，栈应该是由空到有元素最终再因全部匹配成功后荿为空栈的结果。

但对于四则运算括号也只是当中的一部分，先乘除后加减使得问题依然复杂 如何有放地处理它们呢?我们伟大的科学镓想到了好办法。

20 世纪 50 年代s 波兰逻辑学家 J8111 :tukasiewicz当时也和我们现在的同学们一 样，困惑于如何才可以搞定这个四则运算习之知道他是否也像犇顿被苹果砸到头而想 到万有引力的原理，或者还是阿基米德在浴缸中洗澡时想到判断皇冠是否纯金的办 法总之他也是灵感突现，想到叻一种不需要括号的后缀表达法我们也把它称为逆波兰 (Reverse Polish Notation, RPN) 表示。 我想可能是他的名字太复杂了所以 后人只用他的国籍而不是姓名来命名，实在可惜这也告诉我们，想要流芳百世名 字还要起得朗朗上口才行。这种后缀表示法是表达式的一种新的显示方式，非常巧 妙地解决了程序实现四则运算的难题

我们先来看看，对于"9+ (3-1) X3+10-:-2" 如果要用后缀表示法应该是什么 样子: “93 1-3*+102/+” ，这样的表达式称为后缀表达式叫后綴的原因在于所有的符号都是在要运算数字的后面出现。显然这里没有了括号。对于从来没有接触 过后缀表达式的同学来讲这样的表述是很难受的。不过你不喜欢有机器喜吹，比 如我们聪明的计算机

程序中解决四则运算是比较麻烦的，因为计算有优先级波兰逻辑學家发明了一种不需要括号的后缀表达法，称为逆波兰表示

从左到右遍历表达式的每个数字和符号若是数字就输出，即成为后缀表达式嘚一部分若是符号，则判断其与栈顶符号的优先级是右括号或优先级低于栈顶符号（乘除优先加减）则栈顶元素依次出栈并输出，并將当前符号进栈一直到最终输出后缀表达式为止

从左到右遍历表达式的每个数字和符号，遇到是数字就进栈遇到是符号，就将处于栈頂两个数字出栈进行运算，运算结果进栈一直到最终获得结果

为了解释后缀表达式的好处，我们先来看看计算机如何应用后缀表达式计算出 最终的结果 20 的。
规则:从左到右遍历表达式的每个数字和符号遇到是数字就进枝，遇到是符 号就将处于桔顶两个数字出拢，进荇运算运算结果进钱， 一直到最终获得结果

4.9.3中缀表达式转后缀表达式 108

我们把平时所用的标准四则运算表达式 ，即 “9+ (3-1) X3+10-;.-2” 叫做中级 表达式因为所有的运算符号都在两数字的中阁，现在我们的问题就是中缀到后缀的 转化

规则 : 从左到右遍历中缀表达式的每个数字和符号，若昰数字就输出即成为后 缀表达式的一部分i 若是符号，则判断其与楼顶符号的优先级是右括号或优先级低 于槐顶符号(乘除优先加减)则检頂元素依次出钱并输出 ， 并将当前符号进梢一直 到最终输出后缀表达式为止。

从刚才的推导中你会发现 要想让计算机具有处理我们通瑺的标准(中缀)表达 式的能力，最重要的就是两步:

1. 将中缀表达式转化为后缀表达式(栈用来迸出运算的符号)
2. 将后缀表达式进行运算得出结果(棧用来进出运算的数字)。

整个过程都充分利用了栈的后进先出特性来处理，理解好它其实也就理解好了栈这个数据结构

电脑有时会处於疑似死机的状态。就当你失去耐心打算了reset时。突然它像酒醒了一样把你刚才点击的所有操作全部都按顺序执行了一遍。这其实是因為操作 系统中的多个程序因需要通过一个通道输出而按先后次序排队等待造成的。

再比如像移动、联迪、电信等客服电话客服人员与愙户相比总是少数，在所有 的客服人员都占线的情况下客户会被要求等待，直到有某个客服人员空下来才能 让最先等待的客户接通电話。这里也是将所有当前拨打客服电话的客户进行了排队处
操作系统和客服系统中都是应用了一种数据结构来实现刚才提到的先进先出嘚 排队功能，这就是队列

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表

队列是一种先进先出（First In First Out）的线性表简称FIFO。允许插入的一 端称为队尾允许删除的一端称为队头。
队列在程序设计中用得非常频繁前面我们已经举了两个例子，再比如用鍵盘进 行各种字母或数字的输入到显示器上如记事本软件上的输出，其实就是队列的典型应用假如你本来和女友聊天，想表达你是我嘚上帝输入的是 god，而屏幕上却显 示出了 由g 发了出去这真是要气死人了。

4.11队列的抽象数据类型 112

同样是线性表队列也有类似线性表的各種操作，不同的就是插入数据只能在队 尾进行删除数据只能在队头进行。

你上了公交车发现前排有两个空座位而后排所有座位都已经唑满，你会怎么做立马下车，并对自己说后面没座了，我等下一辆没这么笨的人，前面有座位当然也是可以坐的。

队列的头尾相接的顺序存储结构称为循环队列

线性表有顺序存储和链式存储棋是线性衰，所以有这两种存储方式同样，队 列作为一种特殊的钱性衰也同样存在这两种存储方式。我们先来看队列的顺序存储结构

我们假设一个队列有 n 个元素，则JI民序存储的队列需建立一个大于 n 的数组并 把队列的所有元素存储在数组的前 n 个单元，数组下标为 0 的一端即是队头所谓的 入队列操作，其实就是在队尾追加一个元素不需要迻动任何元素，因此时间复杂度为O(1)

与栈不同的是，队列元素的出列是在队头即下标为 0 的位置，那也就意味着 队列中的所有元素都得姠前移动，以保证队列的队头也就是下标为 0 的位置不为 空，此时时间复杂度为 O(n)
这里的实现和线性表的顺序存储结构完全相同不再详述。
在现实中也是如此 一群人在排队买票，前面的人买好了离开 后面的人就要全 部向前一步，补上空位似乎这也没什么不好。
可有时想想为什么出队列时一定要全部移动呢，如果不去限制队列的元素必须 存储在数组的前 n 个单元这一条件出队的性能就会大大增加。 也僦是说队头不需 要一定在下标为 0 的位置
为了避免当只有一个元素时，队头和队尾重合使处理变得麻烦所以引入两个指 针， front 指针指向队頭元素 rear 指针指向队尾元素的下一个位置，这样当 的front 等 于 rear 时此队列不是还剩一个元素，而是空队列
假设是长度为 5 的数组，初始状态涳队列如图 。 front 与 rear 指针均指向下标为 0 的位置 然后入队 al、 a2、 a3、 a4， front 指针依然指向下标 为 0 位置而 rear 指针指向下标为 4 的位置，如图
出队 al、 缸则 front 指針指向下标为 2 的位置， rear 不变如图 。再入队 as此时 front 指针不变， rear 指针移动到数组之外嗯?数组之外， 那将是哪里?如图

问题还不止于此假设這个队列的总个数不超过 5 个，但目前如果接着人队的 话因数组末尾元素已经占用，再向后加就会产生数组越界的错误，可实际上我 們的队列在下标为 0 和 1 的地方还是空闲的。 我们把这种现象叫做"假滥出"

所以解决假溢出的办法就是后面满了 ，就再从头开始也就是头尾楿接的循环。 我们把队列的这种头尾相接的顺序存储结构称为循环队列

rear 可以改为指向下标为 0 的位置，这样就不会 造成指针指向不明的问題了

接着人队衔将它放置于下标为 0 处， rear 指针指向下标为 1 处如图 。若再人队衍则 rear 指针就与 front 指针重合，同时指向下标为 2 的位 置如图 。

? 此时问题又出来了我们刚才说，空队列时 front等于此rear，现在当队列满 时也是front等于此rear，那么如何判断此时的队列究竟是空还是满呢?
? 办法二是当队列空时条件就是 from = rear，当队列满时我们修改其条 件，保留一个元素空间也就是说，队列满时数组中还有一个空闲单元 ，我們就认为此队列已经满了

我们重点来讨论第二种方法，由于 rear 可能比 front大也可能比 front 小，所以 尽管它们只相差一个位.琶时就是满的情况但吔可能是相差整整一圈。 所以若队列的最大尺寸为 QueueSize那么队列满的条件是 (rear+l) %QueueSlze==front (取 模 “%” 的目的就是为了整合 rear 与 front 大小为一个问题)。

* 注意点：表长嘚表示、队列满的判断、front和rear的改变 //不是rear=rear+1当rear在数组尾部时，后移一位会转到数组头部

从这一段讲解大家应该发现，单是顺序存储若不昰循环队列，算法的时间性 能是不高的但循环队列又面临着数组可能会溢出的问题，所以我们还需要研究一下不需要担心队列长度的链式存储结构

4.13队列的链式存储结构及实现 117

队列的链式存储结构，就是线性表的单链表只不过它只能尾进头出，我们把它简称为链队列

為了操作上的方便，我们将队头指针指向链队列的头结点而队尾指针指向终端结点，如图
空队列肘 front 和 rear 都指向头结点，如图

4.13.1队列链式存儲结构入队操作118

人队操作时其实就是在链衰尾部插入结点，如图

4.13.2队列链式存储结构出队操作 119

出队操作时就是头结点的后继结点出队，將头结点的后继改为宫后面的结点 若链表除头结点外只剩一个元素时， 则需将 rear 指向头结点如图

* 注意点：出队操作时，若队头是队尾（即队中仅有一个结点）则删除后要将rear指向头结点。 //若队头是队尾则删除后要将rear指向头结点。 //通过count来判断可能更容易理解

循环队列和鏈队列的比较

循环队列与链队列的时间复杂度都为O(1)

循环队列需要事先申请好空间，使用期间不释放而对于链队列，每次申请和释放结点吔会存在一些时间开销

对于空间上来说循环队列必须有一个固定的长度，所以就有了存储元素个数和空间浪费的问题而链队列不存在這个问题，尽管它需要一个指针域会产生一些空间上的开销，但也可以接受 所以在空间上，链队列更加灵 活

在可以确定队列长度最夶值的情况下，建议用循环队列如果无法预估队列的长度时，则用链队列

又到了总结回顾的时间我们这一章讲的是楼和队列，官们都昰特殊的线性衰 只不过对插入和删除操作做了限制。
栈 (stack) 是限定仅在表尾进行插入和删除操作的线性袭
队列 (queue) 是只允许在一端进行插入操莋，而在另一端进行删除操作的线性
它们均可以用线性表的顺序存储结构来实现但都存在着顺序存储的一些弊端。
因此它们各自有各自嘚技巧来解决这个问题
对于栈来说，如果是两个相同数据类型的楼则可以用数组的两端作栈底的方法 来让两个栈共享数据，这就可以朂大化地利用数组的空间
对于队列来说，为了避免数组插入和删除时需要移动数据于是就引入了循环队 列 ，使得队头和队尾可以在数組中循环变化解决了移动数据的时间损耗，使得本来 插入和删除是 O(n)的时间复杂度变成了 (1)。
它们也都可以通过链式存储结构来实现实現原则上与线性表基本相同如图 4-14-1 所示。

人生需要有队列精神的体现。南极到北极不过是南纬90度到北纬90度的队列，如果你中途犹豫临時转向，也许你就只能和企鹅相伴永远可事实上，无论哪个方向只要你坚持到底，你都可以到达终点

串(string)： 是由零个或多个字符串组荿的有限序列， 又各叫字符串 .

“枯眼望遥山隔水往来曾见几心知？壶空怕酌一杯酒笔下难成和韵诗。途路阻人离别久讯音无雁寄回遲。孤灯夜守长寥寂夫忆妻兮父忆儿。”……可再仔细一读发现这首诗竟然可以倒过来读。

这种诗体叫做回文诗宫是一种可以倒读戓反复回旋阅读的诗体。刚才这首就是 正读是丈夫思念妻子倒读是妻子思念丈夫的古诗。是不是感觉很奇妙呢?

我所提到的“over”、“end”、“lie”其实就是“lover”、“friend”、“believe”这些单词字符串的子串

串（string）是由零个或多个字符组成的有限序列，又名叫字符串

一般记为 s= “ala2…… .an” (0;;;‘時 其中， s 是串的名称用双引号(有些书中 也用单引号)括起来的字符序列是串的值，注意单引号不属于串的内容 ai (1<=i<=n)可以是字母、 数字或其怹字符， i 就是该字符在串中的位置 串中的字符数目 n 称 为串的长度， 定义中谈到"有限"是指长度 n 是一个有限的数值 零个字符的审称为 空串 (null string) ， 它的长度为零可以直接用两双引号 ".…’ 表示，也可以用希腊 字母 “φ” 来表示。所谓的序列说明昂的相邻字符之间具有前驱和后继的關系。

空格串是只包含空格的串。注意它与空串的区别空格串是有内容有长度的， 而且可以不止一个空格
子串与主串，串中任意个數的连续字符组成的子序列称为该串的子串相应地， 包含子串的串称为主串
子串在主串中的位置就是子串的第一个字符在主串中的序號。

串的比较是通过组成串的字符之间的编码来进行的而字符的编码指的是字符在对应字符集中的序号（如ASCII值）

ASCII 编码，更准确一点 由 7 位二进制数表 示一个字符，总共可以表示 128 个字符后来发现一些特殊符号的出现， 128 个不够 用于是扩展 ASCII 码由 8 位二进制数表示一个字符，总囲可以表示 256 个字符这 已经足够满足以英语为主的语言和特殊符号进行输入、存储、输出等操作的字符需要 了。

可是单我们国家就有除漢族外的满、田、藏、蒙古、 维吾尔等多个少数民族文 字，换作全世界估计要有成百上千种语言与文字显然这 256 个字符是不够的，因此 后來就有了 Unicode 编码 比较常用的是由 16 位的二进制数表示一个字符，这样总 共就可以表示 216 个字符约是 65 万多个字符，足够表示世界上所有语言的所有字 符了当然，为了和 ASCII 码兼容 Unicode

所以如果我们要在 C 语言中比较两个串是否相等，必须是它们串的长度以及它们 各个对应位置的字特都楿等时才算是相等。即给定两个串 s= “a1a2……an” , t= “b1b2……bm” 当且仅当 n=m，且 al=bl a2=b2，…… an=bm 时，我们认为 s=t
那么对于两个串不相等时，如何判定它們的大小呢我们这样定义:

5.4串的抽象数据类型 127

串的逻辑结构和线性表很相似，不同之处在于串针对的是字符集也就是串中的 元素都是字苻

因此，对于串的基本操作与线性表是有很大差别的.线性表更关注的是单个元素 的操作比如查找一个元素，插入或删除一个元素但串Φ更多的是查找子串位置、 得到指定位置子串、替换子串等操作。

我们来看一个操作 Index 的实现算法

感情上发生了问题，为了向女友解释一丅我准备发一条短信，一共打了75个字最后八个字是“我恨你是不可能的”，点发送后来得知对方收到的，只有70个字短信结尾是“……我恨你”。

串的存储结构与线性表相同分为两种：串的顺序存储结构和串的链式存储结构

串的顺序存储结构是用一组地址连续的存儲单元来存储串中的字符序列，按照预定义的大小为每个定义的串变量分配一个固定长度的存储区，一般是用定长数组来定义

既然是定長数组就存在一个预定义的最大串长度， 一般可以将实际的串长度值 保存在数组的 0 下标位置3 有的书中也会定义存储在数组的最后一个下標位置但也 有些编程语言不想这么干，觉得存个数字占个空间麻烦它规定在串值后面加一个不 计入串长度的结束标记字符，比如气"\0"来表示串值的终结这个时候，你要想知道此时的串长度就需要遍历计算-下才知道了，其实这还是需要占用-个空间何必 刚才讲的串的顺序存储方式其实是有问题的，因为字符晤的操作比如两串的连 接 Concat、新串的插入 如lnsert， 以及字符串的替换 Replace) 都有可能使得串序列 的长度超过了數组的长度 MaxSize.

于是对于串的顺序存储有一些变化，串值的存储空间可在程序执行过程中动态 分配而得比如在计算机中存在一个自由存储區，叫做"堆"这个堆可由 C 语言的 动态分配函数 malloc()和 free ()来管理。

串结构中的每个元素数据是一个字符如果一个结点对应一个字符，就会存在很夶的空间浪费因此可以考虑一个结点存放多个字符，最后一个结点若是未被占满时可以用”#”或其他非串值字符补全，如下图所示

每個结点存多少个字符会直接影响串处理的效率需要根据实际情况做出选择

串的链式存储结构除了在连接串与串操作时有一定方便之外，總的来说不如顺序存储灵活性能也不如顺序存储结构好

5.6朴素的模式匹配算法 131

子串的定位操作通常称做串的模式匹配

假设我们要从下面的主串 S="googoogle"中，找到 T="google"这个子串的位置我 们通常需要下面的步骤。

简单的说就是对主串的每一个字符作为子串开头，与要匹配的字符串进行匹 配对主E但做大循环，每个字符开头做 T 的长度的小循环直到匹配成功或全部遍历完成为止。

前面我们已经用串的其他操作实现了模式匹配的算法 Index现在考虑不用串的其他操作，而是只用基本的数组来实现同样的算法注意我们假设主串 S 和要匹配的子 串 T 的长度存在 S[O]与 T[O]中。 实現代码如下:

为主串和子串分别定义指针ij。

（1）当 i 和 j 位置上的字母相同时两个指针都指向下一个位置继续比较；

（2）当 i 和 j 位置上的字母鈈同时，i 退回上次匹配首位的下一位j 则返回子串的首位。

* 朴素的模式匹配算法 * 说明：下标从0开始与书稍有不同，但原理一样 * 返回子串t茬主串s中第pos个字符后的位置若不存在返回-1 j++; //i和j指向下一个位置继续比较 i=i-j+1; //退回上次匹配首位的下一位

分析一下， 最好的情况是什么?那就是一開始就区配成功比如 “googlegood” 中去找 google ，时间复杂度为 0(1) 稍差一些，如果像刚才例子中第二、 三、四位 一样每次都是首字母就不匹配，那么對 T 串的循环就不必进行了比如 “abccdffgoogle” 中去找 google。 那么时间复杂度为 O(n+m) 其中 n 为主串长度， m 为要匹配的子串长度根据等概率原则，平均是 (n+m) /2 次查找时间复杂度为 O(n+m).

那么最坏的情况又是什么?就是每次不成功的匹配都发生在串 T 的最后一个字 符。举一个很极端的例子主串为s=”01”，而要匹配的子串为t=””……，前者是有 49 个 “0” 和 1 个 “I " 的主串后者是 9 个 “0” 和 1 个"1” 的子串。在匹配时每次都得将t中字符循环到最后一位才發现，哦原来它们是不匹配的。这样等于 T串需要在 S 串 的前 40 个位置都需要判断 10 次并得出不匹配的结论

子串的定位操作通常称做串的模式匹配，如从主串S=”goodgoogle”中找到子串T=”google”这个子串的位置，通常需要下面的步骤

主串S第一位开始匹配匹配失败
主串S第二位开始匹配，匹配夨败
主串S第三位开始匹配匹配失败
主串S第四位开始匹配，匹配失败
主串S第五位开始匹配S与T，6个字母全匹配匹配成功
时间复杂度为O(n+m)，其中n为主串长度m为要匹配的子串长度

极端情况下，主串为S=”01”子串为T=”0001”，在匹配时每次都得将T中字符循环到最后一位才发现不匹配，此时的时间复杂度为O((n-m+1)*m)

很多年前我们的科学家觉得像这种有多个0和1重复字符的字符串却需要挨个遍历的算法，是非常糟糕的事情

在仩图的比较中，当 i 和 j 等于5时两字符不匹配。在朴素匹配算法中会令i=1，j=0然后进行下一步比较；但是，我们其实已经知道了i=1到4的主串情況了没有必要重复进行i=2到4的比较，且我们观察“ABCABB”的B前面的ABCAB其前缀与后缀(黄色部分)相同，所以可以直接进行上图中的第三步比较（令 i 鈈变令 j 从5变成2，继续进行比较）这就是KMP模式匹配算法的大概思路。这当中的 j 从5跳转到了22通过一个函数next(5)求得，next(5)即代表j=5位置不匹配时要跳转的下一个进行比较的位置

为主串和子串分别定义指针 i 和 j 。

（1）当 i 和 j 位置上的字母相同时两个指针都指向下一个位置继续比较；

（2）当 i 和 j 位置上的字母不同时，i 不变j 则返回到next[j]位置重新比较。（暂时先不管next[]的求法只要记得定义有next[0]=-1）

（3）当 j 返回到下标为0时，若当 i 和 j 位置上的字母仍然不同根据（2），有 j = next[0]=-1这时只能令 i 和 j 都继续往后移一位进行比较 （同步骤（1））。

上述内容可结合下图说明：

（1）i 和 j 从下標为0开始比较该位置两字母相同，i 和 j 往后移继续比较；

（2）一直比较到 i 和 j 等于5时两字母不同， i 不变j 返回到 next[j]的位置重新比较，该子串嘚next[5]=2所以 j 返回到下标为2的位置继续与 i=5的主串字母比较。

（3）在下图情况下当j=0时，两字母不同子串只能与主串的下一个元素比较了（即i=1與j=0比较）。根据（2）会使 j=next[j]=next[0]=-1，所以现在的i=0j=next[0]=-1了，要下一步比较的话两个指针都要加一

根据上述说明可以写出如下代码（代码中的next[]暂时假設已知，之后会讲）：

* 返回子串t在主串s中第pos个字符后的位置(包含pos位置)若不存在返回-1 // j==-1说明了子串首位也不匹配，它是由上一步j=next[0]=-1得到的

　　根据上述内容可知，next[j] 的含义为：当下标为 j 的元素在不匹配时j 要跳转的下一个位置下标。

当j=5时元素不匹配，j跳转到next[5]=2的位置重新比较

那为什么next[5]的值为2呢？即为什么j=5不匹配时要跳转到2位置呢？

观察 ABCABB 这个字符串下标为5的字符为B，它前面的字符 ABCAB 与主串完全相同而ABCAB的前缀與后缀(黄色部分)相同，所以前缀AB不用再进行比较了，直接比较C这个字符即下标为2的字符，所以next[5]=2

那么该如何求解跳转位置next[]呢？通过刚財的讨论我们可以发现next[j]的值等于 j 位置前面字符串的相同前后缀的最大长度，上面例子就是等于AB的长度2

1.在j=0时，0位置之前没有字符串next[0]定義为-1 ；

2. 在 j 位置之前的字符串中，如果有出现前后缀相等的情况令 j 变为相等部分的最大长度，即刚刚所说的相同前后缀的最大长度如上述的ABCABB字符串中，j=5时前面相等部分AB长度为2，所以next[5]=2；

3.其余情况下next[j]=0。其他情况没有出现字符的前后缀相等，相同前后缀的最大长度自然就昰0

那求解next[]的代码如何实现呢？以下是代码的分析过程：

1.定义两个指针 i=0 和 j=-1分别指向前缀和后缀( j 值始终要比 i 值小)，用于确定相同前后缀的朂大长度；（因为 i 是后缀所以我们求的都是 i+1位置的next值next[i+1])

3.当前缀中 j 位置的字符和后缀中 i 位置的字符相等时，说明 i+1 位置的next值为 j+1 (因为 j+1 为相同前后綴的最大长度可结合下面两种情况思考）(即next[i+1]=j+1 )

4.j==-1时，说明前缀没有与后缀相同的地方最大长度为0，则 i+1 位置的next值只能为0此时也可以表示为next[i+1]=j+1。

5.当 j 位置的字符和 i 位置的字符不相等时说明前缀在第 j 个位置无法与后缀匹配，令 j 跳转到下一个匹配的位置即 j= next[j] 。

以下是实现求解next[]的程序：

　　结合next数组的求解和KMP算法完整代码如下：

* KMP模式匹配算法 * 返回子串t在主串s中第pos个字符后的位置。若不存在返回-1 要注意i不变只改变j * 返囙字符串的next数组 * 返回子串t在主串s中第pos个字符后的位置(包含pos位置)。若不存在返回-1

对于如下字符串j=3时，next[j]=1根据next的定义，即当 j=3位置不匹配时j跳转到1位置重新比较，但可以发现j=2位置和j=1位置其实是同一个字母，没有必要重复比较
举个例子，在KMP算法下的比较过程如下（按图依次進行）：
因为有next[3]=1所以会出现中间这个其实可以省略掉的过程。实际上我们是可以直接跳到j=0那一步进行比较的这就需要修改next数组，我们紦新的数组记为nextval数组

中间那步可以省略是因为，j=3和 j=1位置上的字符是完全相同的因此没有必要再进行比较了。因此只需要在原有的next程序Φ加上一个字符是否相等的判断如果要跳转的nextval位置上的字符于当前字符相等，令当前字符的nextval值等于要跳转位置上的nextval值
KMP模式匹配算法的妀进程序如下:

* KMP模式匹配算法 的改进算法 * 返回子串t在主串s中第pos个字符后的位置。若不存在返回-1 要注意i不变只改变j * 返回字符串的next数组 * 返回子串t在主串s中第pos个字符后的位置(包含pos位置)。若不存在返回-1

改进的算法仅在第24到28行代码发生了改变
图中这句话可以结合下表仔细体会。（要記得nextval[j]的含义：j位置的字符未匹配时要跳转的下一个位置）

　　　　要记住上面的算法一定要记住指针 i 和 j 代表的意义，j==-1的意义以及next的意義。

(getNext()中前缀位置和后缀位置index_KMP()中主串位置和子串位置)，（前缀或子串的首个字符就无法匹配）（要跳转的下一个位置）

还有要注意的就昰，i为后缀我们求的是下一个位置的next值，即next[i+1]

这一章节我们主重点讲了"串n 这样的数据结构，串 (string) 是由零个或多个字符 组成的有限序列又洺叫字特串。 本质上它是一种线性袤的扩展，但相对于线性表 关注一个个元素来说 我们对串这种结掏更多的是关注宫子串的应用问题，如查找、 替换等操作现在的高级语言都有针对串的函数可以调用。 我们在使用这些函数的时 候同时也应该要理解它当中的原理，以便于在碰到复杂的问题时可以更加灵活的 使用，比如 KMP 模式匹配算法的学习就是更有效地去理解 in似 函数当中的实现细 节。多用心一点說不定有一天，可以有以你的名字命名的算法流传于后世

《璇玑图》共八百四十字，纵横各二十九字纵、横、斜、交互、正、反读或退一字、迭一字读均可成诗，诗有三、四、五、六、七言不等目前有人统计可组成七千九百五十八首诗。听清楚哦是7958首。

Cemni千年珠宝秉持同步欧洲的时尚设计和独特的品牌内涵，成为诸多名人、明星追捧的对象随着李嘉欣、林志玲陆续为品牌代言，品牌高贵、迷人、经典的奢美形象也进一步受到世人的关注；凭借CCTV-6《首映》栏目唯一指定珠宝的身份，成为倍受瞩目的珠宝品牌

克里斯汀.司徒科特（Christian Stockert）,千年珠宝现任首席珠宝设计師

钻石的4C标志着顶级美钻的至高标准，CEMNI千年珠宝传承钻石4C标准的真谛通过设计师的艺术化，演变成四心元素完美演绎爱情的浪漫、珍贵、忠诚和恒久，传承了因爱而生的珠宝所寄予的至诚誓言

“真爱四心”外围圆形萦绕，使这永生永世的真爱相拥相守，铭刻心中

1990年 以卢浮宫金字塔为灵感的“爱若骄阳”戒指诞生

1997年 恢弘开启中国内地市场

2004年 被中国宝玉石协会聘为常务理事单位

荣获“中国珠宝首饰業驰名品牌”称号

2005年 当选为亚太区的钻石批发、切割和流通的重要组织——香港钻石总会（Diamond Federation Of Hong Kong）理事会员；

2006年 被世界品牌实验室评为“中国500朂具价值品牌”

2007年 纯手工打造 “嫦娥一号”卫星模型被中国国家博物馆永久典藏再次当选“中国珠宝首饰业驰名品牌”

2009年 邀国际影星李嘉欣做品牌形象代言人

荣膺29届香港电影金像奖唯一指定珠宝

“三面伊人”金镶翡翠系列吊坠问世

2010年 荣获“中国珠宝玉石首饰行业科技创新优秀企业”称号

摘获“创建中国珠宝品牌优秀企业”称号

2011年 独家承办国际时尚奢侈品峰会，与LV、万宝龙等国际品牌共同问道中国LV集团前总裁Vincent Bastien先生成为CEMNI千年珠宝品牌顾问中国珠宝玉石首饰行业协会颁授“常务理事单位”称号

2012年 参加“相信爱——电影频道《首映》新年慈善晚会”

贊助CCTV-6《首映》栏目

中国珠宝玉石首饰行业协会授予“常务理事单位”荣誉

国际巨星林志玲受邀成为品牌形象代言人

Vincent Bastien曾任巴黎HEC商学院教授怹在加入HEC之前，曾经在LV担任过6年的CEO也曾担任过YSL、LANCEL等奢侈品牌管理者，是奢侈品界顶尖人物成为CEMNI千年珠宝品牌顾问及好友。他将CEMNI千年珠寶品牌所蕴含的深厚文化和理念明确而生动地表达：秉持国际顶尖奢侈品风尚，为客户缔造高品质的时尚婚庆珠宝

亚洲超人气优雅女性代表

以睿智洞察力践行简单爱情信念

真我爱情信念的守护者和传播者

极具国际视野和美学品味的婚庆珠宝品牌

契合彼此时尚与爱情的律動

CEMNI千年珠宝携手林志玲

续写流光溢彩珠宝新传奇

为您雕琢真情诺言的千年见证

——————————————————————————————————————————————

2013年12月11日，亚洲第一美女林志玲正式签约知名婚庆珠宝品牌CEMNI千年珠宝和品牌共同开启充满传奇和梦幻色彩欧洲珠宝之旅。

发布会现场CEMNI千年珠宝CEO李勇先生与林志玲共同按下“爱”的手印，启动代言仪式鉯示双方的合作将为CEMNI千年珠宝许下传播爱的承诺。

李勇先生表示林志玲内外兼修，集美丽与智慧于一身与品牌独具设计之美十分相符，希望通过林志玲的分享和演绎激励更多的爱侣共同去感受、追求爱情的美好。林志玲现场分享了自己对品牌新品THE MEMORY系列钻石婚戒的解读：“爱情是彼此生命中最美好的记忆之所以难忘，是因为有无数感动铭刻在心”并将此爱的理念赠送给“THE MEMORY”愿更多的爱侣相爱一生。