线性结构、线性表、顺序表、链表、头插法、尾插法、中间插入或删除一个节点

梳理几个名词：

逻辑地址：就是说是第几个元素。

物理地址：也就是存储地址，在计算机里具体存放的位置。

线性表的存储结构分为：

（1）顺序存储结构：将数据依次存储在连续的整块物理空间中。简称顺序表。

特点：通过计算地址，能直接访问任何数据元素，即随机访问。适合查找，不适合插入删除操作。

（2）链式存储结构：数据分散的存储在物理空间中，通过一根线保存着它们之间的逻辑关系。简称链表、线性链表。

特点：在逻辑上相邻的结点在物理上不必相邻。不能随机存取，只能顺序存储。适合插入删除，不适合访问。

一、线性结构与线性表

1、线性结构是最简单、最常用的一种数据结构。

2、线性结构特点

在数据元素的非空有限集合中，除了第一个元素无直接前驱、最后一个元素无直接后继外，集合中其余的每个数据元素都有唯一的直接前驱和唯一的直接后继。可以想象成：把所有结点用一根直线穿起来。

3、线性表

含义：是由 $n$ $(n\geqslant 0)$ 个类型相同的数据元素组成的有限序列。即：具有相同数据类型的n个数据元素的有限序列，其中n为表长，n=0 是一个空表。

记作： $(a_{1},a_{2},...,a_{i-1},a_{i},a_{i+1},...,a_{n})$ 。

当n >0，除第一个元素无直接前驱、最后一个元素无直接后继外，其余的元素都只有一个前驱和一个直接后继。即：数据元素之间具有一对一的关系。

例如：英文字母表（A,B,C...Z），就是一个简单的线性表。表中的每一个英文字母就是一个数据元素，每个元素之间存在唯一的顺序关系，比如：B前面就是A，B后面就是C，以此类推。

4、线性表的逻辑结构

如下图所示：

5、线性表的长度

线性表中元素的个数 $n$ ，被定义为线性表的长度， $n=0$ 时被称为空表。

6、线性表的特点

（1）同一性。线性表中所有数据元素都具有相同的数据类型。

（2）有穷性。线性表由有限个数据元素组成，表的长度就是表中数据元素的个数。

（3）有序性。线性表中相邻数据元素之间存在着顺序关系， $<a_{i} , a_{i+1}>$ 。

7、线性表的存储

在计算机中主要有两种存储结构用来存放线性表：顺序存储结构和链式存储结构。

二、线性表的顺序存储结构——顺序表

1、含义

用一组地址连续的存储单元，依次存储线性表中的各个元素。使得线性表中在逻辑结构上相邻的数据元素存储在连续的物理存储单元中，即：通过数据元素物理存储的连续性，来反映数据元素之间逻辑上的相邻关系。就是说，拿一块内存，把数据挨个存进去，这样就能保证表里元素的逻辑顺序和物理顺序相同。

2、顺序表

采用顺序存储结构的线性表简称为顺序表。

可将顺序表归纳为：关系线性化，结点顺序存。

3、线性表顺序存储结构示意图

从图中可以看出，在顺序表中，每个结点 $a_{i}$ 的存储地址是该结点在表中的逻辑位置 i 的线性函数，只要知道线性表中第一个元素的存储地址（基地址）和表中每个元素所占存储单元的多少，就可以计算出线性表中任意一个数据元素的存储地址，从而实现对顺序表中数据元素的随机存取。

4、地址的计算

假设线性表中有 n 个元素，每个元素占 k 个单元，第一个元素的地址为： $Loc(a_{1})$ （也叫基地址），则可以公式计算出第 i 个元素的地址： $Loc(a_{i})$ :

$Loc(a_{i})=Loc(a_{1})+(i-1)*k$

5、顺序表上的操作

（1）查找。可以通过元素所在的序号查找它，也可以通过元素内容来查找。

（2）增加和删除。都会涉及到对元素进行移动。

（3）合并多个顺序表。

例如：有如下顺序表，现在要在第三个元素前面插入6，此时就要把第三个元素一直到最后一个元素，全部向后移动一个位置。

同理，删除也一样，只是把元素像前移动。

6、顺序表优缺点

方便存取，不适合插入和删除。

三、线性表的链式存储

一种动态存储方法。通常将采用链式存储结构的线性表称为线性链表。

	分类
从链接方式的角度看	单链表
	双链表
	循环链表
从实现角度看	动态链表
从实现角度看	静态链表

1、单链表

在顺序表中，用一组地址连续的存储单元

链表：由一系列结点组成的元素集合。

每个节点包含两部分：

1、数据域item ：存储数据的地方。

2、next：指向下一个节点的指针。

通过结点之间的相互连接，最终串联成一个链表。

列表：顺序存储

链表：链式存储

链表的方法：

输出当前节点的数据域：节点名.item

输出当前节点的下个节点的数据域：节点名.next.item

举例1：手动创建一个链表：

现有三个节点分别是a,b,c，各节点对应的数据域的值分别是1，2，3

class Node:
    def __init__(self, item):
        self.item = item
        self.next = None


a = Node(1)  # 实例化一个对象a，即：创建一个新节点a
b = Node(2)  # 创建一个新节点b
c = Node(3)
a.next = b   # a的下一个值指向b
b.next = c   # b的下一个值指向c
print(a.item) # 输出节点a的数据域的值
print(a.next.item)  # 输出a 的下一个节点的值
# 结果：
1
2

print(a.next.next.item)  # 输出a 的下一个节点的下一个节点的值，即a下下个节点的值
# 结果：
3

