常用结构python

trust Tomorrow

于 2023-11-30 10:48:15 发布

阅读量58

点赞数 1

分类专栏： python 文章标签： python 数据结构开发语言

本文链接：https://blog.csdn.net/liudadaxuexi/article/details/134706905

版权

python 专栏收录该内容

56 篇文章 3 订阅

订阅专栏

栈（Stack）：一种线性数据结构，具有先进后出（LIFO）的特点。常用的操作有压栈（push）、弹栈（pop）、获取栈顶元素（top）等。

示例：

stack = []
stack.append(1) # push
stack.append(2) # push
stack.pop() # pop，弹出2
stack[-1] # top，返回1

队列（Queue）：一种线性数据结构，具有先进先出（FIFO）的特点。常用的操作有入队（enqueue）、出队（dequeue）、获取队头元素（front）等。

示例：

from collections import deque

queue = deque()
queue.append(1) # enqueue
queue.append(2) # enqueue
queue.popleft() # dequeue，弹出1
queue[0] # front，返回2

双端队列（Deque）：一种线性数据结构，可以在队头和队尾进行插入和删除操作。常用的操作有在队头插入元素（appendleft）、在队头删除元素（popleft）、在队尾插入元素（append）、在队尾删除元素（pop）等。

示例：

from collections import deque

deque = deque()
deque.appendleft(1) # 在队头插入1
deque.append(2) # 在队尾插入2
deque.pop() # 在队尾删除2
deque.popleft() # 在队头删除1

集合（Set）：一种无序、不重复的数据结构。常用的操作有添加元素（add）、删除元素（remove）、判断元素是否在集合中（in）等。

示例：

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
set3 = set1.union(set2) # 集合并，返回{1, 2, 3, 4, 5, 6}
set1.add(5) # 添加元素5，集合变为{1, 2, 3, 4, 5}
set2.remove(6) # 删除元素6，集合变为{3, 4, 5}
3 in set1 # 判断元素3是否在集合1中，返回True

列表（List）：一种有序、可重复的数据结构。常用的操作有添加元素（append）、插入元素（insert）、删除元素（remove）等。

示例：

list1 = [1, 2, 3, 4]
list2 = [3, 4, 5, 6]
list3 = list1 + list2 # 列表合并，返回[1, 2, 3, 4, 3, 4, 5, 6]
list1.append(5) # 在列表1末尾添加元素5，列表变为[1, 2, 3, 4, 5]
list2.insert(0, 2) # 在列表2的第一个位置插入元素2，列表变为[2, 3, 4, 5, 6]
list1.remove(1) # 删除列表1中的元素1，列表变为[2, 3, 4, 5]

圆形缓冲区（Circular buffer）：一种类似于队列的数据结构，但是在达到缓冲区最大容量时会覆盖掉最早加入的元素。常用的操作有添加元素（append）、获取最早加入的元素（oldest）等。

示例：

from collections import deque

cb = deque(maxlen=4)
cb.append(1) # 添加元素1
cb.append(2) # 添加元素2
cb.append(3) # 添加元素3
cb.append(4) # 添加元素4
cb.append(5) # 添加元素5，缓冲区已达到最大容量，覆盖了最早加入的元素1
cb[0] # 获取最早加入的元素，返回2

散列表（Hash table）：一种以键值对存储数据的数据结构，可以快速查找、插入、删除数据。常用的操作有添加键值对（setitem）、获取键值对（getitem）、删除键值对（delitem）等。

示例：

hash_table = {}
hash_table['key1'] = 'value1' # 添加键值对
hash_table['key2'] = 'value2' # 添加键值对
hash_table['key3'] = 'value3' # 添加键值对
hash_table['key2'] = 'new_value2' # 修改键值对
hash_table.pop('key3') # 删除键值对
'key1' in hash_table # 判断键是否在散列表中，返回True

二叉树（Binary tree）：一种每个节点最多有两个子节点的数据结构。常用的操作有插入节点（insert）、删除节点（delete）、查找节点（find）等。

示例：

class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None
        
class BinaryTree:
    def __init__(self):
        self.root = None
    
    def insert(self, value):
        node = Node(value)
        if not self.root:
            self.root = node
        else:
            curr = self.root
            while True:
                if value < curr.value:
                    if not curr.left:
                        curr.left = node
                        break
                    else:
                        curr = curr.left
                else:
                    if not curr.right:
                        curr.right = node
                        break
                    else:
                        curr = curr.right
    
    def inorder_traversal(self, node, res):
        if node:
            self.inorder_traversal(node.left, res)
            res.append(node.value)
            self.inorder_traversal(node.right, res)
    
    def to_list(self):
        res = []
        self.inorder_traversal(self.root, res)
        return res

tree = BinaryTree()
tree.insert(5)
tree.insert(2)
tree.insert(7)
tree.to_list() # 返回[2, 5, 7]

堆（Heap）：一种可以用来快速找到最大或最小值的完全二叉树。常用的操作有插入元素（heappush）、获取堆顶元素（heappop）、将列表转换成堆（heapify）等。

示例：

import heapq

heap = []
heapq.heappush(heap, 3) # 插入元素3
heapq.heappush(heap, 1) # 插入元素1
heapq.heappush(heap, 2) # 插入元素2
heapq.heappush(heap, 4) # 插入元素4
heapq.heappop(heap) # 弹出堆顶元素1

跳表（Skip list）：一种以空间换时间的数据结构，可以快速查找、插入、删除数据。常用的操作有添加元素（insert）、获取元素（get）、删除元素（delete）等。

示例：

import random

class Node:
    def __init__(self, value=None, level=1):
        self.value = value
        self.forward = [None] * level
        
class SkipList:
    def __init__(self, max_level=4, p=0.5):
        self.max_level = max_level
        self.p = p
        self.head = Node()
        self.level = 1
        
    def random_level(self):
        level = 1
        while random.random() < self.p and level < self.max_level:
            level += 1
        return level
    
    def insert(self, value):
        level = self.random_level()
        node = Node(value, level)
        update = [self.head] * level
        curr = self.head
        for i in range(level-1, -1, -1):
            while curr.forward[i] and curr.forward[i].value < value:
                curr = curr.forward[i]
            update[i] = curr
        for i in range(level):
            node.forward[i] = update[i].forward[i]
            update[i].forward[i] = node
        if level > self.level:
            self.level = level
            
    def get(self, value):
        curr = self.head
        for i in range(self.level-1, -1, -1):
            while curr.forward[i] and curr.forward[i