数据结构概述 | 设置 2（二叉树、BST、堆和哈希）

二叉树

二叉树是一种常见的树形结构，其中每个节点最多有两个子节点。二叉树可以用来实现许多常见的算法，如查找、排序和遍历等。

二叉树有许多种不同的变形，如二叉搜索树、平衡树、红黑树等。每种变形都有其特定的应用场景和算法实现方式。

以下是一个简单的二叉树的Node类实现：

class Node:
    def __init__(self, value):
        self.value = value
        self.left_child = None
        self.right_child = None

二叉搜索树

二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树。在BST中，每个节点的左子节点保存的数据小于该节点，而右子节点保存的数据大于该节点。

BST支持查找、插入、删除操作，时间复杂度为O(log n)。

以下是一个简单的二叉搜索树的实现：

class BST:
    def __init__(self):
        self.root = None

    def search(self, value):
        node = self.root
        while node:
            if value == node.value:
                return node
            elif value < node.value:
                node = node.left_child
            else:
                node = node.right_child
        return None

    def insert(self, value):
        new_node = Node(value)
        if not self.root:
            self.root = new_node
            return
        node = self.root
        while node:
            if value < node.value:
                if not node.left_child:
                    node.left_child = new_node
                    return
                node = node.left_child
            else:
                if not node.right_child:
                    node.right_child = new_node
                    return
                node = node.right_child

    def delete(self, value):
        def _delete(node, value):
            if not node:
                return None
            if value < node.value:
                node.left_child = _delete(node.left_child, value)
            elif value > node.value:
                node.right_child = _delete(node.right_child, value)
            else:
                if not node.left_child:
                    return node.right_child
                elif not node.right_child:
                    return node.left_child
                else:
                    min_node = self._get_min_node(node.right_child)
                    node.value = min_node.value
                    node.right_child = _delete(node.right_child, min_node.value)
            return node

        self.root = _delete(self.root, value)

    def _get_min_node(self, node):
        while node.left_child:
            node = node.left_child
        return node

堆

堆是一种完全二叉树，其中每个节点的值都小于或等于它的子节点的值。这种性质被称为堆序。堆被广泛用于实现优先队列等数据结构。

堆有两种不同的类型：最大堆和最小堆。在最大堆中，根节点始终是最大值，在最小堆中，根节点始终是最小值。

以下是一个简单的最小堆的实现：

class MinHeap:
    def __init__(self):
        self.heap = []

    def heapify_up(self, index):
        while index > 0:
            parent_index = (index - 1) // 2
            if self.heap[parent_index] > self.heap[index]:
                self.heap[parent_index], self.heap[index] = self.heap[index], self.heap[parent_index]
                index = parent_index
            else:
                break

    def heapify_down(self, index):
        while index < len(self.heap):
            left_index = index * 2 + 1
            right_index = index * 2 + 2
            if left_index >= len(self.heap):
                break
            if right_index >= len(self.heap):
                child_index = left_index
            else:
                child_index = left_index if self.heap[left_index] < self.heap[right_index] else right_index
            if self.heap[child_index] < self.heap[index]:
                self.heap[child_index], self.heap[index] = self.heap[index], self.heap[child_index]
                index = child_index
            else:
                break

    def push(self, value):
        self.heap.append(value)
        self.heapify_up(len(self.heap) - 1)

    def pop(self):
        if len(self.heap) == 0:
            raise Exception("Heap is empty")
        min_value = self.heap[0]
        if len(self.heap) == 1:
            self.heap = []
        else:
            last_value = self.heap.pop()
            self.heap[0] = last_value
            self.heapify_down(0)
        return min_value

哈希表

哈希表是一种数据结构，它能够以常数时间复杂度实现查找、插入和删除等操作。

哈希表通过哈希函数将数据映射到一个固定的位置上。如果两个不同的数据映射到同一个位置上，称之为冲突。哈希表通常使用链表来处理冲突。

以下是一个简单的哈希表的实现：

class HashTable:
    def __init__(self, size):
        self.size = size
        self.table = [[] for _ in range(size)]

    def _hash(self, key):
        return hash(key) % self.size

    def set(self, key, value):
        hash_value = self._hash(key)
        for i, pair in enumerate(self.table[hash_value]):
            if pair[0] == key:
                self.table[hash_value][i] = (key, value)
                return
        self.table[hash_value].append((key, value))

    def get(self, key):
        hash_value = self._hash(key)
        for pair in self.table[hash_value]:
            if pair[0] == key:
                return pair[1]
        return None

    def delete(self, key):
        hash_value = self._hash(key)
        for i, pair in enumerate(self.table[hash_value]):
            if pair[0] == key:
                del self.table[hash_value][i]
                return

以上是二叉树、BST、堆和哈希表的介绍以及简单的实现，程序员可以根据具体情况选择相应的数据结构。