python链表

一 简介

1 链表简介

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。

我们提供的服务有：网站设计、成都做网站、微信公众号开发、网站优化、网站认证、荔湾ssl等。为上千企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的荔湾网站制作公司

使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。链表最明显的好处就是，常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序，数据的存取往往要在不同的排列顺序中转换。链表允许插入和移除表上任意位置上的节点，但是不允许随机存取。链表有很多种不同的类型：单向链表，双向链表以及循环链表。链表可以在多种编程语言中实现。像Lisp和Scheme这样的语言的内建数据类型中就包含了链表的存取和操作。程序语言或面向对象语言，如C,C++和Java依靠易变工具来生成链表，python在其标准库中没有链接列表。

2 单项链表和双向链表

1 单链表

1 示意图

2 存储结构

上图就是单向链表的存储结构原理图，由图中我们可以看出每个节点都由两部分组成，一个是data数据域，另一个是指向下一节点的next指针域，指针域不存放任何数据，然后通过这样的方式一直指下去，最后便形成了一条类似铁链的结构，所以称为链表，最后的next指针为null，说明到了最后一个节点，(python中为None),最后一个节点的指针不指向任何节点，所以next=null.

2 双向链表

1 示意图

2 存储结构

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

二 python单向链表实现

1 单项链表实现append和 iternodes

#!/usr/bin/poython3.6
#conding:utf-8
class  SingleNode:
    ''' 定义一个节点'''
    def  __init__(self,value,next=None,prev=None):  #追加的下一跳就是None
        self.value=value  # 定义节点中的数据
        self.next=next   # 定义节点的指针
        self.prev=prev   # 定义节点的上一个元素
    def  __repr__(self):
        return str(self.value)  # 此处返回的是指针的值

class  LinkedList:
    '''容器类，用来存储一个个节点，链表在内存中并非是连续的，而list在内存中是连续的'''
    def __init__(self):
        self.nodes=[]  #定义存储的容器，对于一个不需要插入和删除的链表来说，使用list更方便,但插入和remove是不方便的
        self.head=None  #默认的，链表的头和尾都是空
        self.tail=None  # 追加知道tail不用从头进行处理，尾巴加上
    def append(self,val):
        node=SingleNode(val)  #此处生成一个node的值
        prev=self.tail #查看当前有多少个元素，及就是未加的节点之前，前一个节点
        if  prev  is None:  # 如果当前尾巴是None,则表明无元素。tail指的是node,此处是针对第一个元素的执行
            self.head=node #前一个的下一个是None
        else:
            prev.next = node  # 前一个元素的下一个元素指向当前的元素,若只放一个，则next是None，用默认值就可以
        self.nodes.append(node) #追加，此处需要前一个元素
        self.tail=node  # 前一个元素的下一个指向的是node，
    def  iternodes(self,reverse=False):#遍历当前元素
        current= self.head  # 遍历
        while current:
            yield current
            current=current.next

l1=LinkedList()
l1.append(10)
l1.append(11)
l1.append(12)
l1.append(20)
for i in  l1.iternodes():
    print (i)

结果如下

2 双向链表实现如下

#!/usr/bin/poython3.6
#conding:utf-8
class  SignerNode:
    def __init__(self,value,next=None,prev=None):
        self.value=value
        self.next=next
        self.prev=prev
    def __repr__(self):
        return  str(self.value)

class  LinkedList:
    def __init__(self):
        self.tail = None
        self.head = None
    def append(self,val):
        node=SignerNode(val)
        if self.tail  is None:  # only one
            self.head=node
        else:
            self.tail.next=node
            node.prev=self.tail  #前一个应该指向当前的前一个
        self.tail=node  # 将自己变成尾部
    def  iternodes(self,reverse=False):
        current=self.tail  if reverse else  self.head
        while current:
            yield  current
            current=current.prev  if  reverse  else  current.next
    def  pop(self):  # 从尾部进行删除
        if self.tail  is  None:  #如果没尾部，则直接为空
            raise  Exception('Empty')
        # tail中只有一个元素，则其一定不是None,但一定需要拿到
        tail = self.tail  #当前的尾巴
        prev=tail.prev   # 获取尾巴的前一个
        # next=tail.next    # 尾巴的后一个恒定位None
        if  prev  is  None: # 此处表示其如果只有一个元素,则头部和尾部都为空
            self.head=None
            self.tail=None
        else:  # 此处不止一个元素
            self.tail=prev  #将tail指定到前面的一个
            prev.next=None # 前一个的下一个是None
        return  tail.value  # 送进来的是谁，返回的应该就是谁
    def getitem(self,index): # 此处不支持负向索引，此处时通过索引进行操作
        if index < 0 :
            return None
        current=None
        for  k,v in enumerate(self.iternodes()):
            if  index==k:
                current=v  # 如果存在，此处返回为Node
                break
        if current  is  not  None:  # 此处是判断元素的值是否是None，如果时None,则返回，查看遍历是否到头
            return  current
    def insert(self,index,value):
        if  index <0:
            raise Exception('Error')
        current = None
        for k, v in enumerate(self.iternodes()):
            if index == k:
                current = v  # 如果存在，此处返回为Node
                break
        if current  is   None:  # 此处是判断元素的值是否是None，如果时None,则返回，查看遍历是否到头,若没找到，则追加
            self.append(value)  # 此处尾部的修改是不用管的
            return
        prev = current.prev
        next = current.next
        node = SignerNode(value)
        if prev  is None:  # 若你是开头，则prev为None
            self.head=node
            node.next=current # 当前的下一个是之前的
            current.prev=node # 之前的前一个之前是None,现在由于加入了元素，因此前一个的前一个是当前的节点
        else: # 在后面的，本身最后的没动，只是他前面的在动
            node.prev=prev  # 插入的前一个是之前的
            node.next=current # 插入的后一个是当前节点
            current.prev= node   # 当前节点的之前修改成node
            prev.next=node  # 前一个的需要指向当前的
    def  remove(self,index):
        if self.tail is None:  # 此处表示是最后一个
            raise Exception('Empty')
        if index <0:
            raise ValueError('Wrong Index {}'.format(index))
        current=None
        for k, v in enumerate(self.iternodes()):
            if index == k:
                current = v  # 如果存在，此处返回为Node
                break
        if current  is None: # 没找到
            raise  ValueError('Wrong   Index {} .out of  boundary'.format(index))
        prev=current.prev
        next = current.next

        if prev  is None  and  next  is  None: # 此处表示只有一个元素 only  one的情况
            self.head=None
            self.tail=None
        elif  prev  is None:  # 则表示为开始元素
            self.head=next
            next.prev=None
        elif next is  None: # 此处表示是最后一个元素
            self.tail=prev
            prev.next=None
        else: # 不是头部，也不是尾部
            prev.next=next
            next.prev=prev
        print (current)
        del  current
