python与链表

链表是由许多相同数据类型的数据项按照特定顺序排列而成的线性表。数据的插入和删除较为方便，有新的数据则申请一块内存空间，数据删除后则将这块内存还给系统。链表的优势在于灵活地进行插入和删除操作，不需要连续的存储单元。

	查找	更新	插入	删除
数组	O(1)	O(1)	O(n)	O(n)
链表	O(n)	O(n)	O(1)	O(1)

数组适合读操作多，写操作少的场景，而链表相反。
注释：cur_node:当前节点, head:头节点, tail:尾节点, ptr:“穿针引线用的针”,通常在遍历和修改时会使用它，new_node:创建的新节点.
1.单向链表

class linked_list:
    def __init__(self):
        self.data = None   #用于存储每个结点的具体数据信息
        self.next = None   #用于指向下一个结点
        
1.1 单向链表的创建
head = linked_list()    #创建头节点
new_node = linked_list()    #创建新节点
head.next = new_node    #新节点链接在头节点后

1.2 单向链表的遍历
ptr = head
while ptr != None:
    print("节点信息")

1.3 单向链表中插入新节点
 1.3.1 在头部插入
 new_node.next = head   #原来的头节点链接在新节点后
 head = new_node    #更新头节点信息
 
 1.3.2 在中间插入
 ptr = head
 通过遍历找到插入位置的上一个节点，positon可以为编号等标识
 while ptr != None:
    if ptr.next = positon:
        break
    ptr = ptr.next
 new_node.next = ptr.next
 ptr.next = new_node
 
 1.3.3 在尾部插入
 找到尾节点
 while ptr != None:
    if ptr.next == None:
        break
    ptr = ptr.next
 ptr.next = new_node
 new_node.next = None

1.4 单向链表的反转
由于单向链表不知道当前节点的上一个节点信息，如果要将单向链表反转，就需要3个指针，需要一个保留遍历过程中前一个节点位置的pre指针。
ptr = head
pre = None
whiel ptr != None:
    r = pre
    pre = ptr
    ptr = ptr.next
    pre.next = r
head = ptr

1.5 单向链表的链接
ptr = head1
whiel ptr != None:
    if ptr.next == None:
        break
    ptr = ptr.next
ptr.next = head2
head = head1

1.6 单向链表的删除
 1.6.1 删除头节点
 head = head.next
 
 1.6.2 删除中间节点
 ptr = head
 while ptr.next != positon:
    ptr = ptr.next
 ptr.next = ptr.next.next

2.环形链表
在单向链表中，需要维持链表头指针，如果链表头指针被破坏或者遗失，整个链表都会遗失。在环形链表中，可以从任何一个节点来遍历其他结点，环形链表通常应用于内存工作区和输入/输出缓冲区。

class circular_linked_list:
    def __init__(self):
        self.data = None   
        self.next = None

2.1 环形链表的建立
与单向链表唯一不同的是将尾节点指向头节点
new_node = circular_linked_list()
head.next = new_node
new_node.next = head

2.2 环形链表的遍历
ptr = head
while True:
    print("节点信息")
    if ptr.next = head:
        break

2.3 在环形链表中插入新节点
 2.3.1 在头部插入
 new_node.next = head
 ptr = head
 while ptr.next != head:
    ptr = ptr.next
 ptr.next = new_node
 head = new_node
 
 2.3.2 在中间插入
 ptr = head
 while ptr.next != position:
    ptr = ptr.next
 new_node.next = ptr.next
 ptr.next = new_node
 
 2.3.3 在尾部插入
 ptr = head
 while ptr.next != head:
    ptr = ptr.next
 ptr.next = new_node
 new_node.next = head
 
2.3 环形链表删除节点
 2.3.1 删除头节点
 ptr = head
 while ptr.next != head:
    ptr = ptr.next
 ptr.next = head.next
 head = head.next
 
 2.3.2 删除头节点外的节点
 ptr = head
 whiel ptr.next != positon:
    ptr = ptr.next
 ptr.next = ptr.next.next

3.双向链表
单向链表和环形链表都是拥有方向性的链表，只能单向遍历，双向链表具有左指针和右指针。如果中间链接有断裂，可经由反方向链表进行遍历，从而快速地重建完整地链表。

class double_linked_list:
    def __init__(self):
        self.data = None
        self.llink = None
        self.rlink = None

3.1 双向链表的建立
head = double_linked_list()
new_node = double_linked_list()
head.rlink = new_node
new_node.llink = head

3.2 双向链表中插入新节点
 3.2.1 在头部插入
 new_node.rlink = head
 head.llink = new_node
 head = new_node

 3.2.2 在中间插入
 ptr = head
 while ptr.next != positon:
    ptr = ptr.next
 ptr.rlink.llink = new_node
 new_node.rlink =  ptr.rlink
 new_node.llink = ptr
 ptr.rlink = new_node
 
 3.3.3 在尾部插入
 ptr = head
 while ptr.next != None:
    ptr = ptr.next
 ptr.rlink = new_node
 new_node.llink = ptr
 new_node.rlink = None

3.3 双向链表删除节点
 3.3.1 删除头节点
 head = head.rlink
 head.llink = None
 
 3.3.2 删除中间节点
 ptr = head
 while ptr != position:
    ptr = ptr.next
 ptr.rlink.llink = ptr.llink
 ptr.llink.rlink = ptr.rlink