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
    
    #返回并删除表头元素    
    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)