无序表也可以使用链表来实现。与用列表实现无序表不同，链表在元素插入和删除时具有更高的效率，因为不需要像列表那样移动元素的位置。

以下是基于链表实现无序表的完整 Python 示例，包括插入、删除、查找等操作。

无序表的链表实现

1.节点类

链表的每个节点包含两部分：

• 数据部分 data
• 指向下一个节点的指针 next

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

2.无序表类

无序表类包含以下功能：

• 插入元素（add 方法）：在链表头部插入新元素。
• 删除元素（remove 方法）：查找到指定值并删除。
• 查找元素（search 方法）：检查表中是否存在某个值。
• 大小（size 方法）：返回链表中元素的个数。
• 判断空表（is_empty 方法）：判断表是否为空。
• 遍历链表（traverse 方法）：输出链表中所有元素。

class UnorderedList:
    def __init__(self):
        self.head = None  # 初始化时，链表为空

    def is_empty(self):
        # 判断链表是否为空
        return self.head is None

    def add(self, item):
        # 在链表头部插入新元素
        new_node = Node(item)
        new_node.next = self.head
        self.head = new_node

    def size(self):
        # 计算链表中节点的个数
        count = 0
        current = self.head
        while current is not None:
            count += 1
            current = current.next
        return count

    def search(self, item):
        # 查找链表中是否存在某个值
        current = self.head
        while current is not None:
            if current.data == item:
                return True
            current = current.next
        return False

    def remove(self, item):
        # 删除链表中指定值的节点
        current = self.head
        previous = None
        while current is not None:
            if current.data == item:
                if previous is None:
                    # 如果删除的是头节点
                    self.head = current.next
                else:
                    # 如果删除的是非头节点
                    previous.next = current.next
                return
            previous = current
            current = current.next
        raise ValueError(f"Item {item} not found in the list.")

    def traverse(self):
        # 遍历链表并打印所有节点
        current = self.head
        while current is not None:
            print(current.data, end=" -> ")
            current = current.next
        print("None")  # 链表结束

示例使用

以下是如何使用链表实现的无序表来进行操作的例子：

# 创建无序表
ul = UnorderedList()

# 添加元素
ul.add(10)
ul.add(20)
ul.add(30)

# 遍历链表
print("Initial list:")
ul.traverse()  # 输出：30 -> 20 -> 10 -> None

# 查找元素
print("Is 20 in the list?", ul.search(20))  # 输出：True
print("Is 40 in the list?", ul.search(40))  # 输出：False

# 删除元素
ul.remove(20)
print("After removing 20:")
ul.traverse()  # 输出：30 -> 10 -> None

# 获取大小
print("Size of the list:", ul.size())  # 输出：2

# 判断是否为空
print("Is the list empty?", ul.is_empty())  # 输出：False

# 再次删除元素
ul.remove(30)
ul.remove(10)
print("After removing all elements:")
print("Is the list empty?", ul.is_empty())  # 输出：True

实现原理及特点

1. 插入操作（头部插入）：
2. 每次插入一个新元素时，都将新元素放在链表的头部，时间复杂度为 O(1)。
3. 删除操作：
4. 删除需要先查找到对应节点，时间复杂度为 O(n)。
5. 查找操作：
6. 查找需要遍历链表，时间复杂度为 O(n)。
7. 动态存储：
8. 链表相比列表的优点是它不需要预先分配存储空间，适合元素动态变化的场景。

每天坚持学习一点点，不求有回报，只愿可以丰富自己！！！