蓝桥杯python基础算法（2-1）——排序

news2025/2/5 21:31:31

目录

一、排序

二、例题 P3225——宝藏排序Ⅰ

三、各种排序比较

四、例题 P3226——宝藏排序Ⅱ

一、排序

（一）冒泡排序

  • 基本思想：比较相邻的元素，如果顺序错误就把它们交换过来。

（二）选择排序

  • 基本思想：在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾

（三）插入排序

  • 基本思想：将未排序数据插入到已排序序列的合适位置。

（四）快速排序

  • 基本思想：选择一个基准值，将数组分为两部分，小于基准值的放在左边，大于基准值的放在右边，然后对左右两部分分别进行排序。

（五）归并排序

  • 基本思想：将数组分成两个子数组，对两个子数组分别进行排序，然后将排序好的子数组合并成一个有序的数组。

 （七）桶排序

  • 基本思想：将待排序的数据元素，按照一定的规则划分到不同的“桶”中。每个桶内的数据元素再根据具体情况进行单独排序（通常可以使用其他简单排序算法，如插入排序），最后将各个桶中排好序的数据元素依次取出，就得到了一个有序的序列。

应用要点

  • 时间复杂度：不同排序算法时间复杂度不同，如冒泡排序、选择排序、插入排序平均时间复杂度为 O(n^2)​，快速排序平均时间复杂度为 O(nlogn)​，归并排序时间复杂度稳定在 O(nlogn)​。蓝桥杯题目对时间限制严格，大数据量下应优先选择 O(nlogn)​ 级别的排序算法。

  • 空间复杂度：有些题目对空间也有限制。例如归并排序空间复杂度为 O(n)​，而快速排序如果实现合理（如原地分区）空间复杂度可以为 O(logn)​。

  • 稳定性：排序稳定性指相等元素在排序前后相对位置是否改变。例如插入排序、冒泡排序是稳定的，选择排序、快速排序是不稳定的。如果题目要求保持相等元素相对顺序，要选择稳定排序算法。

二、例题 P3225——宝藏排序Ⅰ

在一个神秘的岛屿上，有一支探险队发现了一批宝藏，这批宝藏是以整数数组的形式存在的。每个宝藏上都标有一个数字，代表了其珍贵程度。然而，由于某种神奇的力量，这批宝藏的顺序被打乱了，探险队需要将宝藏按照珍贵程度进行排序，以便更好地研究和保护它们。作为探险队的一员，肖恩需要设计合适的排序算法来将宝藏按照珍贵程度进行从小到大排序。请你帮帮肖恩。

输入描述

输入第一行包括一个数字 n ，表示宝藏总共有 n 个。

输入的第二行包括 n 个数字，第 ii 个数字 a[i] 表示第 i 个宝藏的珍贵程度。

数据保证 1≤n≤1000,1≤a[i]≤10^6 。

输出描述

输出 n 个数字，为对宝藏按照珍贵程度从小到大排序后的数组。

# 冒泡排序
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr


# 选择排序
def selection_sort(arr):
    n = len(arr)
    for i in range(n):
        min_index = i
        for j in range(i + 1, n):
            if arr[j] < arr[min_index]:
                min_index = j
        arr[i], arr[min_index] = arr[min_index], arr[i]
    return arr


# 插入排序
def insertion_sort(arr):
    n = len(arr)
    for i in range(1, n):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j = j - 1
        arr[j + 1] = key
    return arr


# 快速排序
def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)


# 归并排序
def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left_half = arr[:mid]
    right_half = arr[mid:]
    left_half = merge_sort(left_half)
    right_half = merge_sort(right_half)
    return merge(left_half, right_half)


def merge(left, right):
    result = []
    left_index = 0
    right_index = 0
    while left_index < len(left) and right_index < len(right):
        if left[left_index] < right[right_index]:
            result.append(left[left_index])
            left_index += 1
        else:
            result.append(right[right_index])
            right_index += 1
    result.extend(left[left_index:])
    result.extend(right[right_index:])
    return result