l1=LinkedList()
node=SignerNode('1234')
l1.append(node)
node=SignerNode(1)
l1.insert(0,node)
node=SignerNode(2)
l1.insert(1,node)
node=SignerNode(100)
l1.insert(100,node)
for  i  in   l1.iternodes():
    print (i)
print ('#'*20)
print  (l1.pop())
print (l1.pop())
for  i  in   l1.iternodes():
    print (i)
print ('~'*20)
l1.remove(1)
print ('*'*20)
for  i  in   l1.iternodes():
    print (i)

结果如下

3 使用_setitem_，_getitem_,__iter__实现对链表的访问

#!/usr/bin/poython3.6
#conding:utf-8
class  Node:
    def __init__(self,value,next=None,prev=None):
        self.value=value
        self.next=next
        self.prev=prev
    def __repr__(self):
        return  str(self.value)

class  NodeList:
    def __init__(self):
        # self.lst=[]
        self.tail=None
        self.head=None
    def append(self,value):
        node = Node(value)
        current=self.tail
        if current  is None:  # 此处表示无数据
            self.head=node
        else:  #此处表示有数据
            current.next=node
            node.prev=current
        self.tail=node
        # self.lst.append(node)
    def  pop(self):
        current=self.tail
        prev=current.prev
        next=current.next
        if  current  is None:
            raise  Exception('Empty')
        if  prev  is None:  # 此处是判断只有一个元素
            self.head=None
            self.tail=None
        else:
            self.tail=prev
            prev.next=None
    def  iterable(self,reverse=True):
        current=  self.head    if  reverse else  self.tail
        while current:
            yield  current
            current= current.next  if reverse  else current.prev
    def insert(self,index,value):
        if index < 0 :
            raise Exception('Index  illegal')
        node1=Node(value)
        current=None
        for  k,node  in   enumerate(self.iterable()):
            if  index==k:
                current=node
                break
        if  current  is  None:
            self.append(node1)
            return
        prev=current.prev
        mext=current.next
        if prev is None:  # 此处表示是第一个
            self.head=node1
            node1.next=current
            current.prev=node1
        else:
            node1.next=current
            node1.prev=current.prev
            prev.next=node1
            current.prev=node1
    def remove(self,index):
        if index < 0:
            raise Exception('Index  illegal')
        current = None
        for k, node in enumerate(self.iterable()):
            if index == k:
                current = node
                break
        if current  is None:
            raise Exception('Index  not exist')
        prev=current.prev
        next=current.next
        if  prev  is None  and  next  is None:
            self.tail=None
            self.head=None
        elif prev  is None:
            self.head=current.next
            next.prev=None
        elif  next is None:
            self.tail=current.prev
            prev.next=None
        else:
            prev.next=next
            next.prev=prev
    def __getitem__(self, index):
        for  i,node  in enumerate(self.iterable(True  if index >=0  else  False), 0  if  index >= 0 else 1 ): # 此处表示枚举法的起点为0
            if  ( i   if  index>=0  else  -i) == abs(index):
                return node

    def __iter__(self):
        return  iter(self.iterable())
    def __setitem__(self,index, value):
        self[index].value=value
node=Node(1)
l1=NodeList()
l1.append(node)
node=Node(2)
l1.append(node)
node=Node(3)
l1.append(node)
node=Node(4)
l1.append(node)
node=Node(5)
l1.append(node)
for i in l1.iterable():
    print (i)
print ('*'*30)
l1.pop()
l1.pop()
l1.pop()
for i in l1.iterable():
    print (i)
print ('#'*30)
l1.insert(0,100)
l1.insert(100,10)
l1.insert(2,'abc')
for i in l1.iterable():
    print (i)
print ('~'*30)
l1.remove(2)
l1.remove(1)
l1.remove(0)
l1.remove(1)
for i in l1.iterable():
    print (i)
l1.append(node)
l1.append(node)
print ('}'*20)
print (l1[0])
print (l1[1])
print ('}'*20)
for i  in l1:
    print (i)
print ('['*30)
l1[1]=4
for i  in l1:
    print (i)
l1[0]=10
print (']'*30)
for i  in l1:
    print (i)
l1[2]=20
print ('$'*30)
for i  in l1:
    print (i)
l1[2]=40
print ('('*30)
for i  in l1:
    print (i)