数据结构和算法-08.链表单向链表

最近身体不舒服，停更了一些天，只能慢慢补上了，这个感觉难点，很绕，说实话我还没搞懂…

# CY3761 | 2021-12-01 10:36

# 节点类
import types


class Node:
    def __init__(self, data, next=None):  # 在生成节点时需要传入值
        self.data = data  # 数据域
        self.next = next  # 指针域 链表的下一个节点(指针域)


# 单向链表类
class SLinkList:
    def __init__(self):
        self._head = None  # 链表的头节点 (当创建对象而并未插入时, 为None)
        self._tail = None  # 链表的尾节点
        self._length = 0  # 链表的个数
    
    def isEmpty(self):  # 链表是否为空
        return self._length == 0
    
    def length(self):  # 链表长度
        return self._length
    
    def items(self):  # 链表中的所有节点的值 组成的列表
        items = []
        
        if self.isEmpty():
            return items
        
        items.append(self._head.data)  # 链表的第一个值
        
        cItem = self._head.next  # 头信息的.next 第二个节点(当只有一个值时, 这里也是第一个节点)
        
        while cItem != self._head:  # 第二个节点开始进入循环, 第一个节点时 头信息的.next = 头信息 = 第一个节点
            items.append(cItem.data)  # cItem.next.data 插入 (第一次循环是头信息next) 第二次下面的那句作更改
            cItem = cItem.next  # cItem = cItem.next |  cItem = self._head.next.next | 一直找下层
        
        return items
    
    def add(self, item):  # 向头部添加节点
        node = Node(item)  # 新建节点
        
        if self.isEmpty():
            self._head = node  # 设置头信息 第一个节点
            node.next = self._head  # 第一个节点的指针域 = 头信息 | 当前 node.next = self._head = node
        else:
            node.next = self._head  # 从第二个节点开始 指针域 = 头信息 (指当前add后的节点的.next必为头信息)
            
            cItem = self._head  # 头信息
            # 这个while第三次有效 | 1、2次不进入while
            while cItem.next != self._head:  # 头信息.next(会变)
                cItem = cItem.next  # 新的 cItem =
            cItem.next = node  # 第二个节点改 next 第一次该改 self._head.next | 最后都将 cItem.next = add 的 节点
        self._length += 1
    
    def append(self, item):  # 向尾部添加结点
        node = Node(item)  # 新建结点
        
        if self._head:
            cItem = self._head
            while cItem.next != self._head:
                cItem = cItem.next
            cItem.next = node
        else:
            self._head = node
        
        self._length += 1
        pass
    
    def insert(self, pos, item):  # 指定位置添加结点
        # 如果输入值计算后 少于等于0 头部处理
        if pos <= 0:
            self.add(item)
            # 如果输入值计算后 大于等于长度 尾部处理
        elif pos > self.length():
            self.append(item)
        else:
            node = Node(item)  # 新建结点
            cItem = self._head
            
            while pos - 1:
                cItem = cItem.next
                pos -= 1
            
            node.next = cItem.next
            cItem.next = node
            self._length += 1
    
    def remove(self, item):  # 删除第一个值为item的节点 值删除一个
        if self.isEmpty():
            return -1
        
        cItem = self._head
        pItem = None
        flag = True
        
        while cItem != self._head or flag:
            flag = False
            
            if cItem.data == item:
                # 如果前驱节点为空 说明需要删除的是第一节点
                if not pItem:
                    lItem = self._head
                    while lItem.next != self._head:
                        lItem = lItem.next
                    
                    lItem.next = self._head.next
                    self._head = cItem.next
                else:
                    pItem.next = cItem.next
                
                self._length -= 1
                
                return 1
            
            pItem = cItem
            cItem = cItem.next
        
        return -1  # 找不到
    
    def modify(self, pos, item):  # 修改指定位置的元素的值
        if o <= pos < self._length:
            cItem = self._head
            while pos:
                cItem = cItem.next
                pos -= 1
            cItem.data = item
            
            return 1
        else:
            return -1
    
    def search(self, item):  # 查找节点是否存在
        if self.isEmpty():
            return -1
        
        cItem = self._head
        flag = True
        
        while cItem != self._head or flag:
            flag = False
            
            if cItem.data == item:
                return 1
            cItem = cItem.next
        
        return -1


def eachSLinkList(args, method, methodString):  # 注意 * 后面要给 keyword-only arguments | 这里就不 * 了
    a = SLinkList()  # 新建数据
    print('-' * 80)
    print(a.length(), a.items(), '初始化')
    
    for _ in args:
        if isinstance(method, types.LambdaType):
            r = method(a, _)
            print(r, a.length(), a.items(), methodString, _)


if __name__ == '__main__':
    eachSLinkList(['A', 'B', 'C'], lambda a, b: a.add(b), 's.add')  # 注意断点 C
    


    # eachSLinkList('A', 'B', 'C', method=lambda a, b: a.append(b), methodString='s.append')
    # 算了这个问就这样发了 理不通
    pass

看这个头疼死我，希望不是必考点。。或者有类库搞定…