# 桶排序
def bucket_sort(arr):
    max_val = max(arr)
    min_val = min(arr)
    bucket_size = 1000
    bucket_count = (max_val - min_val) // bucket_size + 1
    buckets = [[] for _ in range(bucket_count)]
    for num in arr:
        index = (num - min_val) // bucket_size
        buckets[index].append(num)
    for i in range(bucket_count):
        buckets[i].sort()
    sorted_arr = []
    for bucket in buckets:
        sorted_arr.extend(bucket)
    return sorted_arr


n = int(input())
treasures = list(map(int, input().split()))

print("冒泡排序结果:")
print(bubble_sort(treasures[:]))

print("选择排序结果:")
print(selection_sort(treasures[:]))

print("插入排序结果:")
print(insertion_sort(treasures[:]))

print("快速排序结果:")
print(quick_sort(treasures[:]))

print("归并排序结果:")
print(merge_sort(treasures[:]))

print("桶排序结果:")
print(bucket_sort(treasures[:]))

三、各种排序比较

import time
import random


# 冒泡排序
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr


# 选择排序
def selection_sort(arr):
    n = len(arr)
    for i in range(n):
        min_index = i
        for j in range(i + 1, n):
            if arr[j] < arr[min_index]:
                min_index = j
        arr[i], arr[min_index] = arr[min_index], arr[i]
    return arr


# 插入排序
def insertion_sort(arr):
    n = len(arr)
    for i in range(1, n):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j = j - 1
        arr[j + 1] = key
    return arr


# 快速排序
def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)


# 归并排序
def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left_half = arr[:mid]
    right_half = arr[mid:]
    left_half = merge_sort(left_half)
    right_half = merge_sort(right_half)
    return merge(left_half, right_half)


def merge(left, right):
    result = []
    left_index = 0
    right_index = 0
    while left_index < len(left) and right_index < len(right):
        if left[left_index] < right[right_index]:
            result.append(left[left_index])
            left_index += 1
        else:
            result.append(right[right_index])
            right_index += 1
    result.extend(left[left_index:])
    result.extend(right[right_index:])
    return result


# 桶排序
def bucket_sort(arr):
    max_val = max(arr)
    min_val = min(arr)
    bucket_size = 1000
    bucket_count = (max_val - min_val) // bucket_size + 1
    buckets = [[] for _ in range(bucket_count)]
    for num in arr:
        index = (num - min_val) // bucket_size
        buckets[index].append(num)
    for i in range(bucket_count):
        buckets[i].sort()
    sorted_arr = []
    for bucket in buckets:
        sorted_arr.extend(bucket)
    return sorted_arr



# ——————————————————————————————————————————————
# 生成测试数据
test_array = [random.randint(1, 10000) for _ in range(10000)]

# 记录每种排序的时间
sorting_methods = [
    ("冒泡排序", bubble_sort),
    ("选择排序", selection_sort),
    ("插入排序", insertion_sort),
    ("快速排序", quick_sort),
    ("归并排序", merge_sort),
    ("桶排序", bucket_sort)
]

# 比较排序结果
sorted_results = {}
for name, sort_func in sorting_methods:
    start_time = time.time()
    sorted_array = sort_func(test_array[:])
    end_time = time.time()
    sorted_results[name] = sorted_array
    print(f"{name} 耗时: {end_time - start_time} 秒")

# 比较排序结果是否一致
base_result = sorted_results[sorting_methods[0][0]]
is_consistent = True
for name, result in sorted_results.items():
    if result != base_result:
        is_consistent = False
        print(f"{name} 的排序结果与基准排序结果不一致")

if is_consistent:
    print("所有排序算法的排序结果一致")

# 比较稳定性
# 稳定性定义: 排序后相同元素的相对顺序不变
# 生成包含重复元素的测试数据
test_stability_array = [5, 3, 8, 3, 6]
stable_sorts = []
unstable_sorts = []

