可视化排序（包括猴子排序、交换排序、归并排序、插入排序、选择排序）

**

效果展示

**

​

**

代码介绍

**

导入库：

tkinter：用于创建图形用户界面（GUI）。

random：用于生成随机数。

time：用于处理时间。

threading：用于并行执行排序算法。

queue：用于线程间通信。

排序算法
is_sorted(arr):

检查数组是否已排序，遍历数组并判断相邻元素的顺序。

bogo_sort(canvas, arr, queue):

实现猴子排序。随机打乱数组，直到其有序。每次打乱后，将当前数组状态和尝试次数放入队列。

insertion_sort(canvas, arr, queue):

实现插入排序。逐个遍历元素并将其插入到已排序部分，更新队列中的状态。

selection_sort(canvas, arr, queue):

实现选择排序。每次选择未排序部分的最小元素，并将其放到已排序部分的末尾，更新状态。

bubble_sort(canvas, arr, queue):

实现气泡排序。重复遍历数组，交换相邻的元素，直到整个数组有序，更新状态。

merge_sort(canvas, arr, queue):

实现归并排序。递归地将数组分成两半，分别排序后合并，更新状态。

可视化相关
visualize_sort(canvas, arr, attempt, sort_type, finished=False, time_elapsed=0):

根据当前排序状态绘制条形图。根据排序算法类型设置不同的颜色和位置，同时显示排序用时。

update_visualization(canvas, queue):

定期检查队列中的状态更新，并调用 visualize_sort 更新图形。

启动与绘制
start_sorting(canvas, arr_monkey, arr_insertion, arr_selection, arr_bubble, arr_merge, queue, button):

当用户点击“开始排序”按钮时，禁用按钮，启动所有排序算法的线程。

draw_initial_arrays(canvas, arr_monkey, arr_insertion, arr_selection, arr_bubble, arr_merge):

绘制初始的随机数组，显示在窗口中。

主函数
main():

设置窗口属性，如标题和图标。

生成一个随机数组，创建多个相同的数组副本供不同的排序算法使用。

调用 draw_initial_arrays 绘制初始数组。

创建“开始排序”按钮，并设置其命令为启动排序的函数。

启动可视化更新循环。

**

部分源码

**

##完整源码gongzhonghao：PandaYY回复1016
import tkinter as tk
import random
import time
import threading
from queue import Queue
def is_sorted(arr):
    for i in range(len(arr) - 1):
        if arr[i] > arr[i + 1]:
            return False
    return True

# 猴子排序实现
def bogo_sort(canvas, arr, queue):
    start_time = time.time()  # 记录开始时间
    attempts = 0
    while not is_sorted(arr):
        attempts += 1
        random.shuffle(arr)
        queue.put(("Monkey", arr.copy(), attempts, time.time() - start_time))
        time.sleep(0.1)  # 暂停 0.1 秒来模拟动画效果
    queue.put(("Monkey", arr.copy(), attempts, time.time() - start_time))

# 插入排序实现
def insertion_sort(canvas, arr, queue):
    start_time = time.time()  # 记录开始时间
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
        queue.put(("Insertion", arr.copy(), i, time.time() - start_time))
        time.sleep(0.1)  # 暂停 0.1 秒来模拟动画效果
    queue.put(("Insertion", arr.copy(), len(arr), time.time() - start_time))

# 选择排序实现
def selection_sort(canvas, arr, queue):
    start_time = time.time()  # 记录开始时间
    for i in range(len(arr)):
        min_index = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[min_index]:
                min_index = j
        arr[i], arr[min_index] = arr[min_index], arr[i]
        queue.put(("Selection", arr.copy(), i + 1, time.time() - start_time))
        time.sleep(0.1)  # 暂停 0.1 秒来模拟动画效果
    queue.put(("Selection", arr.copy(), len(arr), time.time() - start_time))

# 交换排序实现（气泡排序）
def bubble_sort(canvas, arr, queue):
    start_time = time.time()  # 记录开始时间
    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]
            queue.put(("Bubble", arr.copy(), j + 1, time.time() - start_time))
            time.sleep(0.1)  # 暂停 0.1 秒来模拟动画效果
    queue.put(("Bubble", arr.copy(), n, time.time() - start_time))

# 归并排序实现
def merge_sort(canvas, arr, queue):
    start_time = time.time()  # 记录开始时间

    def merge(left, right):
        merged = []
        while left and right:
            if left[0] < right[0]:
                merged.append(left.pop(0))
            else:
                merged.append(right.pop(0))
        merged.extend(left)
        merged.extend(right)
        return merged

    def sort_and_visualize(arr):
        if len(arr) <= 1:
            return arr
        mid = len(arr) // 2
        left = sort_and_visualize(arr[:mid])
        right = sort_and_visualize(arr[mid:])
        merged = merge(left, right)
        queue.put(("Merge", merged.copy(), 0, time.time() - start_time))  # 更新可视化
        time.sleep(0.1)  # 暂停以模拟动画效果
        return merged

    sorted_arr = sort_and_visualize(arr)
    queue.put(("Merge", sorted_arr.copy(), len(arr), time.time() - start_time))