python 数据结构一 之 线性表

python数据结构教程第一课

从这里将会正式开始讲解python的一些实用的数据结构，原理加上实例源码。

一、简介

二、线性表的抽象数据类型

三、顺序表的实现

四、链接表的实现

1.单链表

2.带尾指针的单链表

3.循环单链表

4.双链表

5.循环双链表

五、线性表的应用—Josephus问题

1.顺序表解法

2.循环单链表解法

一、简介

在程序里经常需要将一组数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，一组数据中包含的元素个数可能发生变化，也可能会用元素在序列里的位置和顺序，表示实际应用中的某种有意义信息。线性表就是这样一组元素的抽象，其具体实现方式有两种，顺序表和链接表

二、线性表的抽象数据类型（ADT）

线性表的基本操作应当有创建空表、返回长度信息、插入、删除等操作，其基本的ADT如下：

ADT List：
List(self)           #创建一个新表
is_empty(self)       #判断self是否是一个空表
len(self)            #返回表长度
prepend(self,elem)   #在表头插入元素
append(self,elem)    #在表尾加入元素
insert(self,elem,i)  #在表的位置i处插入元素
del_first(self)      #删除第一个元素
def_last(self)       #删除最后一个元素
del(self,i)          #删除第I个元素
search(self,elem)    #查找元素在表中第一次出现的位置
forall(self,op)      #对表元素的遍历操作，op操作

三、顺序表的实现

python内部的tuple与list采用的就是顺序表结构，其不同点在于tuple是固定结构，一旦创建就无法进行改动，而list则支持变动操作，具有上述ADT所描述的全部操作，这里不再具体重写类代码，其主要使用命令如下

list1 = list([1,2,3,4,5])    #创建新表
list1.append(6)              #在尾部添加新元素 6
k = len(list1)               #返回表长度
list1.insert(k,7)            #在位置k插入7
list1.pop()                  #返回并删除尾部元素
print(list1)                 #输出表的全部元素
list2 = list1[2:]            #表的切片操作

顺序表的优势在于O(1)时间的定位元素访问，很多简单的操作效率也比较高，比较麻烦的地方在于，表中间位置元素的插入删除操作，由于元素在顺序表的存储区里连续排列，插入／删除操作可能要移动很多元素，代价很高

四、链接表的实现

基于链接技术实现的线性表称为链接表或者链表，用链接关系显式表示元素之间的顺序关系，链接表结构的基本思想如下：

1.把表中的元素分别存储在一批独立的存储块（结点）里

2.保证从组成表结构中的任一个结点可找到与其相关的下一个结点

3.在前一结点里用链接的方式显式地记录与下一结点之间的关联

在python里链表的实现有诸多方式和变形，接下来将选取主要的结构进行源码讲解

1.单链表

单链表是最基本也是最常用的链表结构，以下描述了链表的各种方法，包括，插入、排序、删除、融合等

import copy

#单链表结点类
class LNode:
def __init__(self, elem,next_=None):
self.elem = elem
self.next = next_

#链表位置定位错误
class LinkedListUnderflow(ValueError):
pass

#单链表类的具体实现
class LList:
def __init__(self):               #初始化操作
self._head = None
self.num = 0                  #num记录结点数

def is_empty(self):               #空表判定
return self._head is None

def len(self):                    #返回表长
return self.num

#定位到链表的第loc个元素
def located(self,loc):
if (loc > self.num or loc < 1):
raise LinkedListUnderflow('in located')
temp = self._head
i = 1
if loc == 1:
return temp
else:
while i < loc:
temp = temp.next
i += 1
return temp

#在链表的第loc个位置添加元素elem
def located_add(self,loc,elem):
temp = self.located(loc)
node = LNode(elem)
if loc == 1:
node.next = self._head
self._head = node
else:
node.next = temp.next
temp.next = node
self.num += 1

#在链表的第loc个位置删除元素
def located_del(self,loc):
temp = self.located(loc)
if loc == 1:
self._head = self._head.next
else:
temp.next = temp.next.next
self.num -= 1

#表头插入元素
def prepend(self,elem):
self._head = LNode(elem,self._head)
self.num += 1

