Python数据结构完整实例:栈/队列/链表/树

### 栈（Stack）
栈是一种后进先出（Last In First Out, LIFO）的数据结构。想象一下一叠盘子，你只能从顶部添加或移除盘子，最后放上去的盘子会是第一个被拿走的。栈的主要操作包括“push”（压栈，即添加元素到栈顶）、“pop”（出栈，即移除栈顶元素并返回该元素）、以及“peek”（查看栈顶元素但不移除）。栈是解决许多编程问题的有用工具，例如在函数调用、表达式求值和括号匹配等场景中。

### 队列（Queue）
队列是一种先进先出（First In First Out, FIFO）的数据结构。可以将队列想象成排队买票，最先排队的人将会是第一个买到票并离开队伍的人。队列的主要操作包括“enqueue”（入队，即在队尾添加一个元素）和“dequeue”（出队，即移除队首元素并返回该元素）。队列广泛用于实现消息处理系统、任务调度等场景。

### 链表（LinkedList）
链表是一种由节点组成的线性集合，每个节点包含数据部分和指向下一个节点的指针（链接）。链表按照节点中的指针连接顺序排列。链表可以是单向的（每个节点只有一个指向下一个节点的链接）或双向的（节点包含指向前一个和下一个节点的链接）。链表的优点是动态大小，可以灵活地添加或删除节点。它们常用于实现文件系统、哈希表和邻接表。

### 树（Tree）
树是一种分层的数据结构，由根节点及其子节点组成，每个节点除了根节点外都恰有一个父节点，并且每个节点可以有零个或多个子节点。树的一个特例是二叉树，其中每个节点最多有两个子节点。树广泛用于表示具有层次结构的数据，例如文件系统的目录结构、XML/HTML数据以及数据库索引。树的一个特殊形式是二叉搜索树，它对于数据的存储和搜索非常有效，因为它保持了一个有序的结构，使得搜索、添加和删除操作都可以以对数时间复杂度进行。
 

下面将为每个数据结构提供一个更完整的实例，包括栈（Stack）、队列（Queue）、链表（LinkedList）、和树（Tree）的基本操作。这些实例将包括一些基本方法，如添加、删除和打印元素。

### 栈（Stack）

class Stack:
    def __init__(self):
        self.items = []
    
    def push(self, item):
        """添加元素到栈顶"""
        self.items.append(item)
    
    def pop(self):
        """移除并返回栈顶元素"""
        if not self.is_empty():
            return self.items.pop()
        return "Stack is empty"
    
    def peek(self):
        """返回栈顶元素"""
        if not self.is_empty():
            return self.items[-1]
        return "Stack is empty"
    
    def is_empty(self):
        """检查栈是否为空"""
        return len(self.items) == 0
    
    def size(self):
        """返回栈的大小"""
        return len(self.items)
    
    def __str__(self):
        """打印栈的元素"""
        return str(self.items)

# 使用栈
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
print(stack)  # 输出: [1, 2, 3]
print(stack.pop())  # 输出: 3
print(stack)  # 输出: [1, 2]

### 队列（Queue）

class Queue:
    def __init__(self):
        self.items = []
    
    def enqueue(self, item):
        """在队尾插入元素"""
        self.items.insert(0, item)
    
    def dequeue(self):
        """移除并返回队首元素"""
        if not self.is_empty():
            return self.items.pop()
        return "Queue is empty"
    
    def is_empty(self):
        """检查队列是否为空"""
        return len(self.items) == 0
    
    def size(self):
        """返回队列的大小"""
        return len(self.items)
    
    def __str__(self):
        """打印队列的元素"""
        return str(self.items[::-1])

# 使用队列
queue = Queue()
queue.enqueue('a')
queue.enqueue('b')
queue.enqueue('c')
print(queue)  # 输出: ['a', 'b', 'c']
print(queue.dequeue())  # 输出: 'a'
print(queue)  # 输出: ['b', 'c']

### 链表（LinkedList）
这段代码定义了一个简单的链表类(LinkedList)和一个节点类(Node)。你可以通过调用append()方法在链表末尾添加节点，通过调用prepend()方法在链表开头添加节点，通过调用delete()方法删除指定值的节点，通过调用print_list()方法打印链表的内容。

class Node:
    # 定义节点类
    def __init__(self, data):
        # 初始化节点对象
        self.data = data  # 节点数据
        self.next = None  # 指向下一个节点的指针，默认为None

