表的概念和性质
在抽象地讨论线性表时，首先要考虑一个（有穷的或无穷的）基本元素集合E，集合E中的元素可能都是某个类型的数据对象。
在一个非空的线性表里，存在着唯一的一个首元素和唯一的尾元素。除首元素之外，表中的每个元素e都有且仅有一个前驱元素；除了尾元素之外的每个元素都有且仅有一个后继元素。
线性表的实现
将表中元素顺序存放在一大块连续的存储区里，这样实现的表也称为顺序表（或连续表）。在这种实现中，元素间的顺序关系由它们的存储顺序自然表示。
将表元素存放在通过链接构造起来的一系列存储块里，这样实现的表称为链接表，简称链表。
顺序表的实现
如果表里的元素大小相同，假定表元素编号从0开始，元素e0自然应存储在内存位置Loc(e0) = l0,再假定表中一个元素所需的存储单元数为c=size(元素)，在这种情况下，就有下面的简单元素ei的地址计算公式：
Loc(ei) = Loc(e0) + c * i
如果表元素大小不统一，按照上面的方案将元素顺序存入元素存储区，将无法通过统一公式计算元素位置。这时可以采用另一种布局方案。将实际数据元素另行存储，在顺序表里各单元位置保存对应元素的引用信息（地址），由于每个地址所需的存储量相同，可以计算出元素地址的存储位置，而后地址做一次间接访问，就能得到实际元素的数据了。
顺序表的基本操作的实现
创建空表
简单判断操作
访问给定下标i的元素
遍历操作
查找给定元素d的（第一次出现的）位置
查找给定元素d在位置 k之后的第一次出现的位置
变动操作：加入元素：
尾端加入新数据项：O(1)
新数据存入元素存储区的第i个单元：要求无序：O(1)，要求保序：O(n)
变动操作：删除元素：
尾端删除元素：O(1)
删除位置i的数据：要求无序：O(1)，要求保序：O(n)
基于条件的删除：O(n)
表的顺序实现（顺序表）的总结：
优点：O(1)时间的（随机、直接的）按位置访问元素；元素在表里存储紧凑，除表元素存储区之外只需要O(1)空间存放少量辅助信息。
缺点：需要连续的存储区存放表中的元素，如果表很大，就需要很大片的连续内在空间。一旦确定了存储块的大小，可容纳单元个数并不随着插入/删除操作的进行而变化。如果很大的存储区里只保存了少量数据项，就会有大量空闲单元，造成表内的存储浪费。另外，在执行加入或删除操作时，通常需要移动许多元素，效率低。最后，建立表时需要考虑元素存储区大小，而实际需求通常很难事先估计。
顺序表的结构
两种基本的实现方式：一体式结构 / 分离式结构
采用一体式结构，如果不断地向元素存储区添加元素，最终一定会填满其元素存储区。一体式结构不能扩大其存储。要想继续工作，就只能另外创建一个容量更大地对象，把元素搬过去。但是这是一个新对象。
采用分离式结构就简单得多，可以在不改变对象的情况下换一块更大的元素存储区，使加入元素操作可以正常完成。操作过程：
1）另外申请一块更大的元素存储区
2）把表中已有的元素复制到新存储区
3）用新的元素存储区替换原来的元素存储区（改变表对象中的元素链接）
4）实际加入新元素。
这种技术实现的顺序表称为动态顺序表
python中的list：
python标准类型list就是一种元素个数可变的线性表，可以加入和删除元素，在各种操作中维持已有元素的顺序。其重要的实现约束还有：
1）基于下标（位置）的高效元素访问和更新，时间复杂度应该是O(1)
2）允许任意加入元素（不会出现由于表满而无法加入新元素的情况），而且在不断加入元素的过程中，表对象的标识（函数id得到的值）不变。
list需要维持元素的顺序，这种表只能采用连续表技术，表中元素保存在一块连续的存储区里；能容纳任意多的元素，就必须能更换元素存储区。要想在更换存储区时list对象的标识（id）不变，只能采用分离实现技术。
python中list采用如下实际策略：在建立空表时，系统分配一块能容纳8个元素的存储区；在执行插入操作（insert或append）时，如果元素区满就换一块4倍大的存储区。但如果当时的表已经很大，系统将改变策略，换存储区时容量加倍，这里的“很大”是一个实际确定的参数，目前的值是50000。引入后一个策略是为了避免出现过多空闲的存储位置。
顺序表的简单总结
采用顺序表结构实现线性表：
1）最重要的特点（优势）是O(1)时间的定位元素访问。很多简单操作的效率也比较高。
2）这里最重要的麻烦是加入/删除等操作的效率问题。这类操作改变表中元素序列的结构，是典型的变动操作。由于元素在顺序表的存储区里连续排列，加入/删除操作有可能要移动很多元素，操作代价高。
3）只有特殊的尾端插入/删除操作具有O(1)时间复杂度。但插入操作复杂度还受到元素存储区固定大小的限制。通过适当的（加倍）存储区扩充策略，一系列尾端插入可以达到O(1)的平均复杂度。
顺序表的优点和缺点都在于其元素存储的集中方式和连续性。从缺点看，这样的表结构不够灵活，不容易调整和变化。如果在一个表的使用中需要经常修改结构，用顺序表去实现就不太方便，反复操作的代价可能很高。
还有一点问题 也值得提出：如果程序里需要巨大的线性表，采用顺序表实现就需要巨大块的连续存储空间，这也可能造成存储管理方面的困难。
链接表
实现线性表的基本需求是：
1）能够找到表中的首元素
2）从表里的任一元素出发，可以找到它之后的下一个元素
用链接关系显示表示元素之间的顺序关联。基于链接技术实现的线性表称为链接表或者链表。采用链接方式实现线性表的基本思路 ：
1）把表中的元素分别放存储在一批独立的存储块（称为表的结点）里。
2）保证从组成表结构中的任一个结点可找到与其相关的下一个结点。
3）在前一结点里用链接的方式显示地记录下与下一结点之间的关联。
单向链表
一个单链表由一些具体的表结点构成。每个结点是一个对象，有自己的标识，下面也常称其为该结点的链接。结点之间通过结点链接建立起单向的顺序联系。
基本链表操作
创建空链表：只需要把相应的表头变量设置为空链接
删除链表：应丢弃这个链表里的所有结点。这个操作的实现与具体的语言环境有关。在python中只需要将表指针赋值为None，就抛弃了链表原有的所有结点。
判断链表是否为空：将表头变量的值与空链接比较。
判断表是否满：一般而言链表不会满，除非程序用完了所有可用的存储空间。
加入元素：
表首端插入：首端插入元素要求把新数据元素插入表中，作为表的第一元素，这是最简单的情况。这一操作需要通过三步完成：
1）创建一个新结点并存入数据。
2）把原链表首结点的链接存入新结点的链接域next，这一操作将原表的一串结点链接在刚创建的新结点之后。
3）修改表头变量，使之指向新结点，这个操作使新结点实际成为表头变量所指的结点，即表的首结点。
一般情况的元素插入：要想在单链表里的某位置插入一个新结点。必须先找到该位置之前的那个结点，因为新结点需要插入在它的后面，需要修改它的next域。设变量pre已指向要插入元素位置的前一结点，操作也分三步：
1）创建一个新结点并存入数据
2）把pre所指结点next域的值存入新结点的链接域next，这个操作将原表在pre所指结点之后的一段链接到新结点之后。
3）修改pre的next域，使之指向新结点，这个操作把新结点链入被操作的表。
删除元素：删除链表中元素，也可以通过调整表结构删除表中结点的方式完成：
删除表首元素：删除表中第一个元素对应于删除表的第一个结点，为此只需要修改表头指针，令其指向表中第二个结点。丢弃不用的结点将被python解释器自动回收：head = head.next
一般情况的元素删除：一般情况删除须先找到要删元素所在结点的前一结点，设用变量pre指向，然后修改pre的next域，使之指向被删除结点的下一结点：pre.next = pre.next.next
扫描、定位和遍历：
按下标定位：链表首结点的元素应看作下标0，其他元素一次排列。确定第i个元素所在结点的操作称为按下标定位，可以参考表扫描模式写出：
p = head while p is not None and i > 0: i -= 1 p = p.next
假设循环前变量i已有所需的值，循环结束时可能出现两种情况：或者扫描完表中所有结点还没有找到第i个结点，或者p所指结点就是所需。通过检查p值是否为None可以区分这两中情况。显然，如果现在需要删除第k个结点，可以先将i设置为k-1，循环后检查i是0且p.next不是None就可以执行删除了。
按元素定位：假设需要在链表里找到满足谓词pred的元素。同样可以参考上面的表扫描模式：
p = head while p is not None and not pred(p.elem): p = p.next
链表操作的复杂度
创建空表：O(1)
删除表：在python里是：O(1)
判断空表：O(1)
加入元素：
首端加入元素：O(1)
尾端加入元素：O(n)
定位加入元素：O(n)
删除元素：
首端删除元素：O(1)
尾端删除元素：O(n)
定位删除元素：O(n)
其他删除：通常需要扫描整个表或其一部分，O(n)
单链表类的定义，初始化函数和简单操作
class LList: def __init__(self): self._head = None def is_empty(self): return self._head is None def prepend(self, elem): self._head = LNode(elem, self._head) def pop(self): if self._head is None: raise LinkedListUnderflow("in pop") e = self._head.elem self._head = self._head.next return e def append(self, elem): if self._head is None: self._head = LNode(elem) return p = self._head while p.next is not None: p = p.next p.next = LNode(elem) def pop_last(self): if self._head is None: raise LinkedListUnderflow("in pop_last") p = self._head if p.next is None: e = p.elem self._head = None return e while p.next.next is not None: p = p.next e = p.next.elem p.next = None return e def find(self, pred): p = self._head while p is not None: if pred(p.elem): return p.elem p = p.next def printall(self): p = self._head while p is not None: print(p.elem, end="") if p.next is not None: print(", ", end="") p = p.next print("") def elements(self): p = self._head while p is not None: yield p.elem p = p.next def filter(self, pred): p = self._head while p is not None: if pred(p.elem): yield p.elem p = p.next
链表的变形和操作
前面单链表实现有一个缺点：尾端加入元素操作的效率低，因为这时只能从表头开始查找，直至找到表的最后一个结点，而后才能链接新结点。
优化：给表对象增加一个表尾结点引用域，只需要常量时间就能找到尾结点，在尾结点加入新结点的操作就可能做到O(1)。
class LList1(LList): def __init__(self): super().__init__() self._rear = None def prepend(self, elem): if self._head is None: self._head = LNode(elem, self._head) self._rear = self._head else: self._head = LNode(elem, self._head) def append(self, elem): if self._head is None: self._head = LNode(elem, self._head) self._rear = self._head else:
# 将新加入的结点连在现有尾端结点后 self._rear.next = LNode(elem)
# 将尾端结点指向新加入的加点 self._rear = self._rear.next def pop_last(self): if self._head is None: raise LinkedListUnderflow("in pop_last") p = self._head if p.next is None: e = p.elem self._head = None return e while p.next.next is not None: p = p.next e = p.next.next p.next = None self._rear = p return e
循环单链表
单链表的另一常见变形是循环单链表（简称循环链表），其中最后一个结点的next域不用None，而是指向表的第一个结点，但仔细考虑，就会发现在链表对象里记录表尾结点更合适，这样就可以同时支持O(1)时间的表头/表尾插入和O(1)时间的表头删除。当然，由于循环链表里的结点连成一个圈，哪个结点算是表头或表尾，只要是概念问题，从表的内部形态上无法区分。
class LCList: def __init__(self): self._head = None def is_empty(self): return self._head is None def prepend(self, elem): p = LNode(elem) if self._rear is None: p.next = p self._rear = p else: p.next = self._rear.next self._rear.next = p def append(self, elem): self.prepend(elem) self._rear = self._rear.next def pop(self): if self._rear is None: raise LinkedListUnderflow("in pop of CLList") p = self._rear.next if self._rear is p: self._rear = None else: self._rear.next = p.next return p.elem
双链表
单链表只有一个方向的链接，只能做一个方向的扫描和逐步操作。即使增加了尾结点引用，也只能支持O(1)时间的首端加入/删除和尾端加入。如果希望两端插入和删除操作都能高效完成，就必须修改结点的基本设计，加入另一种方向的链接，这样就得到了双向链接表，简称双链表。
双链表类
class LNode: def __init__(self, elem, next_=None): self.elem = elem self.next = next_
class DLNode(LNode): def __init__(self, elem, prev=None, next_=None): super().__init__(elem, next_) self.prev = prev
class DLList(LList1): def __init__(self): super().__init__() def prepend(self, elem): p = DLNode(elem, None, self._head) if self._head is None: self._rear = p else: p.next.prev = p self._head = p def append(self, elem): p = DLNode(elem, self._rear, None) if self._head is None: self._head = p else: p.prev.next = p self._rear = p def pop(self): if self._head is None: raise LinkedListUnderflow("in pop of DLList") e = self._head.elem self._head = self._head.next if self._head is not None: self._head.prev = None return e def pop_last(self): if self._head is None: raise LinkedListUnderflow("in pop_last of DLList") e = self._rear.elem self._rear = self._rear.prev if self._rear is None: self._head = None else: self._rear.next = None return e
两个链表操作
链表反转
链表反转有两种方式，第一种是结点之间搬动元素，但是时间复杂度是O(n**2)；第二种是修改结点的链接关系，通过改变结点的链接顺序来改变表元素的顺序。
下面是LList类的反转方法，在LList1中还需要考虑_rear：
def rev(self): p = None while self._head is not None: q = self._head # self._head = q.next self._head = self._head.next q.next = p p = q self._head = p
链表排序
第一种：结点之间搬动元素，插入排序：
def sort(self): if self._head is None: return crt = self._head.next while crt is not None: x = crt.elem p = self._head while p is not crt and p.elem <= x: p = p.next while p is not crt: y = p.elem p.elem = x x = y p = p.next crt.elem = x crt = crt.next
第二种：种是修改结点的链接关系，插入排序：
def sort(self): p = self._head if p is None or p.next is None: return rem = p.next p.next = None while rem is not None: p = self._head prev = None while p is not None and p.elem <= rem.elem: prev = p p = p.next if prev is None: self._head = rem else: prev.next = rem prev = rem rem = rem.next prev.next = p
不同链表的简单总结
1）基本单链表包含了一系列结点，通过y一个方向的链接构造起来。它支持高效的前端插入和删除操作，定位操作或尾端操作都需要O(n)时间。
2）增加了尾结点引用域的单链表可以很好地支持首端/尾端插入和首端弹出元素，它们都是O(1)时间复杂度的操作，但不能支持高效的尾端删除。
3）循环单链表也能支持高效的表首端/尾端插入和首端弹出元素。需要特别注意结束判断问题。
4）双链表中每个结点都有两个方向的链接，因此可以高效地找到前后结点。如果有尾端点引用，两端插入和删除都能在O(1)时间完成。循环双链表类似。
5）对于单链表，遍历和数据检索操作都只能从表头开始，需要O(n)时间。对于双链表，这些操作可以从表头或表尾开始，复杂度不变。与它们对应的两种循环链表，遍历和检索可以从表中任何一个地方开始，但要注意结束条件。
链表的一些重要的优点：
1）表结构是通过一些链接起来的结点形成的，结点之间的顺序由链接关系决定，链接可以修改，因此表的结构很容易调整和修改。
2）不需要修改结点里的数据元素或移动它们，只通过修改结点之间的链接，就能灵活地修改表的结构和数据排列方式。
3）整个表由一些小的存储块构成，比较容易安排和管理。用python编写程序时，这些问题由解释器负责，程序员不必处理，但了解情况也很重要。
链表的一些明显的缺点：
1）定位访问需要线性时间，这是与顺序表相比的最大劣势。
2）简单单链表上的尾端操作需要线性时间。增加一个尾指针，可以将尾端插入变成常量时间操作，但仍不能有效实现尾端删除。双链表通过在每个结点里增加第二个链接，可以实现两端的高效插入和删除。
3）要找当前元素的前一元素，必须从头开始扫描表结点。这种操作应尽量避免。双链表可以解决这个问题，但每个结点要付出更多存储代价。
4）为存储一个表元素，需要多用一个链接域，这是实现链接表的存储代价。双链表可以提高链表操作的灵活性，但需要增加两个链接域。