单链表的实现-python

实现如下

"""
带头结点的单链表
"""

from typing import Optional, Any


class Node(object):

    def __init__(self, value: Any = None):
        """单链表表结点

        Args:
            value (Any): 数据域
        """
        self._value: Any = value
        self._follow: Optional[Node] = None

    @property
    def follow(self):
        return self._follow

    @follow.setter
    def follow(self, value):
        if not isinstance(value, Node) and value is not None:
            raise TypeError('follow must be a Node instance or None!')
        self._follow = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, value):
        self._value = value

    def __str__(self):
        return f'Node(value={self.value})'

    def __repr__(self):
        return f'<object Node({self.value}) at {hex(id(self))}>\n'


class LinkList(object):

    def __init__(self):
        self._head = Node()
        self._length = 0

    @property
    def head(self):
        return self._head

    @property
    def length(self):
        return self._length

    @length.setter
    def length(self, value: int):
        self._length = value

    def traverse(self) -> None:
        """遍历单链表"""
        if self.head.follow is None:
            print(None)
            return None
        p = self.head
        print('head >', end=' ')
        while p.follow is not None:
            p = p.follow
            print(p.value, '>', end=' ')
        print('None')

    def create_from_lst(self, lst: list[Any]) -> Node:
        """根据一个列表创建一个单链表，注意创建出来的单链表顺序和列表中元素顺序一致

        Args:
            lst (list[Any]): 数据列表

        Returns:
            Node: 头结点
        """
        p = self.head
        for item in lst:
            node = Node(item)
            p.follow = node
            p = p.follow
        p.follow = None
        self.length = len(lst)
        return self.head

    def get_elem(self, i: int) -> bool | Node:
        """当第i个元素存在时，返回第i个结点，否则返回False

        Args:
            i (int): 第i个元素 -- 位序 而不是偏移

        Returns:
            bool | Node: 当第i个元素存在时，返回第i个结点，否则返回False
        """
        if i == 0:
            return self.head
        if self.head is None or i < 0:
            return False
        p = self.head
        j = 0
        while p.follow is not None and j < i:
            p = p.follow
            j += 1
        if j == i:
            return p
        return False

    def locate_elem(self, elem: Any) -> Node | None:
        """查找元素，返回Node节点

        Args:
            elem (Any): 需要查找的值

        Returns:
            Node | bool: 如果找到，返回对应的Node，否则返回
        """
        if self.head is None:
            return None
        p = self.head.follow
        while p is not None and p.value != elem:
            p = p.follow
        return p

    def head_insert(self) -> Node:
        """头插法建立单链表

        Returns:
            Node 建立好的单链表的头结点
        """
        if self.head.follow is None:
            while True:
                enter = input('Please input the value of node to create the Single Link List!')
                if enter == '9999':
                    break
                # 假设用户输入完全符合条件
                new_node = Node(int(enter))
                new_node.follow = self.head.follow
                self.head.follow = new_node
                self.length += 1
        return self.head

    def tail_insert(self) -> Node:
        """尾插法建立单链表

        Returns:
            Node 建立好的单链表
        """
        if self.head.follow is None:
            p = self.head
            while True:
                print('Please input the value of node to create the Single Link List! >>> ')
                enter = input()
                if enter == '9999':
                    break
                # 假设用户输入完全符合条件
                new_node = Node(int(enter))
                new_node.follow = p.follow
                p.follow = new_node
                p = p.follow
                self.length += 1
        return self.head

    def insert_before_node(self, p: Node, e: Any) -> None | Node:
        """在指定结点（p）之前插入一个结点

        Args:
            p (Node): 在此结点之前插入节点
            e (Any): 插入节点的数据域

        Returns:
            None | Node: 如果成功插入，那么返回head，否则返回None
        """
        if self.head is None:
            print('插入失败，因为单链表为空')
            return None
        if self.head == p:
            print('插入失败，因为单链表没有结点！')
            return None
        q = self.head
        while q.follow != p and q.follow is not None:
            q = q.follow
        if q.follow is None:
            print(f'节点{p}不在单链表{self.head}中！')
            return None
        s = Node(e)
        s.follow = q.follow
        q.follow = s
        self.length += 1
        return self.head

    def insert_after_node(self, p: Node, e: Any) -> None | Node:
        """在指定根节点后插入一个结点

        Args:
            p (Node): 需要在此节点之后插入新节点
            e (Any): 插入的新节点的数据域

        Returns:
            None | Node: 如果成功插入，那么返回head，否则返回None
        """
        if self.head is None:
            print('插入失败，因为单链表为空')
            return None
        q = self.head
        while q != p and q is not None:
            q = q.follow
        if q is None:
            print('节点{p}不在单链表{head}中！')
            return None
        s = Node(e)
        s.follow = q.follow
        q.follow = s
        self.length += 1
        return self.head

    def delete(self, p: Node) -> bool:
        """删除单链表中的结点p

        Args:
            p (Node): 需要删除的结点p

        Returns:
            bool: 删除成功返回True，失败返回False
        """
        if self.head is None:
            return False
        if self.head == p:
            print('不能删除头结点！')
            return False
        q = self.head
        while q.follow != p and q.follow is not None:
            q = q.follow
        if q.follow is None:
            print(f'在单链表{self.head}中没有{p}节点！')
            return False
        q.follow = q.follow.follow
        p.follow = None
        self.length -= 1
        return True

    def insert_locate(self, i: int, e: Any) -> Node | bool:
        """在单链表的第i个位置插入一个节点node

        Args:
            i (int): 要插入的位置(从1开始)
            e (Any): 要插入的结点的值

        Returns:
            Node | bool: 插入成功返回头结点，插入失败返回False
        """
        if self.head is None:
            return False
        locate_node = self.get_elem(i - 1)
        if not locate_node:
            return False
        if locate_node.follow is None:
            return False
        s = Node(e)
        s.follow = locate_node.follow
        locate_node.follow = s
        self.length += 1
        return self.head

    def delete_locate(self, i: int) -> Node | bool:
        """删除第i个元素

        Args:
            i (int): 元素的位置(从1开始)

        Returns:
            Node | bool: 如果删除成功，返回头结点，如果删除失败，返回False
        """
        if self.head is None:
            return False
        res_get = self.get_elem(i - 1)
        if not res_get:
            return False
        if res_get.follow is None:
            print(f'错误的参数{i}!')
            return False
        p = res_get.follow
        res_get.follow = p.follow
        p.follow = None
        del p
        self.length -= 1
        return self.head