python描述：链表

单链表结构：

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。对于python来说指针就是指向下一个对象。

单链表时间复杂度：

创建空表：O（1）

删除表：O（1）

判断空：O（1）

加入：

首端加入：O（1）

尾端加入：O（n）

定位加入：O（n）

删除：

首端删除：O（1）

尾端删除：O（n）

定位删除：O（n）

其他删除:O（n）

扫描定位遍历都需要价差一批表节点，其时间复杂度收到节点数约束。

　　

单链表 实现：

 class LinkedListUnderflow(ValueError): #自定义链表为空异常类
     pass
 
 class Lnode(object):
     def __init__(self,ele,next=None):
         self.ele = ele
         self.next = next
 
 class Dlist(object):
     def __init__(self):
         self.head = None
 
     def is_emtpy(self):   #链表是否为空
         if self.head == None:
 
             return True
 
     def last_append(self,ele):  #尾插入
         p = Lnode(ele=ele)
 
         if self.is_emtpy():
             self.head = p
             return
 
         last_p = self.head
         while last_p.next:    #找到尾部后插入
            last_p = last_p.next
         last_p.next = p
 
     def head_append(self,ele):  #头插入
         p = Lnode(ele=ele)
 
         if self.is_emtpy():
             self.head = p
             return
 
         p.next = self.head
         self.head = p
 
     def head_pop(self):
         if self.is_emtpy():
             raise LinkedListUnderflow("链表为空")
 
         if self.head.next == None: #只有一个节点
             self.head = None
             return
 
         self.head = self.head.next
 
     def last_pop(self):
         if self.is_emtpy():
             raise LinkedListUnderflow("链表为空")
 
         if self.head.next == None:  # 只有一个节点
             self.head = None
             return
 
         p = self.head
         while p.next.next:  #找到倒数第二个节点
             p = p.next
         p.next = None
 
     def print_all(self):  #输出所有元素
         if self.is_emtpy():
             print("链表为空")
             return
 
         last_p = self.head
         while last_p:
             print(last_p.ele)
             last_p = last_p.next

单链表

循环单链表：

python中的循环单链表，实际就是尾部（tail）节点的指针指向head对象。所以循环单链表实现中只需要实现self.tail而头部即为self.tail.next，以此形成循环进行节点操作。

循环单链表实现

 class LooDlist(object):
     def __init__(self):
         self._real = None
 
     def is_emtpy(self):
         return self._real is None
 
     def head_append(self,ele):
         p = Lnode(ele=ele)
 
         if self.is_emtpy():
             self._real = p
             p.next = self._real  #建立一个列表循环
             return
 
         p.next = self._real.next #在首部添加新节点
         self._real.next = p
 
     def last_append(self,ele):
         self.head_append(ele)
         self._real = self._real.next  #将尾部指针向后移一位
 
     def pop(self):  #前端弹出
         if self.is_emtpy():
             raise LinkedListUnderflow("链表为空")
 
         if self._real.next == self._real: #只有一个节点
             print(self._real.ele)
             self._real = None
             return
 
         value = self._real.next.ele
         self._real.next = self._real.next.next  #弹出前端节点，尾部指针指向弹出节点的next对象
         return value
 
     def print_all(self):
         if self.is_emtpy():
             return
 
         p = self._real.next
         while True:
             print(p.ele)
             if p is self._real:
                 break
             p = p.next

双向链表：

双向链表实现：

#双向链表
 
class Delement(object):
    def __init__(self,ele,next=None,pre=None):
        self.ele = ele
        self.next = next
        self.pre = pre
 
class Bllist(object):
    def __init__(self):
        self.head = None
        self.real = None
 
    def Empty(self):     #清空链表
        self.head = None
        self.real = None
 
    def head_append(self,ele):        #前端增加
        p = Delement(ele=ele,next=self.head)
 
        if not self.head:       #链表为空
            self.head = p
            self.real = p
            return
 
        self.head.pre = p
        self.head = p
 
    def last_append(self,ele):        #尾端增加
        p = Delement(ele=ele,pre=self.real)
 
        if not self.real:
            self.head = p
            self.real = p
            return
 
        self.real.next = p
        self.real = p
 
    def head_pop(self):         #前端删除
        if not self.head:
            raise ValueError("列表为空")
 
        value = self.head.ele
        if self.head == self.real:     #只有一个元素清空
            self.Empty()
            return value
 
        self.head = self.head.next
        self.head.pre = None
        return value
 
    def last_pop(self):
        if not self.real:
            raise ValueError("列表为空")
 
        value = self.real.ele
        if self.head == self.real:
            self.Empty()
            return value
 
        self.real = self.real.pre
        self.real.next = None
        return value
 
    def printall(self):   #输出所有元素值
        p = self.head
        while p != self.real:
            print(p.ele)
            p = p.next
 
        if p:             #链表是否为空
            print(p.ele)

链表反转

原理：原链表相当于一摞书，将这摞书最上面的一本拿下来 放在一个位置B， 再拿一本再放在位置B的最上面，重复这个过程。

class Lnode(object):
    def __init__(self, ele, next=None):
        self.next = next
        self.ele = ele
 
class Dlist(object):
    def __init__(self):
        self.head = None
 
    def head_append(self, ele):  # 头插入
        p = Lnode(ele=ele)
        if not self.head:
            self.head = p
            return
        p.next = self.head
        self.head = p
 
    def reverse(self):
        q = None             #新链表
 
        while True:       #从原链表中拿到一个元素放入新链表
            p = self.head   #剔除原链表最上方的元素
            self.head = self.head.next
 
            if p == None:    #原链表没元素了
                break
 
            p.next = q      #将剔除元素放入新的链表
            q = p
 
        self.head = q    #将反转的链表给原链表
 
    def printall(self):
        p = self.head
        while p != None:
            print(p.ele)
            p = p.next
 
a = Dlist()
for i in range(10):
    a.head_append(i)
 
a.reverse()
a.printall()