数据结构和算法-11.单向链路-重学(自写)-单向链表-后插入、指定插入02

# CY3761 | 2021-12-06 15:45

# 节点类
import copy


class Node:
    def __init__(self, _item, _next=None):
        self._item = _item  # 数据域
        self._next = _next  # 指针域
    
    def next(self, *args):
        if len(args) == 0:
            return self._next
        
        _next = args[0]
        if isinstance(_next, Node) or _next is None:
            self._next = _next
    
    def item(self, *args):
        if len(args) == 0:
            return self._item
        
        self._item = args[0]
    
    def __str__(self):
        iterable = [self._item, hex(id(self))]
        
        if self._next:
            iterable.append(hex(id(self._next)))
        
        return ', '.join(map(str, iterable))
    
    def chain(self):  # 当前节点下的所有关联节点链
        chain = []
        cNext = self._next
        chain.append(self._item)
        
        while cNext:
            chain.append(cNext.item())
            cNext = cNext.next()  # 指引到下一个节点
        
        return chain


# 链表类
class SingleChain:
    def __init__(self):
        self._leng = 0
        self._head = None
    
    # 链表是否为空
    def isEmpty(self):
        return self._leng <= 0
    
    # 链表长度
    def length(self):
        return self._leng
    
    # 链表所有节点(值)
    def items(self):
        if self._head:
            return self._head.chain()
        else:
            return []
    
    # 向链表头添加节点
    def before(self, item):
        # A, A.next(None), self._head = A
        # B, B.next(A), self._head = B
        # C, C.next(B), self._head = C
        # D, D.next(C), self._head = D
        # ...
        
        item = Node(item)  # 新建节点
        item.next(self._head)  # 第一次是None
        
        self._head = item  # 增加的做头
        self._leng += 1
    
    # 向链表尾添加节点
    def after(self, item):
        # A, self._head = A
        # B, A.next(): None, A.next(B)
        # C, B.next(): None, B.next(C)
        # D, C.next(): None, C.next(D)
        
        item = Node(item)  # 新建节点
        
        if not self._head:
            self._head = item
        else:
            aItem = self._head  # A
            
            while aItem.next():  # A.next():
                aItem = aItem.next()  # B.next()
            aItem.next(item)  # A.next(B) | B.next(C) | C.next(D)
        
        self._leng += 1
    
    # 向链表指定位置添加节点
    def where(self, pos, item):
        pos = int(pos)
        
        if pos <= 0:
            return self.before(item)
        elif pos >= self._leng:
            return self.after(item)
        else:
            item = Node(item)  # 新建节点
            aItem = self._head  # A
            bItem = aItem
            
            while pos > 0:
                bItem = aItem
                aItem = aItem.next()
                pos -= 1
            
            item.next(aItem)
            bItem.next(item)
            self._leng += 1
    
    # 删除第一个指定值的节点
    def remove(self, item):
        pass
    
    # 删除指定位置的节点
    def removePos(self, pos):
        pass
    
    # 修改向链表指定位置的节点值
    def update(self, pos, item):
        pass
    
    # 查找指定值的节点是否存在
    def search(self, item):
        pass


if __name__ == '__main__':
    SC = SingleChain()
    print(SC.items(), SC.isEmpty(), SC.length())
    
    for _ in ['A', 'B', 'C', 'D', 'E']:
        print('-' * 80)
        SC.before(_)
        print(SC.items(), SC.isEmpty(), SC.length())
    
    ###########################################################
    
    SC = SingleChain()
    print(SC.items(), SC.isEmpty(), SC.length())
    
    for _ in ['A', 'B', 'C', 'D', 'E']:
        print('-' * 80)
        SC.after(_)
        print(SC.items(), SC.isEmpty(), SC.length())
    
    ###########################################################
    
    print('-' * 80)
    print('-' * 80)
    print(SC.items(), SC.isEmpty(), SC.length())
    SCBack = [copy.deepcopy(SC) for _ in range(6)]
    
    # print(SCBack)
    
    for k, _ in enumerate(['零', '一', '二', '三', '四', '五']):
        SC = SCBack[k]
        print('-' * 80)
        SC.where(k, _)
        print(k, SC.items(), SC.isEmpty(), SC.length())