基于python的数据结构 之 【单链表】

# -*- coding:utf-8 -*-
# Author:        Greed_Vic(PL Z)
# Product_name:  PyCharm
# File_name:     linked list 
# @Time:         21:58  2021/5/17
"""
    1、 {root、length
    2、 {init、append、appendleft、iter_node、remove、find、popleft、clear
"""

class Node(object):
    """
    创建一个Node节点
    这就像是单个空间
    """
    def __init__(self, value=None, next=None):
        self.value, self.next = value, next

class LinkedList(object):
    """
    这是链式结构，用来操作节点
    """
    def __init__(self, maxsize=None):
        """
        初始化，设定的最大值，实际上没有空间设定的
        :param maxsize:
        """
        self.maxsize = maxsize
        self.root = Node()  # 创建一个Node对象
        self.length = 0  # 长度为一
        self.tailnode = None

    def __len__(self):
        return self.length  # 返回长度

    def append(self, value):
        if self.maxsize is not None and len(self) > self.maxsize:  # 判断是否长度超过了最大值
            raise Exception("Full")
        node = Node(value)  # 创建一个节点
        tailnode = self.tailnode  #
        if tailnode is None:  # 如果还没有产生一个节点，尾巴就是根节点所连的地方
            self.root.next = node
        else:  # 如果已经有节点了，那么原本根节点的下一个节点就是这个节点
            tailnode.next = node
        self.tailnode = node  # 更新根节点
        self.length += 1  # 长度加一

    def appendleft(self, value):
        headnode = self.root.next  # 获取根节点的下一个节点，也就是原来的头节点
        node = Node(value)  # 创建新节点
        self.root.next = node  # 更新头节点
        node.next = headnode  # 新的头节点的下一个节点连上原来的头节点
        self.length += 1  # 增加长度

    def iter_node(self):
        """
        迭代器
        """
        curnode = self.root.next  # 获取头节点
        while curnode is not self.tailnode:  # 如果不是尾部节点
            yield curnode  # yield
            curnode = curnode.next
        yield curnode

    def __iter__(self):
        for node in self.iter_node():
            yield node.value

    def remove(self, value):
        prevnode = self.root  # 根节点--之前的节点
        curnode = self.root.next  # 当前节点
        for curnode in self.iter_node():
            if curnode.value == value:  # 找到指定数值的节点
                prevnode.next = curnode.next  # 前指针指向当前的下一个指针
                if curnode is self.tailnode:  # 如果是尾巴节点
                    self.tailnode = prevnode  # 更新尾巴节点
                del curnode  # 删除当前节点
                self.length -= 1  # 长度减
                return 1
            else:
                prevnode = curnode  # 进行下一个
        return -1

    def find(self, value):
        index = 0
        for node in self.iter_node():  # 遍历
            if node.value == value:  # 找到对应节点
                return index  # 返回节点的索引值
            index += 1
        return -1  # 找不到就返回-1

    def popleft(self):
        if self.root.next is None:  # 如果不存在节点，除了根节点
            raise Exception("pop fro empty LinkedList")
        headnode = self.root.next  # 获取根节点
        self.root.next = headnode.next  # 接上第二个节点
        self.length -= 1  # 减一
        value = headnode.value  # 获取值
        del headnode  # 删除节点
        return value

    def clear(self):
        for node in self.iter_node():
            del node
        self.root.next = None
        self.length = 0


if __name__ == '__main__':
    """
    检测
    """
    def test_linked_list():
        ll = LinkedList()

        ll.append(0)
        ll.append(1)
        ll.append(2)

        assert len(ll) == 3
        assert ll.find(2) == 2
        assert ll.find(3) == -1

        ll.remove(0)
        assert len(ll) == 2
        assert ll.find(0) == -1

        assert list(ll) == [1, 2]

        ll.appendleft(0)
        assert list(ll) == [0, 1, 2]
        assert len(ll) == 3

        headvalue = ll.popleft()
        assert headvalue == 0
        assert len(ll) == 2
        assert list(ll) == [1, 2]

        ll.clear()
        assert len(ll) == 0


    test_linked_list()