for name, sort_func in sorting_methods:
    original_array = test_stability_array[:]
    sorted_array = sort_func(original_array)
    original_indices = [i for i, x in enumerate(original_array) if x == 3]
    sorted_indices = [i for i, x in enumerate(sorted_array) if x == 3]
    if original_indices == sorted_indices:
        stable_sorts.append(name)
    else:
        unstable_sorts.append(name)

print("\n稳定的排序算法: ", stable_sorts)
print("不稳定的排序算法: ", unstable_sorts)

space_complexity = {
    "冒泡排序": "O(1)",
    "选择排序": "O(1)",
    "插入排序": "O(1)",
    "快速排序": "O(log n) 平均, O(n) 最坏",
    "归并排序": "O(n)",
    "桶排序": "O(n + k) 其中 k 是桶的数量"
}

print("\n空间复杂度:")
for name, complexity in space_complexity.items():
    print(f"{name}: {complexity}")

四、例题 P3226——宝藏排序Ⅱ

问题描述

注意：这道题于宝藏排序Ⅰ的区别仅是数据范围

在一个神秘的岛屿上，有一支探险队发现了一批宝藏，这批宝藏是以整数数组的形式存在的。每个宝藏上都标有一个数字，代表了其珍贵程度。然而，由于某种神奇的力量，这批宝藏的顺序被打乱了，探险队需要将宝藏按照珍贵程度进行排序，以便更好地研究和保护它们。作为探险队的一员，肖恩需要设计合适的排序算法来将宝藏按照珍贵程度进行从小到大排序。请你帮帮肖恩。

输入描述

输入第一行包括一个数字 n ，表示宝藏总共有 n 个。

输入的第二行包括 n 个数字，第 i 个数字 a[i] 表示第 i 个宝藏的珍贵程度。

数据保证 1≤n≤10^5,1≤a[i]≤10^9。

输出描述

输出 n 个数字，为对宝藏按照珍贵程度从小到大排序后的数组。

list.sort()​：是Python标准库中已经实现好的方法，它是基于优化的C语言代码实现的，内部实现经过了高度优化，以确保在各种情况下都能高效运行。

n = int(input())   
treasures = list(map(int, input().split()))
   
# 使用Python内置的排序函数进行排序   
sorted_treasures = sorted(treasures)
   
for treasure in sorted_treasures:
    print(treasure, end=" ")

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2293479.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

linux 进程补充

linux 进程补充

环境变量 基本概念 环境变量(environment variables)一般是指在操作系统中用来指定操作系统运行环境的一些参数 如&#xff1a;我们在编写C/C代码的时候&#xff0c;在链接的时候&#xff0c;从来不知道我们的所链接的动态静态库在哪 里&#xff0c;但是照样可以链接成功&#…
阅读更多...
C基础寒假练习(8)

C基础寒假练习(8)

一、终端输入10个学生成绩&#xff0c;使用冒泡排序对学生成绩从低到高排序 #include <stdio.h> int main(int argc, const char *argv[]) {int arr[10]; // 定义一个长度为10的整型数组&#xff0c;用于存储学生成绩int len sizeof(arr) / sizeof(arr[0]); // 计算数组…
阅读更多...
Python爬虫：1药城店铺爬虫（完整代码）

Python爬虫：1药城店铺爬虫（完整代码）

⭐️⭐️⭐️⭐️⭐️欢迎来到我的博客⭐️⭐️⭐️⭐️⭐️ &#x1f434;作者&#xff1a;秋无之地 &#x1f434;简介&#xff1a;CSDN爬虫、后端、大数据领域创作者。目前从事python爬虫、后端和大数据等相关工作&#xff0c;主要擅长领域有&#xff1a;爬虫、后端、大数据…
阅读更多...
【贪心算法篇】：“贪心”之旅--算法练习题中的智慧与策略（一）

【贪心算法篇】：“贪心”之旅--算法练习题中的智慧与策略（一）

✨感谢您阅读本篇文章&#xff0c;文章内容是个人学习笔记的整理&#xff0c;如果哪里有误的话还请您指正噢✨ ✨ 个人主页&#xff1a;余辉zmh–CSDN博客 ✨ 文章所属专栏&#xff1a;贪心算法篇–CSDN博客 文章目录 一.贪心算法1.什么是贪心算法2.贪心算法的特点 二.例题1.柠…
阅读更多...
基于Springboot框架的学术期刊遴选服务-项目演示

