Python数据结构

一、链表

节点：

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

 上述代码定义了一个Node类，每个节点包含一个data属性用于存储数据，以及一个next属性用于指向下一个节点。

单链表：

class LinkedList:
    def __init__(self):
        self.head = None

    def is_empty(self):
        return self.head is None

    def append(self, data):
        new_node = Node(data)
        if self.is_empty():
            self.head = new_node
        else:
            cur = self.head
            while cur.next:
                cur = cur.next
            cur.next = new_node

    def insert(self, data, position):
        new_node = Node(data)
        if position == 0:
            new_node.next = self.head
            self.head = new_node
        else:
            cur = self.head
            count = 0
            while cur and count < position - 1:
                cur = cur.next
                count += 1
            if cur:
                new_node.next = cur.next
                cur.next = new_node

    def delete(self, data):
        if self.is_empty():
            return
        if self.head.data == data:
            self.head = self.head.next
            return
        cur = self.head
        while cur.next and cur.next.data != data:
            cur = cur.next
        if cur.next:
            cur.next = cur.next.next

    def search(self, data):
        cur = self.head
        while cur:
            if cur.data == data:
                return True
            cur = cur.next
        return False

    def print_list(self):
        cur = self.head
        while cur:
            print(cur.data, end=" ")
            cur = cur.next
        print()

上述代码定义了一个LinkedList类，包含了以下几个方法：

• __init__()：初始化一个空链表。
• is_empty()：判断链表是否为空。
• append(data)：在链表末尾添加一个节点。
• insert(data, position)：在指定位置插入一个节点。
• delete(data)：删除第一个值为data的节点。
• search(data)：判断链表中是否存在值为data的节点。
• print_list()：打印链表中的所有节点。

双链表：

class DoublyLinkedList:
    def __init__(self):
        self.head = None

    def is_empty(self):
        return self.head is None

    def append(self, data):
        new_node = Node(data)
        if self.is_empty():
            self.head = new_node
        else:
            cur = self.head
            while cur.next:
                cur = cur.next
            cur.next = new_node
            new_node.prev = cur

    def insert(self, data, position):
        new_node = Node(data)
        if position == 0:
            new_node.next = self.head
            if self.head:
                self.head.prev = new_node
            self.head = new_node
        else:
            cur = self.head
            count = 0
            while cur and count < position - 1:
                cur = cur.next
                count += 1
            if cur:
                new_node.next = cur.next
                if cur.next:
                    cur.next.prev = new_node
                cur.next = new_node
                new_node.prev = cur

    def delete(self, data):
        if self.is_empty():
            return
        if self.head.data == data:
            self.head = self.head.next
            if self.head:
                self.head.prev = None
            return
        cur = self.head
        while cur.next and cur.next.data != data:
            cur = cur.next
        if cur.next:
            cur.next = cur.next.next
            if cur.next:
                cur.next.prev = cur

    def search(self, data):
        cur = self.head
        while cur:
            if cur.data == data:
                return True
            cur = cur.next
        return False

    def print_list(self):
        cur = self.head
        while cur:
            print(cur.data, end=" ")
            cur = cur.next
        print()

二、栈

        在Python中，可以使用列表（List）来实现栈。栈是一种后进先出（LIFO）的数据结构，可以通过列表的append()方法向栈顶添加元素，使用pop()方法从栈顶移除元素。        

class Stack:
    def __init__(self):
        self.items = []

    def is_empty(self):
        return len(self.items) == 0

    def push(self, item):
        self.items.append(item)

    def pop(self):
        if self.is_empty():
            return None
        return self.items.pop()

    def peek(self):
        if self.is_empty():
            return None
        return self.items[-1]

    def size(self):
        return len(self.items)

在上述示例中，Stack类具有以下几个方法：

• __init__()：初始化一个空栈。
• is_empty()：判断栈是否为空。
• push(item)：将元素item压入栈顶。
• pop()：从栈顶弹出并返回元素。
• peek()：返回栈顶元素，但不移除。
• size()：返回栈中元素的个数。

三、队列

        在Python中，可以使用列表（List）来实现队列。队列是一种先进先出（FIFO）的数据结构，可以通过列表的append()方法向队尾添加元素，使用pop(0)方法从队首移除元素。        

class Queue:
    def __init__(self):
        self.items = []

    def is_empty(self):
        return len(self.items) == 0

    def enqueue(self, item):
        self.items.append(item)

    def dequeue(self):
        if self.is_empty():
            return None
        return self.items.pop(0)

    def size(self):
        return len(self.items)

 在上述示例中，Queue类具有以下几个方法：

• __init__()：初始化一个空队列。
• is_empty()：判断队列是否为空。
• enqueue(item)：将元素item添加到队列的末尾。
• dequeue()：移除并返回队列的第一个元素。
• size()：返回队列中元素的个数。

四、图

图（Graph）是一种非线性的数据结构，由节点（顶点）和边组成。在Python中，可以使用字典（Dictionary）和列表（List）的组合来实现图。字典用于存储节点和其相邻节点的关系，列表用于存储所有的节点。

class Graph:
    def __init__(self):
        self.graph = {}

    def add_node(self, node):
        if node not in self.graph:
            self.graph[node] = []

    def add_edge(self, node1, node2):
        if node1 in self.graph and node2 in self.graph:
            self.graph[node1].append(node2)
            self.graph[node2].append(node1)

    def get_neighbors(self, node):
        if node in self.graph:
            return self.graph[node]
        return []

    def get_nodes(self):
        return list(self.graph.keys())

在上述示例中，Graph类具有以下几个方法：

• __init__()：初始化一个空图。
• add_node(node)：添加一个节点到图中。
• add_edge(node1, node2)：添加一条边连接两个节点。
• get_neighbors(node)：返回节点的相邻节点列表。
• get_nodes()：返回图中所有节点的列表。

五、树

        在Python中，可以使用类和对象的方式来实现树。树是一种非线性的数据结构，由节点和边组成，每个节点可以有多个子节点。

class TreeNode:
    def __init__(self, data):
        self.data = data
        self.children = []

    def add_child(self, child):
        self.children.append(child)

    def remove_child(self, child):
        self.children.remove(child)

    def get_children(self):
        return self.children

    def get_data(self):
        return self.data

在上述示例中，TreeNode类表示树的节点，具有以下几个方法：

• __init__(self, data)：初始化节点，并设置节点的数据。
• add_child(self, child)：向节点添加子节点。
• remove_child(self, child)：移除节点的子节点。
• get_children(self)：返回节点的子节点列表。
• get_data(self)：返回节点的数据。

六、python关于数据类型的特殊模块

1. collections模块：提供了一些特殊的容器数据类型，如deque（双端队列）、defaultdict（带有默认值的字典）等。
2. heapq模块：提供了堆数据结构的实现，可以用于实现优先队列等。
3. bisect模块：提供了二分查找算法的实现，可以用于在有序列表中进行查找和插入操作。
4. queue模块：提供了多种队列的实现，如Queue（先进先出队列）、LifoQueue（后进先出队列/栈）等。
5. array模块：提供了一种高效的数组数据结构，可以存储同一类型的数据。
6. deque模块：提供了一种双端队列数据结构，可以在队列两端进行插入和删除操作。
7. itertools模块：提供了一些用于迭代操作的工具函数，如排列组合、重复迭代等。