付源码 “堆排序：高效内存排序之选；归并排序：稳定排序的典范。狄杰斯特拉算法：最短路径探索利器；K-最近邻算法：懒惰学习中的分类与回归高手。”嘿嘿嘿-优快云博客

本文链接：https://blog.youkuaiyun.com/PythonAigc/article/details/138317157

本文介绍了四种关键的IT技术：堆排序、归并排序、狄杰斯特拉算法和K-最近邻算法，详细阐述了它们的原理、特点、时间复杂度以及应用场景，展示了这些算法在数据处理和问题求解中的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. 堆排序 (Heap Sort)

堆排序是利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。

import heapq

def heap_sort(arr):
    # 将数组转化为小顶堆
    heapq.heapify(arr)
    # 依次弹出堆顶元素（最小值），实现排序
    for i in range(len(arr)-1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]  # 将当前未排序部分的最大值放到末尾
        heapq.heapify(arr[:i])  # 重新调整堆结构
    return arr

# 示例
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
print(heap_sort(numbers))  # 输出: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

2. 归并排序 (Merge Sort)

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    merged = []
    left_index = 0
    right_index = 0
    while left_index < len(left) and right_index < len(right):
        if left[left_index] < right[right_index]:
            merged.append(left[left_index])
            left_index += 1
        else:
            merged.append(right[right_index])
            right_index += 1
    # 将剩余的元素（如果有的话）添加到结果中
    merged.extend(left[left_index:])
    merged.extend(right[right_index:])
    return merged

# 示例
numbers = [38, 27, 43, 3, 9, 82, 10]
print(merge_sort(numbers))  # 输出: [3, 9, 10, 27, 38, 43, 82]

3. 狄杰斯特拉算法 (Dijkstra’s Algorithm)

狄杰斯特拉算法用于解决带权重的有向图中单源最短路径问题。它计算从源节点到其他所有节点的最短路径。

import heapq

def dijkstra(graph, start):
    distances = {node: float('infinity') for node in graph}
    distances[start] = 0
    queue = [(0, start)]
    while queue:
        current_distance, current_node = heapq.heappop(queue)
        if current_distance > distances[current_node]:
            continue
        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(queue, (distance, neighbor))
    return distances

# 示例
graph = {
    'A': {'B': 1, 'C': 4},
    'B': {'A': 1, 'C': 2, 'D': 5},
    'C': {'A': 4, 'B': 2, 'D': 1},
    'D': {'B': 5, 'C': 1}
}
print(dijkstra(graph, 'A'))  # 输出: {'A': 0, 'B': 1, 'C': 3, 'D': 4}

4. K-最近邻算法 (K-Nearest Neighbors, KNN)

K-最近邻算法（K-Nearest Neighbors，KNN）是一种基本的分类与回归方法。它基于实例的学习，或者说是“懒惰学习”，没有显式的训练过程，而是当给定测试样本时，它基于某种距离度量找出训练集中与其最靠近的K个样本，并基于这K个“邻居”的信息来进行预测。

下面是一个简单的KNN分类器的Python实现，使用了scikit-learn库中的Iris数据集作为示例：

from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report, confusion_matrix

# 加载数据
iris = load_iris()
X = iris.data
y = iris.target

# 数据标准化
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

# 创建KNN分类器
knn = KNeighborsClassifier(n_neighbors=3)

# 训练模型
knn.fit(X_train, y_train)

# 预测测试集
y_pred = knn.predict(X_test)

# 输出评估结果
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))

在这个实现中，我使用了scikit-learn库中的KNeighborsClassifier类来创建KNN分类器。首先对数据进行标准化处理，然后划分训练集和测试集。之后，创建了一个KNN分类器实例，并设置邻居数量为3。接着，使用训练集对模型进行训练，并对测试集进行预测。最后，输出了混淆矩阵和分类报告来评估模型的性能。

KNN算法的性能在很大程度上取决于距离度量的选择、邻居数量K的设定以及数据的预处理方式（如标准化或归一化）。此外，对于大规模数据集，KNN可能会变得非常慢，因为它需要在整个训练集中为每个测试样本找到最近的邻居。在实际应用中，通常使用更高效的数据结构和算法来优化KNN的性能，例如使用KD树或球树。