#返
16fab
回并删除表头元素
def pop(self):
if self._head is None:
raise LinkedListUnderflow('in pop')
e = self._head.elem
self._head = self._head.next
self.num -= 1
return e

#在表尾添加元素
def append(self,elem):
if self._head is None:
self._head = LNode(elem)
self.num += 1
return
p = self._head
while p.next is not None:
p = p.next
p.next = LNode(elem)
self.num += 1

#返回并删除表尾元素
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
self.num -= 1
return e
while p.next.next is not None:
p = p.next
e = p.next.elem
p.next = None
self.num -= 1
return e

#返回表中所有满足pred（）操作的元素
def filter(self,pred):
p = self._head
while p is not None:
if pred(p.elem):
yield 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('')

#对表中的所有元素执行proc操作
def for_each(self,proc):
p = self._head
while p is not None:
proc(p.elem)
p = p.next

#使链表支持iterator操作
def elements(self):
p = self._head
while p is not None:
yield p.elem
p = p.next

#链表倒置
def rev(self):
p = None
while self._head is not  None:
q = self._head
self._head = q.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 sort1(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
q = None
while rem is not None and p.elem <= rem.elem:
q = p
p = p.next
if q is None:
self._head = rem
else:
q.next = rem
q = rem
rem = rem.next
q.next = p

#第三种排序算法
def sort2(self):
list1 = copy.deepcopy(self)
if list1._head.next is None:
return
list1._head.next.next = None

if list1._head.next.elem < list1._head.elem:
a = list1._head
list1._head = list1._head.next
list1._head.next = a
list1._head.next.next = None

temp = self._head.next.next

while temp is not None:
p = list1._head
q = list1._head.next
if temp.elem < list1._head.elem:
a = temp.next
temp.next = list1._head
list1._head = temp
temp = a
if temp is not None:
print(temp.elem)
list1.printall()
elif temp.elem >= list1._head.elem:
while q is not None:
if q.elem >= temp.elem:
a = temp.next
temp.next = q
p.next = temp
temp = a
break
elif q.elem < temp.elem:
q = q.next
p = p.next
if q is None:
p.next = temp
a = temp.next
temp.next = None
temp = a
self._head = list1._head

#链表深拷贝操作
def deep_copy(self):
Co = copy.deepcopy(self)
return Co

#链表相等判断
def __eq__(self,List1):
Co1 = self.deep_copy()
Co2 = List1.deep_copy()
Co1.sort()
Co2.sort()
temp1 = Co1._head
temp2 = Co2._head
while Co1.len() == Co2.len() and temp1 is not None and temp2 is not None and temp1.elem == temp2.elem:
temp1 = temp1.next
temp2 = temp2.next
return temp1 is None and temp2 is None

#链表按字典序，< 运算函数
def __lt__(self,other):
temp1 = self._head
temp2 = other._head
while temp1 is not None and temp2 is not None:
if temp1.elem < temp2.elem:
return True
elif temp1.elem > temp2.elem:
return False
else:
temp1 = temp1.next
temp2 = temp2.next
if temp1 is None and temp2 is not None:
return True
else:
return False

#链表按字典序，=< 运算函数
def __le__(self,other):
temp1 = self._head
temp2 = other._head
while temp1 is not None and temp2 is not None:
if temp1.elem < temp2.elem:
return True
elif temp1.elem > temp2.elem:
return False
else:
temp1 = temp1.next
temp2 = temp2.next
if temp1 is None:
return True
else:
return False

#链表按字典序 >= 运算函数
def __ge__(self,other):
temp1 = self._head
temp2 = other._head
while temp1 is not None and temp2 is not None:
if temp1.elem > temp2.elem:
return True
elif temp1.elem < temp2.elem:
return False
else:
temp1 = temp1.next
temp2 = temp2.next
if temp2 is None:
return True
else:
return False

#链表按字典序，> 运算函数
def __gt__(self,other):
temp1 = self._head
temp2 = other._head
while temp1 is not None and temp2 is not None:
if temp1.elem > temp2.elem:
return True
elif temp1.elem < temp2.elem:
return False
else:
temp1 = temp1.next
temp2 = temp2.next
if temp2 is None and temp1 is not None:
return True
else:
return False

#链表反向遍历，执行对每个元素执行op操作
def rev_visit(self,op):
temp = copy.deepcopy(self)
temp.rev()
head = temp._head
while head is not None:
op(head.elem)
head = head.next

#删除表中的elem
def del_elem(self,elem):
a = self._head
b = self._head.next
if a is None:
return
if a.elem == elem:
self._head = b
while b is not None:
if b.elem == elem:
a.next = b.next
a = a.next
b = b.next

#删除表中最小元素
def del_minimal(self):
temp = copy.deepcopy(self)
temp.sort()
elem = temp._head.elem
self.del_elem(elem)

#删除表中所有满足pred操作的元素
def del_if(self,pred):
temp = self._head
while temp is not None:
if pred(temp.elem):
self.del_elem(temp.elem)
temp = temp.next

#返回一个字典，字典记录了表中每个元素出现的次数
def elem_num(self):
temp = self._head
adict = dict()
while temp is not None:
if temp.elem not in adict:
adict[temp.elem] = 1
else:
adict[temp.elem] += 1
temp = temp.next
return adict

#删除链表中出现的重复项，第一次不变
def del_duplicate(self):
temp1 = self._head
temp2 = self._head.next
adict = self.elem_num()

if adict[temp1.elem] > 1:
adict[temp1.elem] *= -1

while temp2 is not None:
if adict[temp2.elem] > 1:
adict[temp2.elem] *= -1
temp1 = temp1.next
elif adict[temp2.elem] < 0:
temp1.next = temp2.next
else:
temp1 = temp1.next
temp2 = temp2.next
print(adict)

#两个链表的交叉融合为一个链表
def interleaving(self,another):
temp1 = self._head
temp2 = another._head
while temp1 is not None and temp2 is not None:
p = temp1.next
temp1.next = temp2
q = temp2.next
temp2.next = p
temp1 = p
temp2 = q
if temp1 is None:
p = self._head
while p.next is not None:
p = p.next
p.next = temp1

以上描述了单链表的众多方法，单链表还存在很多别的形态，可以让很多操作变的简洁有效率

2.带尾结点的单链表

单链表对尾部结点的访问效率是十分低下的，需要遍历表中之前的全部结点，当单链表带上尾部指针时，这种操作就会变的有效率很多

#带尾结点的单链表，继承自单链表，支持其的全部属性和方法
class LList1(LList):
def __init__(self): #初始化，新添了—rear作为尾结点
LList.__init__(self)
self._rear = None

#首部结点插入方法
def prepend(self,elem):
self._head = LNode(elem,self._head)
if self._rear is None:
self._rear = 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.elem
p.next = None
self._rear = p
return e

3.循环单链表

使单链表的尾指针指向首结点，就构成了循环单链表，其与单链表的不同在于，其扫描循环结束的控制判断

class LCList:              #循环单链表
def __init__(self):
self._rear = None

#空链表判断
def is_empty(self):
return self._rear 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

#输出所有结点内容
def printall(self):
if self.is_empty():
return
p = self._rear.next
while True:
print(p.elem,end = " ")
if p is self._rear:
break
p = p.next

#两个链表交叉融合为一个链表
def interleaving(self,another):
temp1 = self._rear.next
temp2 = another._rear.next

while temp1 is not self._rear and temp2 is not another._rear:
a = temp2.next
temp2.next = temp1.next
temp1.next = temp2
temp2 = a
temp1 = temp1.next.next
if temp1 is self._rear:
while temp2 is not another._rear:
self.append(temp2.elem)
temp2 = temp2.next

4.双链表

在单链表中，除了首结点和尾结点外，每个元素不但指向它的下一个结点，还会指向它的上一个结点，双链表支持更简单的反向遍历操作，双链表需要双结点类支持

#双结点类
class DLNode(LNode):
def __init__(self,elem,prev = None,next_ = None):
LNode.__init__(self,elem,next_)
self.prev = prev

#双链表继承自带首尾指针的单链表，不过需要重写添加和删除方法
class DLList(LList1):
def __init__(self):       #初始化
LList1.__init__(self)

#使用双向结点前端插入
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 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

5.循环双链表

双链表的尾部首部互指，构成循环双链表

class DCLList():
def __init__(self):   #双链表类
self._head = None
self.__num = 0

#尾端插入
def append(self,elem):
p = DLNode(elem,None,None)
if self._head is None:
p.next = p
p.prev = p
self._head = p
else:
p.prev = self._head.prev
p.next = self._head
self._head.prev.next = p
self._head.prev = p
self.__num += 1

#尾部返回并删除
def pop(self):
if self._head is None:
raise LinkedListUnderflow('in pop_last of DCLList')
elem = self._head.prev.elem
self._head.prev.prev.next = self._head
self._head.prev = self._head.prev.prev
self.__num -= 1
return elem

#返回长度
def len(self):
return self.__num

#链表倒置
def reverse(self):
q = self._head
p = self._head.prev
n = 1
while p is not q and n <= self.len()/2:
t = p.elem
p.elem = q.elem
q.elem = t
q = q.next
p = p.prev
n += 1

#链表元素排序
def sort(self):
i = 0
while i < self.len():
j = 0
p = self._head
while j < self.len()-i-1:
if p.elem > p.next.elem:
t = p.elem
p.elem = p.next.elem
p.next.elem = t
j += 1
p = p.next
self.printall()
i += 1

#链表倒置算法2
def reverse1(self):
li = DCLList()
p = self._head.prev
for i in  range(self.len()):
li.append(p.elem)
p = p.prev
i += 1
self._head = li._head

#链表排序算法2
def sort1(self):

i = 0
while i < self.len()-1:
j = 0
p = self._head.next
while j < self.len()-i-2:
if p.elem > p.next.elem:
a = p.prev
b = p.next.next
c = p.next
a.next = c
c.prev = a
c.next = p
p.prev = c
p.next = b
b.prev = p
else:
p = p.next
j += 1
i += 1
i = 0
p = self._head.next
elem = self._head.elem
while i < self.len()-1:
if p.elem <= elem and p.next.elem > elem:
a = self._head
b = self._head.prev
c = self._head.next
b.next = c
c.prev = b
a.next = p.next
p.next.prev = a
p.next = a
a.prev = p
self._head = c
break
i += 1
p = p.next
if i == self.len()-1:
self._head = self._head.next

#输出链表元素
def printall(self):
p = self._head
for i in range(self.len()):
print(p.elem,end = ' ')
p = p.next
print()

以上介绍了链表的众多基本与高级操作，以及链表的各种形态变形，链表的优势在于，表元素之间的顺序由它们所在的结点之间的链接显式表示，因此表结点可以任意安排位置，灵活的调整结构。

同时，为了实现链接表，每个结点都增加了一个链接域，付出了额外的空间代价，链表的位置访问代价很高，需要一个个结点的遍历，使用链表最合理的方式是前端操作和顺序访问

五、线性表的应用—Josephus问题

这里举出一个经典的问题来描述链表的用法

Josephus问题：

假设有n个人围坐一圈，现要求从第k个人开始报数，报到第m个数的人退出。然后从下一个人开始继续报数并按同样的规则退出，直至所有人退出，要求按顺序输出各出列人的编号

方法1.我们可以用list实现算法：

def josephus_A(n,k,m):
people = list(range(1,n+1))

i = k - 1
for num in range(n):
count = 0
while count < m:
if people[i] > 0:
count += 1
if count == m:
print(people[i],end = ' ')
people[i] = 0
i = (i+1) % n
if num < n - 1:
print(',',end = '')
else:
print('')
return

方法2.如果我们该用循环单链表，会发现问题简单了很多：

class Josephus(LCList):
def turn(self,m):
for i in range(m):
self._rear = self._rear.next

def __init__(self,n,k,m):
LCList.__init__(self)
for i in range(n):
self.append(i+1)
self.turn(k-1)
while not self.is_empty():
self.turn(m-1)
print(self.pop(),end = ('\n' if self.is_empty() else ','))

假设有13个人，从第5个人开始报数，数为6，则两种算法的使用和结果为：

算法1:

josephus_A(13,5,6)

算法2:

Josephus(13,5,6)