链表

链表：通过指针对每个元素进行存储

#假设无序双向链表
class Node:
    def __init__(self, prev, next, key):
        '''节点（前继，后继，关键字）'''
        self.prev = prev
        self.next = next
        self.key = key

class DoubleLinkedList:
    '''无序双链表'''
    def __init__(self,A):
        '''根据头指针初始化一个空链表，再通过给定的数据把数据加入到链表中,通过列表属性反映链表'''
        self.head = None
        self.list=[]
        A.reverse()
        for i in A:
            node=Node(None,None,i)
            self.list_insert(node)


    def list_search(self, k):
        '''链表的搜索：从第一个节点开始依次与关键值k比较，如果不是，节点后移，返回搜索到的节点'''
        x = self.head
        while x != None and x.key != k:
            x = x.next
        return x

    def list_insert(self, x):
        '''链表的插入，头插法：如果头指针不为None则把x设为头结点的前继节点
        再把头指针指向x，此时把x的前继置为None'''
        x.next = self.head
        if self.head != None:
            self.head.prev = x
        self.head = x
        x.prev = None
        self.list.append(x.key)

    def list_delete(self, x):
        '''链表的删除：如果节点的前继不为None（表示x前面有人），
        就把原来（x指向x后继)变为现在（x的前继指向x的后继），删除了x的前继指向x的指针
        否则（相当于x为头结点）就把头指针指向x的后继，
        如果x存在后继（x不是尾节点）就把原来（x指向x前继）变为（x后继指向x前继），'''
        if x.prev != None:
            x.prev.next = x.next
        else:
            self.head = x.next
        if x.next != None:
            x.next.prev = x.prev
        self.list.remove(x.key)
A=[9,16,4,1]
#初始化
L=DoubleLinkedList(A)
print(L)
print(L.list)
print(L.head.key)
print('#'*60)
#插入节点
L.list_insert(Node(None,None,25))
print(L.list)
print(L.head.key)
print('#'*60)
#先搜寻节点，再删除
node=L.list_search(4)
L.list_delete(node)
print(L.list)
print(L.head.key)
-------------------------------------------------
<__main__.DoubleLinkedList object at 0x03B17930>
[1, 4, 16, 9]
9
############################################################
[1, 4, 16, 9, 25]
25
############################################################
[1, 16, 9, 25]
25

 

class DoublyLinkedList2:
    '''有哨兵的双向循环链表，哨兵用于简化边界条件的处理'''
    def __init__(self,nil):
        ''''链表初始化，设置哨兵（一个空点），只有哨兵链表为空'''
        self.nil=nil

    def list_search(self,k):
        x=self.nil.next
        while x !=self.nil and x.key!=k:
            x=x.next
        return x

    def list_insert(self,x):
        x.next=self.nil.next
        self.nil.next.prev=x
        self.nil.next=x
        x.prev=self.nil

    def list_delete(self,x):
        x.prev.next=x.next
        x.next.prev=x.prev

 python中指针和对象的实现：对象的多数组表示：每个属性对应一个数组，一个对象有多个属性

class pointer_object:
    '''指针和对象的实现'''
    def __init__(self,L,free,key,l_next,prev):
        '''初始化：链表L，自由表的第一个元素：free'''
        self.L=L
        self.free=free
        self.key=key
        self.l_next=l_next
        self.prev=prev
    def allocate_object(self):
        '''对象的分配'''
        if self.free==None:
            print("out of space")
        else:#自由表和链表相互交错
            x=self.free
            print("x:",x)
            self.free=self.l_next[x-1]
            print("x.next:",self.free)
            return x
    def free_object(self,x):
        '''对象的释放'''
        self.l_next[x-1]=self.free
        self.free=x
    def list_insert(self,x):
        '''列表插入'''
        self.l_next[x-1]=self.L
        if self.L!=None:
            self.prev[self.L-1]=x
        self.L=x
        self.prev[x-1]=None

L=7
free=4
key=[None,4,1,None,16,None,9,None]
l_next=[-1,3,-1,8,2,1,5,6]
prev=[None,5,2,None,7,None,-1,None]
po=pointer_object(L,free,key,l_next,prev)
print(po.allocate_object())

po.key[3]=25
po.list_insert(4)
print(po.l_next)
print(po.key)
print(po.prev)
-----------------------------------------
x: 4
x.next: 8
4
[-1, 3, -1, 7, 2, 1, 5, 6]
[None, 4, 1, 25, 16, None, 9, None]
[None, 5, 2, None, 7, None, 4, None]