MonoLinkedList & duobleLinkedList

　　

class SimplexNode:
    def __init__(self,value,post=None,prev=None):
        self.value=value
        self.post=post
        self.prev=prev

    def __repr__(self):
        # return 'Node: {}'.format(self.value)
        return str(self.value)

    # def __str__(self):
    #     return 'Node: {}'.format(self.value)

class MonoLinkedList:
    def __init__(self):
        self.nodes=[]
        self.head=None
        self.tail=None

    def __len__(self):
        return len(self.nodes)

    def append(self,value):
        node=SimplexNode(value)
        prev=self.tail
        if prev:
            prev.post=node
        else:
            self.head=node
        self.nodes.append(node)
        self.tail=node

    def iternodes(self,rervser=False):
        current=self.head
        if current:
            while current:
                # yield current.value
                yield current
                current=current.post
        else:
            raise SystemError('Empty!')
b=MonoLinkedList()
b.append(SimplexNode('bb'))
b.append(SimplexNode('pp'))
for p in b.iternodes():
    print(p)
print(len(b))

 

class SimplexNode:
    def __init__(self,value,post=None):
        self.value=value
        self.post=post

    def __repr__(self):
        return repr('value: {}'.format(self.value))

class MonoLinkedList:
    def __init__(self):
        self.head=None
        self.tail=None
        self.size=0

    def add(self,value):
        node=SimplexNode(value)
        if self.head is None:
            self.head=node
        else:
            self.tail.post=node
        self.tail=node

    def iternodes(self):
        current=self.head
        while current:
            yield current
            current=current.post

paw=MonoLinkedList()
paw.add('bnm')
paw.add(1)
paw.add(2)
paw.add('uiop')
print(paw.head,paw.tail)
for b in paw.iternodes():
    print(b)

 

class SimplexNode:
    def __init__(self,value,prev=None,post=None):
        self.value=value
        self.prev=prev
        self.post=post

    def __repr__(self):
        return str(self.value)
    def __str__(self):
        return 'nodeValue: {}'.format(self.value)

class DoubleLinkedList:
    def __init__(self): # 初始化默认只产生空双向链表
        self.head=None
        self.tail=None

    def append(self,value):
        node=SimplexNode(value)
        if self.head is None:
            self.head=node
        else:
            self.tail.post=node
            node.prev=self.tail
        self.tail=node

    def iternodes(self,reverse=False): # 实现基础的遍历方法
        current=self.head if not reverse else self.tail
        while current:
            yield current
            current=current.post if not reverse else current.prev

    def pop(self): # version one
        # pop从尾部操作,故以尾部为基准,tail,prev出栈后被GC回收
        if self.tail is None:
            raise Exception('Empty LinkedList!')
        tail=self.tail
        prev=tail.prev
        if prev is None: # 只有一个元素 head==tail,有很多判断方式,以尾部为基准
            self.head=None
            self.tail=None
        else:
            prev.post=None # 只有一个node时,prev为None
            self.tail=prev
        return tail.value

    def getitem(self,index):
        if index<0:
            return None
        current=None
        for i,item in enumerate(self.iternodes()):
            if i==index:
                current=item
                break
        if current is not None:
            return current

    def insert(self,index,value):
        if index<0:
            raise Exception('Index is negative!')
        current=None
        for i,item in enumerate(self.iternodes()):
            if i==index:
                current=item
                break
        if current is None:
            self.append(value)
            return

        prev=current.prev # 待插入对象的前置对象
        node=SimplexNode(value) # 待插入对象

        if prev is None: # i==index==0第一个元素的情况
            self.head=node
            node.post=current
            current.prev=node
            return

        # prev <=> node <=> current
        prev.post=node
        node.prev=prev
        node.post=current
        current.prev=node

    # Signature: list.pop(self,index=-1,/)
    # Docstring:
    # Remove and return item at index (default last)
    # Raises IndexError if list is empty or index is out of range
    def pop(self,index=None): # simulate list.pop
        def _pop(): # for the last item scenario
            tail=self.tail
            prev=tail.prev
            if prev is None: # one itme scenario
                self.head=None
                self.tail=None
            else: # multi item scenario
                prev.post=None
                self.tail=prev
            return tail

        if self.tail is None: # List is empty
            raise IndexError('Index out of range!')

        if index is None:
            return _pop()
        else:
            if index==0: # 第一个item
                current=self.head
                post=current.post
                self.head=post
                post.prev=None
                current.post=None
                return current

            current=None # 待移除item
            for i,node in enumerate(self.iternodes()):
                if i==index:
                    current=node

            if current is None: # 索引超界
                raise IndexError('Index out of range!')

            if i==index: # 最后一个item
                return _pop()
            else: # prev <=> current <=> post 中间item的pop
                prev=current.prev
                post=current.post
                prev.post=post
                post.prev=prev
                current.prev=None
                current.post=None
                return current