基于Springboot框架的学术期刊遴选服务-项目演示

项目介绍 本课程演示的是一款 基于Javaweb的水果超市管理系统&#xff0c;主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的 Java 学习者。 1.包含&#xff1a;项目源码、项目文档、数据库脚本、软件工具等所有资料 2.带你从零开始部署运行本套系统 3.该项目附…
阅读更多...
Java创建对象有几种方式?

Java创建对象有几种方式?

大家好&#xff0c;我是锋哥。今天分享关于【Java创建对象有几种方式?】面试题。希望对大家有帮助&#xff1b; Java创建对象有几种方式? 1000道 互联网大厂Java工程师 精选面试题-Java资源分享网 在 Java 中&#xff0c;创建对象有几种常见的方式&#xff0c;具体如下&…
阅读更多...
基于Flask的全国星巴克门店可视化分析系统的设计与实现

基于Flask的全国星巴克门店可视化分析系统的设计与实现

【FLask】基于Flask的全国星巴克门店可视化分析系统的设计与实现&#xff08;完整系统源码开发笔记详细部署教程&#xff09;✅ 目录 一、项目简介二、项目界面展示三、项目视频展示 一、项目简介 该系统采用Python作为主要开发语言&#xff0c;结合Flask框架进行后端开发&…
阅读更多...
Golang ：用Redis构建高效灵活的应用程序

Golang ：用Redis构建高效灵活的应用程序

在当前的应用程序开发中&#xff0c;高效的数据存储和检索的必要性已经变得至关重要。Redis是一个快速的、开源的、内存中的数据结构存储&#xff0c;为各种应用场景提供了可靠的解决方案。在这个完整的指南中&#xff0c;我们将学习什么是Redis&#xff0c;通过Docker Compose…
阅读更多...
deepseek+vscode自动化测试脚本生成

deepseek+vscode自动化测试脚本生成

近几日Deepseek大火，我这里也尝试了一下，确实很强。而目前vscode的AI toolkit插件也已经集成了deepseek R1，这里就介绍下在vscode中利用deepseek帮助我们完成自动化测试脚本的实践分享 安装AI ToolKit并启用Deepseek 微软官方提供了一个针对AI辅助的插件，也就是 AI Toolk…
阅读更多...
【大数据技术】Day07：本机DataGrip远程连接虚拟机MySQL/Hive

【大数据技术】Day07：本机DataGrip远程连接虚拟机MySQL/Hive

本机DataGrip远程连接虚拟机MySQL/Hive datagrip-2024.3.4VMware Workstation Pro 16CentOS-Stream-10-latest-x86_64-dvd1.iso写在前面 本文主要介绍如何使用本机的DataGrip连接虚拟机的MySQL数据库和Hive数据库，提高编程效率。 安装DataGrip 请按照以下步骤安装DataGrip软…
阅读更多...
大语言模型的个性化综述 ——《Personalization of Large Language Models: A Survey》

大语言模型的个性化综述 ——《Personalization of Large Language Models: A Survey》

摘要&#xff1a; 本文深入解读了论文“Personalization of Large Language Models: A Survey”&#xff0c;对大语言模型&#xff08;LLMs&#xff09;的个性化领域进行了全面剖析。通过详细阐述个性化的基础概念、分类体系、技术方法、评估指标以及应用实践&#xff0c;揭示了…
阅读更多...
[论文学习]Adaptively Perturbed Mirror Descent for Learning in Games

[论文学习]Adaptively Perturbed Mirror Descent for Learning in Games

[论文学习]Adaptively Perturbed Mirror Descent for Learning in Games 前言概述前置知识和问题约定单调博弈&#xff08;monotone game&#xff09;Nash均衡和Gap函数文章问题定义Mirror Descent 方法评价 前言 文章链接 我们称集合是紧的&#xff0c;则集合满足&#xff1…
阅读更多...
【Unity踩坑】Unity项目管理员权限问题（Unity is running as administrator ）