class LinkedList:
    # 定义链表类
    def __init__(self):
        # 初始化链表对象
        self.head = None  # 头节点，默认为None

    def append(self, data):
        # 在链表末尾添加新节点
        new_node = Node(data)  # 创建新节点对象
        if not self.head:
            # 如果链表为空，则将新节点设置为头节点;not 是 Python 中的逻辑运算符，用于对布尔值进行取反操作。
            self.head = new_node
            return
        last_node = self.head
        # 遍历链表，找到最后一个节点
        while last_node.next:
            last_node = last_node.next
        # 将新节点链接到最后一个节点的next指针上
        last_node.next = new_node

    def prepend(self, data):
        # 在链表开头添加新节点
        new_node = Node(data)  # 创建新节点对象
        new_node.next = self.head  # 将新节点的next指针指向当前头节点
        self.head = new_node  # 将新节点设置为头节点

    def delete(self, key):
        # 删除链表中第一个匹配给定值的节点
        current_node = self.head
        # 如果头节点即为要删除的节点
        if current_node and current_node.data == key:
            self.head = current_node.next  # 更新头节点为下一个节点
            current_node = None  # 删除当前节点
            return
        prev = None
        # 遍历链表，直到找到匹配的节点或遍历完整个链表
        while current_node and current_node.data != key:
            prev = current_node  # 保存当前节点作为上一个节点
            current_node = current_node.next  # 移动到下一个节点
        if current_node is None:
            # 如果未找到匹配的节点
            return
        prev.next = current_node.next  # 更新上一个节点的next指针，跳过当前节点
        current_node = None  # 删除当前节点

    def print_list(self):
        # 打印链表中的所有节点数据
        current_node = self.head
        while current_node:
            print(current_node.data, end=" -> ")  # 打印当前节点数据
            current_node = current_node.next  # 移动到下一个节点
        print("None")  # 打印链表末尾

# 示例用法
if __name__ == "__main__":
    linked_list = LinkedList()
    linked_list.append(1)
    linked_list.append(2)
    linked_list.append(3)
    linked_list.append(4)
    linked_list.prepend(0)
    linked_list.print_list()
    linked_list.delete(2)
    linked_list.print_list()

### 二叉树（Binary Tree）

class TreeNode:
    def __init__(self, value):
        self.val = value
        self.left = None
        self.right = None
 
def preorderTraversal(root):
    if root is None:
        return []
    result = [root.val]  # 访问当前节点
    result.extend(preorderTraversal(root.left))  # 递归遍历左子树
    result.extend(preorderTraversal(root.right))  # 递归遍历右子树
    return result
 
 
# 示例用法
# 创建二叉树
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
 
# 进行前序遍历
print("前序遍历结果:", preorderTraversal(root))

class TreeNode:
    def __init__(self, key):
        self.left = None
        self.right = None
        self.val = key

def insert(root, key):
    """在二叉树中插入元素"""
    if root is None:
        return TreeNode(key)
    else:
        if root.val < key:
            root.right = insert(root.right, key)
        else:
            root.left = insert(root.left, key)
    return root

def inorder_traversal(root):
    """中序遍历二叉树"""
    if root:
        inorder_traversal(root.left)
        print(root.val, end=' ')
        inorder_traversal(root.right)

# 使用二叉树
root = None
root = insert(root, 50)
insert(root, 30)
insert(root, 20)
insert(root, 40)
insert(root, 70)
insert(root, 60)
insert(root, 80)
inorder_traversal(root)  # 输出: 20 30 40 50 60 70 80

这些实例展示了如何使用Python类来实现和操作基本的数据结构。 

----------------

Python中的列表（List）是一种可变的序列，可以存储不同类型的数据项。列表是非常灵活且功能强大的数据结构，支持多种操作，包括添加、删除、修改元素，以及对列表进行排序、查询等。以下是列表的一些基本方法及其详细介绍：

1. `append()`描述：在列表末尾添加一个新的元素。
语法：`list.append(elem)`
参数：  - `elem`：要添加到列表末尾的元素。

2. `extend()`描述：将一个列表（或任何可迭代的）的所有元素添加到另一个列表的末尾。
语法：`list.extend(iterable)`
参数：  - `iterable`：任何可迭代的对象，其所有元素都将被添加到列表末尾。

3. `insert()`描述：在指定位置插入一个新的元素。
语法：`list.insert(index, elem)`
参数：  - `index`：元素要插入的位置。  - `elem`：要插入的元素。

4. `remove()`描述：移除列表中第一个匹配的元素。
语法：`list.remove(elem)`
参数：  - `elem`：要从列表中移除的元素。

5. `pop()`描述：移除列表中的一个元素（默认最后一个元素），并返回该元素的值。
语法：`list.pop([index])`
参数：  - `index`（可选）：要移除元素的索引位置。默认为-1，即最后一个元素。

6. `clear()`描述：移除列表中的所有元素。
语法：`list.clear()`

7. `index()`
描述：返回列表中第一个匹配元素的索引位置。
语法：`list.index(elem[, start[, end]])`
参数：  - `elem`：要查找的元素。  - `start`（可选）：开始搜索的起始位置。  - `end`（可选）：停止搜索的结束位置。

8. `count()`
描述：返回列表中元素出现的次数。语法：`list.count(elem)`
参数：  - `elem`：要计数的元素。

9. `sort()`描述：对列表中的元素进行排序。
语法：`list.sort(key=None, reverse=False)`
参数：  - `key`（可选）：一个函数，用于从每个列表元素中提取比较键（例如，`key=str.lower`）。
  - `reverse`（可选）：排序规则，`reverse=True`表示降序，`False`表示升序（默认）。

10. `reverse()`描述：反转列表中的元素。
语法：`list.reverse()`

11. `copy()`描述：返回列表的一个浅拷贝。
语法：`list.copy()`

这些方法为列表提供了强大的功能，使得列表成为Python中使用最频繁的数据结构之一。通过结合使用这些方法，可以轻松地对列表进行各种操作，满足不同的编程需求。