pat=DoubleLinkedList()
for b in range(4):
    pat.append(b)

for b in pat.iternodes(reverse=True):
    print(b)

# print(pat.getitem(0))
print('*'*40+'insert method'+'*'*40)
pat.insert(1,88)
pat.insert(1,99)
pat.insert(100,'bnm')
pat.insert(0,'uiop')
for b in pat.iternodes():
    print(b)
print('~'*40+'pop method'+'~'*40)
print(pat.pop(3))
# print(pat.pop(0))
print('$'*60)
for b in pat.iternodes():
    print(b)

 

class SimplexNode:
    def __init__(self,value,prev=None,post=None):
        self.value=value
        self.prev=None
        self.post=None

    def __repr__(self):
        return repr(self.value)

class DoubleLinkedList:
    def __init__(self):
        self.head=None
        self.tail=None
        self.size=0

    def append(self,value):
        node=SimplexNode(value)
        if self.head is None:
            self.head=node
        else:
            self.tail.post=node
            node.prev=self.tail
        self.tail=node

    def insert(self,index,value):
        if index<0:
            raise ValueError('Index {} out of range!'.format(index))
        current=None
        for i,node in enumerate(self.iternodes()):
            if i==index:
                current=node
                break
        if current is None:
            self.append(value)
            return
        node=SimplexNode(value)
        prev=current.prev

        if prev is None: # head node
            self.head=node
        else:
            prev.post=node
            node.prev=prev
        node.post=current
        current.prev=node

    def pop(self):
        if self.tail is None:
            raise Exception('{} Empty'.format(self))
        tail=self.tail
        prev=tail.prev

        if prev is None: # one item scenario
            self.head=None
            self.tail=None
        else:
            prev.post=None
            tail.prev=None
            self.tail=prev
        return tail.value

    def remove(self,index):
        if index<0:
            raise ValueError('Index {} is negative'.format(index))
        if self.tail is None:
            raise Exception('Empty!')

        current=None
        for i,node in enumerate(self.iternodes()):
            if i==index:
                current=node
                break
        if current is None:
            raise ValueError('Index {} out of range!'.format(index))
        prev=current.prev
        post=current.post

        if prev is None and post is None: # one item scenario
            self.head=None
            self.tail=None
        elif prev is None:
            self.head=post
            post.prev=None
        elif post is None:
            self.tail=prev
            prev.post=None
        else:
            prev.post=post
            post.prev=prev

        del  current

    def iternodes(self,reverse=False):
        current=self.tail if reverse else self.head
        while current:
            yield current
            current=current.prev if reverse else current.post

pat=DoubleLinkedList()
pat.append('bnm')
for b in range(1,6):
    pat.append(b)
pat.append('uiop')
print(pat.head,pat.tail)
for p in pat.iternodes(True):
    print(p)
print('$'*60)
pat.remove(6)
pat.remove(5)
for p in pat.iternodes():
    print(p)

pat.insert(3,5)
pat.insert(20,'vbn')
pat.insert(8,20)