【Unity踩坑】Unity项目管理员权限问题（Unity is running as administrator ）

问题描述&#xff1a; 使用Unity Hub打开或新建项目时会有下面的提示。 解决方法&#xff1a; 打开“本地安全策略”&#xff1a; 在Windows搜索栏中输入secpol.msc并回车&#xff0c;或者从“运行”对话框&#xff08;Win R&#xff0c;然后输入secpol.msc&#xff09;启…
阅读更多...
一文讲解Java中的ArrayList和LinkedList

一文讲解Java中的ArrayList和LinkedList

ArrayList和LinkedList有什么区别&#xff1f; ArrayList 是基于数组实现的&#xff0c;LinkedList 是基于链表实现的。 二者用途有什么不同&#xff1f; 多数情况下&#xff0c;ArrayList更利于查找&#xff0c;LinkedList更利于增删 由于 ArrayList 是基于数组实现的&#…
阅读更多...
使用 DeepSeek-R1 与 AnythingLLM 搭建本地知识库

使用 DeepSeek-R1 与 AnythingLLM 搭建本地知识库

一、下载地址Download Ollama on macOS 官方网站&#xff1a;Ollama 官方模型库&#xff1a;library 二、模型库搜索 deepseek r1 deepseek-r1:1.5b 私有化部署deepseek&#xff0c;模型库搜索 deepseek r1 运行cmd复制命令&#xff1a;ollama run deepseek-r1:1.5b 私有化…
阅读更多...
MapReduce分区

MapReduce分区

目录 1. MapReduce分区1.1 哈希分区1.2 自定义分区 2. 成绩分组2.1 Map2.2 Partition2.3 Reduce 3. 代码和结果3.1 pom.xml中依赖配置3.2 工具类util3.3 GroupScores3.4 结果 参考 本文引用的Apache Hadoop源代码基于Apache许可证 2.0&#xff0c;详情请参阅 Apache许可证2.0。…
阅读更多...
【Spring】Spring Cloud Alibaba 版本选择及项目搭建笔记

【Spring】Spring Cloud Alibaba 版本选择及项目搭建笔记

文章目录 前言1. 版本选择2. 集成 Nacos3. 服务间调用4. 集成 Sentinel5. 测试后记 前言 最近重新接触了 Spring Cloud 项目&#xff0c;为此参考多篇官方文档重新搭建一次项目&#xff0c;主要实践&#xff1a; 版本选择&#xff0c;包括 Spring Cloud Alibaba、Spring Clou…
阅读更多...
C语言实现统计字符串中不同ASCII字符个数

C语言实现统计字符串中不同ASCII字符个数

在C语言编程中&#xff0c;经常会遇到一些对字符串进行处理的需求&#xff0c;今天我们就来探讨如何统计给定字符串中ASCII码在0 - 127范围内不同字符的个数。这不仅是一个常见的算法问题&#xff0c;也有助于我们更好地理解C语言中数组和字符操作的相关知识。 问题描述 对于给…
阅读更多...
保姆级教程Docker部署Zookeeper官方镜像

保姆级教程Docker部署Zookeeper官方镜像

目录 1、安装Docker及可视化工具 2、创建挂载目录 3、运行Zookeeper容器 4、Compose运行Zookeeper容器 5、查看Zookeeper运行状态 6、验证Zookeeper是否正常运行 1、安装Docker及可视化工具 Docker及可视化工具的安装可参考&#xff1a;Ubuntu上安装 Docker及可视化管理…
阅读更多...
DeepSeek R1 简易指南：架构、本地部署和硬件要求

DeepSeek R1 简易指南：架构、本地部署和硬件要求

DeepSeek 团队近期发布的DeepSeek-R1技术论文展示了其在增强大语言模型推理能力方面的创新实践。该研究突破性地采用强化学习&#xff08;Reinforcement Learning&#xff09;作为核心训练范式&#xff0c;在不依赖大规模监督微调的前提下显著提升了模型的复杂问题求解能力。 技…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023