效果图如下：

2、头插法、尾插法

链表的头节点：head

尾节点：tail

头插法：新节点先连上原来的头节点，然后head指向新节点。（先连上再改头）

node.next=head

head=node

尾插法：不光要知道头在哪，也要知道尾在哪。只有一个头节点时，该节点既是头节点，又是尾节点（即：head tail都指向这个节点），接着再把新节点先连上原来的尾节点，tail指向新节点：（先连上再改尾）

tail.next = node

tail = node

举例、分别利用头插法、尾插法，来创建一个链表

举例1：头插法

用头插法分别把1,2,3插到链表里。

class Node:
    def __init__(self, item):
        self.item = item
        self.next = None


def creat_linklist_head(li):  # 传入一个列表，列表里面的值作为各个节点的值
    head = Node(li[0])  # 根据列表的第一个元素创建头节点
    for i in li[1:]:  # 列表除第一个元素外，剩下的元素都将作为节点的值传进去
        node = Node(i)  # 创建一个新节点node
        node.next = head  # 头插法： 新节点要先连上原来的头节点
        head = node  # head指向新节点
    return head

a1 = creat_linklist_head([1, 2, 3])
print(a1)
# 结果：
<__main__.Node object at 0x000002EA5BB59128>

进程已结束，退出代码 0

结果返回的是一个内存地址，说明，你创建了一个Node对象，并打印了它的内存地址，如果想打印出Node对象的属性，可以在Node类中定义一个__str__方法来返回一个可读的字符串表示形式。

即：加如下代码：

    def __str__(self):
        return str(self.item)

完整代码如下：

class Node:
    def __init__(self, item):
        self.item = item
        self.next = None

    def __str__(self):    # ！！！
        return str(self.item)

def creat_linklist_head(li):  # 传入一个列表，列表里面的值作为各个节点的值
    head = Node(li[0])  # 根据列表的第一个元素创建头节点
    for i in li[1:]:  # 列表除第一个元素外，剩下的元素都将作为节点的值传进去
        node = Node(i)  # 创建一个新节点
        node.next = head  # 头插法： 新节点要先连上原来的头节点
        head = node  # head指向新节点
    return head

a1 = creat_linklist_head([1, 2, 3])
print(a1)
# 结果：
3

为什么结果为3 ？

因为，创建一个单链表函数，返回值是head，也就是头节点，而我们把1，2，3，按头插法插进去之后，头节点的数据域就变成的3，所以返回3 。

或者上面的写法中，把print(a1)改下：改成：

print(a.item) # 输出头节点的数据域

print(a.next.item) # 输出头节点的下一个节点的数据域

结果：

延申：怎么遍历链表？也就是说，怎么从头到尾查看所有节点的数据域。

class Node:
    def __init__(self, item):
        self.item = item
        self.next = None

    def __str__(self):
        return str(self.item)

def creat_linklist_head(li):  # 传入一个列表，列表里面的值作为各个节点的值
    head = Node(li[0])  # 根据列表的第一个元素创建头节点
    for i in li[1:]:  # 列表除第一个元素外，剩下的元素都将作为节点的值传进去
        node = Node(i)  # 创建一个新节点
        node.next = head  # 头插法： 新节点要先连上原来的头节点
        head = node  # head指向新节点
    return head

def print_linklist(a):  # 链表的遍历
    while a:  # 只要链表不是空的就会一直打印
        print(a.item, end=",")  # 打印节点的值
        a = a.next  # 类似i+=1,打印完当前节点，指针指向下个节点，这样才能循环遍历


a1 = creat_linklist_head([1, 2, 3])  # 返回头节点
print_linklist(a1)
# 结果：
3,2,1,

注意：

def print_linklist(a):
    while a:  # 只要链表不是空的就会一直打印
        print(a.item, end=",")  # 打印节点的值
        a = a.next

a=a.next是循环变量，类似i+=1的作用，打印完当前节点的数据域的值后，就要把指针指向下一个节点，否则就一直打印当前这一个节点的数据域，程序就会进入死循环，这里就会一直打印3 。

可以看到，头插法得到的是倒叙的（因为插入的是123，结果确实321，），下面的尾插法得到的是正序的。

举例2：尾插法

class Node:
    def __init__(self, item):
        self.item = item
        self.next = None

    def __str__(self):
        return str(self.item)

# 尾插法
def creat_linklist_tail(li):  # 传入一个列表，列表里面的值作为各个节点的值
    head = Node(li[0])  # ！！将列表的第一个元素作为头节点
    tail = head  #！因为此时只有一个头节点，所以它既是头节点，又是尾节点（即：head tail都指向这个节点）
    for i in li[1:]:  # 列表除第一个元素外，剩下的元素都将作为节点的值传进去
        node = Node(i)  # 创建一个新节点
        tail.next = node  # 尾插法： 新节点先连上原来的尾节点
        tail = node  # tail指向新节点

    return head  # 返回头节点，因为只有头节点有next方法


def print_linklist(a):    # 链表的遍历
    while a:  # 只要链表不是空的就会一直打印
        print(a.item, end=",")  # 打印节点的值
        a = a.next  # 类似i+=1,打印完当前节点，指针指向下个节点，这样才能循环遍历


a1 = creat_linklist_tail([1, 2, 3])  
print_linklist(a1)
# 结果：
1,2,3,

注意：尾插法：

第一步：头节点创建之后，head、tail都指向头节点。

第二步：新节点要先连上原来的尾节点： tail.next = node

第三步：tail指向新节点：tail = node