Sort:Bubble&&Insert&&Shell&Merge

本文介绍了一种通用的排序类模板实现,其中包括插入排序、冒泡排序、希尔排序、归并排序等算法的具体实现过程,并通过一个示例展示了这些排序算法的应用。

一、结果显示

 

二、sort.h

#include<iostream>

using namespace std;

template<class T>
class sort
{
private:
    T a[10] = {'d','a','f','c','v','b','a','g','s','z'};
    int size = sizeof(a);
public:
    sort()
    {
        cout<<"size  = "<<size<<endl;
    }

    void Insert()
    {
        T b[10];
        int i,j;
        for(i =0; i < size; i++)
        {
            b[i] = a[i];
            char tmp = b[i];
            for(j = i; j > 0 && tmp < b[j-1] ; j--)
            {
                b[j] = b[j-1];
            }
            b[j] = tmp;
        }
        cout<<"Insert >>Sort : ";
        print(b);
    }

    void Bubble()
    {
        T b[10];
        for(int i = 0; i < size; i++)
            b[i] = a[i];
        for(int i = size; i > 0; i--)
        {
            for(int j = 1; j < i; j++)
            {
                if(b[j] < b[j-1])
                {
                    char tmp = b[j];
                    b[j] = b[j-1];
                    b[j-1] = tmp;
                }
            }
        }
        cout<<"Bubble >>Sort : ";
        print(b);
    }

    void Shell()
    {
        int j,k,gap;
        T b[10];
        for(int i = 0; i < size; i++)
            b[i] = a[i];
        for(gap = size/2 ; gap > 0 ; gap/=2)
        {
            for(k = gap; k < size ; k++)
            {
                T tmp = b[k];
                for(j = k ; j >= gap && tmp < b[j-gap]; j -= gap)
                {
                    b[j] = b[j-gap];
                }
                b[j] = tmp;
            }
        }
        cout<<"Shell  >>Sort : ";
        print(b);
    }

    void MergeSort()
    {
        T b[10];
        for(int i = 0; i < size; i++)
            b[i] = a[i];
        T tmp[size] = {0};
        MergeSort0( *b, *tmp, 0, size-1);
        cout<<"Merge  >>Sort : ";
        print(b);
    }
    void MergeSort0(T &a, T &tmp, int left, int right)
    {
        if(left < right)
        {
            int center = (left + right)/2;
            MergeSort0( a, tmp, left, center);
            MergeSort0( a, tmp, center + 1, right);
            Merge( &a, &tmp, left, center + 1, right);
        }
    }
    void Merge(T a[], T tmp[],int leftPos, int rightPos, int rightEnd)
    {
        int leftEnd = rightPos - 1;
        int tmpPos = leftPos;
        int ElementNum = rightEnd - leftPos + 1;
        while(leftPos <= leftEnd && rightPos <= rightEnd)
        {
            if(a[leftPos] < a[rightPos])
            {
                tmp[tmpPos++] = a[leftPos++];
            }
            else
            {
                tmp[tmpPos++] = a[rightPos++];
            }
        }
        while(leftPos <= leftEnd)
        {
            tmp[tmpPos++] = a[leftPos++];
        }
        while(rightPos <= rightEnd)
        {
            tmp[tmpPos++] = a[rightPos++];
        }

        for(int i = 0; i < size; i++,rightEnd--)
        {
            a[rightEnd] = tmp[rightEnd];
        }

    }

    void vprint()
    {
        cout<<"The source char array : ";
        print(a);
    }
    void print(char a[10])
    {
        for(int i = 0 ; i < size ; i++)
        {
            cout<<a[i]<<" ";
        }
        cout<<endl;
    }
};

 

三、main.cpp

#include "sort.h"

using namespace std;

int main()
{
    sort<char> T;
    T.vprint();
    T.Insert();
    T.Bubble();
    T.Shell();
    T.MergeSort();

    cout << "Hello world!" <<endl;
    return 0;
}

 

import tkinter as tk from tkinter import ttk, filedialog, messagebox from PIL import Image, ImageTk, ImageSequence import pandas as pd import time import os import random import threading import queue from bubble import Bubble from selection import Selection from insertion import Insertion from shellsort import Shell from cocktailsort import Cocktail from gnomesort import Gnome from combsort import Comb from countingsort import Counting from radixsort import Radix from bucketsort import Bucket from timsort import Tim from heapsort import Heap from quicksort import Quick from mergesort import Merge window = tk.Tk() window.title("排序方法") window.geometry("1200x800+300+100") # 全局变量声明 current_file = "" arr = [] filename = "sort.csv" gif_label = None gif_frames = [] gif_index = 0 gif_speed = 150 gif_after_id = None scroll_after_id = None BATCH_SIZE = 10000 display_queue = queue.Queue() is_displaying = False sorting_thread = None sorting_active = False def load_gif(file_path, size=(400, 300)): # 加载gif global gif_frames, gif_index # 声明全局变量 gif_frames = [] try: img = Image.open(file_path) for frame in ImageSequence.Iterator(img): resized = frame.copy().resize(size, Image.Resampling.LANCZOS) gif_frames.append(ImageTk.PhotoImage(resized)) gif_index = 0 return bool(gif_frames) except Exception as e: print(f"加载 GIF 出错: {e}") return False def animate_gif(): # 循环显示gif的每一帧 global gif_index, gif_after_id if gif_frames: gif_label.config(image=gif_frames[gif_index]) gif_index = (gif_index + 1) % len(gif_frames) gif_after_id = window.after(gif_speed, animate_gif) def update_gif(file_path): global gif_after_id, gif_frames, gif_index if gif_after_id: window.after_cancel(gif_after_id) if load_gif(file_path, size=(500, 300)): animate_gif() else: gif_label.config(text=f"GIF 加载失败: {file_path}") def load_file(): file_path = filedialog.askopenfilename( title="选择数据文件", filetypes=[("CSV文件", "*.csv"), ("文本文件", "*.txt"), ("所有文件", "*.*")] ) if file_path: status_label.config(text=f"正在加载文件: {os.path.basename(file_path)}...") window.update() threading.Thread(target=load_data_thread, args=(file_path), daemon=True).start() def load_data_thread(file_path): global arr, current_file # 声明全局变量 try: # 分块读取大文件 chunks = [] total_size = os.path.getsize(file_path) processed = 0 for chunk in pd.read_csv(file_path, chunksize=10000): chunks.append(chunk) processed += chunk.memory_usage(index=True, deep=True).sum() progress_value = min(processed / total_size * 100, 100) window.after(0, update_progress, progress_value, f"加载中: {progress_value:.1f}% ({processed / 1e6:.2f}MB/{total_size / 1e6:.2f}MB)") df = pd.concat(chunks) arr = df.values.flatten().tolist() current_file = os.path.basename(file_path) # 更新UI window.after(0, update_treeview_batch, unsort_tree, arr) window.after(0, update_treeview, sort_tree, []) window.after(0, lambda: status_label.config( text=f"已加载: {len(arr)} 条数据 | 文件: {current_file}")) window.after(0, lambda: progress.configure(value=0)) except Exception as e: window.after(0, lambda: messagebox.showerror("错误", f"加载文件失败: {str(e)}")) window.after(0, lambda: status_label.config(text=f"加载失败: {str(e)}")) def update_treeview(treeview, data): treeview.delete(*treeview.get_children()) for value in data: treeview.insert("", "end", values=(value,)) def update_treeview_batch(treeview, data): """分批更新Treeview控件""" treeview.delete(*treeview.get_children()) total = len(data) def add_batch(start_idx=0): end_idx = min(start_idx + BATCH_SIZE, total) for i in range(start_idx, end_idx): treeview.insert("", "end", values=(data[i],)) # 更新进度 progress_value = end_idx / total * 100 window.after(0, lambda: progress.configure(value=progress_value)) if end_idx < total: # 使用计时器安排下一批处理 treeview.after(1, add_batch, end_idx) else: treeview.yview_moveto(1.0) add_batch(0) def scroll_sorted_data(treeview, data): """分批滚动显示排序结果""" global scroll_after_id if scroll_after_id: window.after_cancel(scroll_after_id) treeview.delete(*treeview.get_children()) total = len(data) progress.configure(value=0) def scroll(index=0): # 一次插入一批数据 batch_size = min(BATCH_SIZE, total - index) for i in range(index, index + batch_size): treeview.insert("", "end", values=(data[i],)) # 滚动到底部 treeview.yview_moveto(1.0) # 更新进度 progress_value = (index + batch_size) / total * 100 window.after(0, lambda: progress.configure(value=progress_value)) if index + batch_size < total: # 使用计时器安排下一批显示 scroll_after_id = treeview.after(1, scroll, index + batch_size) else: scroll_after_id = None scroll(0) def generate_random_data(): global arr try: count = int(entry.get()) if count < 100: messagebox.showerror("错误", "请输入100以上的数字") return # 清空现有数组 arr = [] # 更新状态 status_label.config(text=f"正在生成 {count} 条随机数据...") window.update() # 启动线程生成数据 threading.Thread(target=generate_data_thread, args=(count,), daemon=True).start() except ValueError: messagebox.showerror("错误", "请输入有效的数字") def generate_data_thread(count): global arr, current_file, stop_sorting arr = [] # 确保数组为空 stop_sorting = False # 分批生成数据 for i in range(0, count, BATCH_SIZE): batch_size = min(BATCH_SIZE, count - len(arr)) batch = [] for _ in range(batch_size): rand_type = random.choice(["int", "float"]) # 控制整数和浮点数的比例 if len(arr) < count * 0.7: # 70% 整数 batch.append(random.randint(-100000, 100000)) else: batch.append(round(random.uniform(-100000, 100000), 3)) arr.extend(batch) # 更新进度 progress_value = len(arr) / count * 100 window.after(0, lambda: update_progress(progress_value, f"生成进度: {progress_value:.1f}% ({len(arr)}/{count})")) # 保存数据 current_file = "random_data.csv" pd.DataFrame(arr).to_csv(current_file, index=False) # 更新UI window.after(0, lambda: update_treeview_batch(unsort_tree, arr)) window.after(0, lambda: update_treeview(sort_tree, [])) window.after(0, lambda: status_label.config( text=f"已生成 {len(arr)} 条随机数据并保存")) window.after(0, lambda: progress.configure(value=0)) def start_sorting(): global sorting_active # 声明全局变量 if not arr: messagebox.showwarning("警告", "没有数据可排序") return if sorting_active: messagebox.showwarning("警告", "排序正在进行中") return # 更新状态 sorting_active = True algorithm = var.get() algorithm_name = { "bubblesort": "冒泡排序", "selectionsort": "选择排序", "insertionsort": "插入排序", "quicksort": "快速排序", "mergesort": "归并排序", "shellsort": "希尔排序", "cocktailsort": "鸡尾酒排序", "gnomesort": "侏儒排序", "combsort": "梳排序", "countingsort": "计数排序", "radixsort": "基数排序", "bucketsort": "桶排序", "timsort": "Tim排序", "heapsort": "堆排序" }.get(algorithm, algorithm) time_label.config(text="排序耗时: 计算中...") steps_label.config(text="运算步数: 计算中...") result_label.config(text="结果文件: 处理中...") status_label.config(text=f"正在使用 {algorithm_name} 排序数据...") progress.configure(value=0) window.update() # 创建新线程运行排序算法 sorting_thread = threading.Thread(target=choose, daemon=True) sorting_thread.start() def choose(): global sorting_active # 声明全局变量 arr_copy = arr.copy() start_time = time.time() algorithm = var.get() sorted_arr, steps = None, 0 title = "" try: if algorithm == "bubblesort": sorter = Bubble() sorted_arr, steps = sorter.sort(arr_copy) title = "冒泡排序" elif algorithm == "selectionsort": sorter = Selection() sorted_arr, steps = sorter.sort(arr_copy) title = "选择排序" elif algorithm == "insertionsort": sorter = Insertion() sorted_arr, steps = sorter.sort(arr_copy) title = "插入排序" elif algorithm == "quicksort": sorter = Quick() sorted_arr, steps = sorter.sort(arr_copy) title = "快速排序" elif algorithm == "mergesort": sorter = Merge() sorted_arr, steps = sorter.sort(arr_copy) title = "归并排序" elif algorithm == "shellsort": sorter = Shell() sorted_arr, steps = sorter.sort(arr_copy) title = "希尔排序" elif algorithm == "cocktailsort": sorter = Cocktail() sorted_arr, steps = sorter.sort(arr_copy) title = "鸡尾酒排序" elif algorithm == "gnomesort": sorter = Gnome() sorted_arr, steps = sorter.sort(arr_copy) title = "侏儒排序" elif algorithm == "combsort": sorter = Comb() sorted_arr, steps = sorter.sort(arr_copy) title = "梳排序" elif algorithm == "countingsort": sorter = Counting() sorted_arr, steps = sorter.sort(arr_copy) title = "计数排序" elif algorithm == "radixsort": sorter = Radix() sorted_arr, steps = sorter.sort(arr_copy) title = "基数排序" elif algorithm == "bucketsort": sorter = Bucket() sorted_arr, steps = sorter.sort(arr_copy) title = "桶排序" elif algorithm == "timsort": sorter = Tim() sorted_arr, steps = sorter.sort(arr_copy) title = "Tim排序" elif algorithm == "heapsort": sorter = Heap() sorted_arr, steps = sorter.sort(arr_copy) title = "堆排序" else: sorter = Bubble() sorted_arr, steps = sorter.sort(arr_copy) title = "冒泡排序" elapsed_time = time.time() - start_time # 保存结果 with open(filename, "a", encoding="utf-8") as f: # 使用"w"模式覆盖旧文件 f.write(f"\n{title}\n") f.write("\n".join(map(str, sorted_arr))) # 更新UI window.after(0, lambda: scroll_sorted_data(sort_tree, sorted_arr)) window.after(0, lambda: time_label.config( text=f"排序耗时: {elapsed_time:.4f} 秒")) window.after(0, lambda: steps_label.config( text=f"运算步数: {steps}")) window.after(0, lambda: result_label.config( text=f"结果文件: {os.path.abspath(filename)}")) window.after(0, lambda: status_label.config( text=f"{title} 完成! 已处理 {len(arr)} 条数据")) except Exception as e: window.after(0, lambda: messagebox.showerror("排序错误", f"排序过程中出错: {str(e)}")) window.after(0, lambda: status_label.config( text=f"排序失败: {str(e)}")) finally: sorting_active = False progress.configure(value=100) def stop_processing(): stop_sorting = True status_label.config(text="正在停止当前操作...") def on_combobox_select(event=None): algorithm = var.get() gif_map = { "bubblesort": "bubble.gif", "selectionsort": "sele.gif", "insertionsort": "inster.gif", "quicksort": "quick.gif", "mergesort": "merge.gif", "shellsort":"shell.gif", "cocktailsort": "cocktail.gif", "gnomesort": "gnome.gif", "combsort": "comb.gif", "countingsort": "counting.gif", "radixsort": "radix.gif", "bucketsort": "bucket.gif", "timsort": "tim.gif", "heapsort": "heap.gif" } gif_path = gif_map.get(algorithm, "sorting.gif") update_gif(gif_path) # 重置排序结果显示 update_treeview(sort_tree, []) time_label.config(text="排序耗时: --") steps_label.config(text="运算步数: --") result_label.config(text="结果文件: --") def open_file(): file_path = os.path.abspath(filename) if os.path.exists(file_path): os.startfile(file_path) # Windows else: messagebox.showinfo("信息", "结果文件尚未生成") def reset(): global stop_sorting, arr, current_file # 声明全局变量 stop_sorting = True update_treeview(sort_tree, []) time_label.config(text="排序耗时: --") steps_label.config(text="运算步数: --") result_label.config(text="结果文件: --") progress.configure(value=0) status_label.config(text="已重置应用程序") def update_progress(value, text): progress.configure(value=value) status_label.config(text=text) # 创建UI组件 optuple = ("bubblesort", "selectionsort", "insertionsort", "shellsort", "cocktailsort", "gnomesort", "combsort", "countingsort", "radixsort","bucketsort","timsort","heapsort","quicksort","mergesort") var = tk.StringVar(value=optuple[0]) control_frame = ttk.Frame(window) control_frame.pack(fill=tk.X, padx=10, pady=10) ttk.Label(control_frame, text="选择排序算法:").grid(row=0, column=0, padx=5, pady=5) cb = ttk.Combobox(control_frame, textvariable=var, values=optuple, state="readonly", width=15) cb.grid(row=0, column=1, padx=5, pady=5) cb.bind("<<ComboboxSelected>>", on_combobox_select) ttk.Label(control_frame, text="生成数据量:").grid(row=0, column=2, padx=5, pady=5) entry = ttk.Entry(control_frame, width=10) entry.grid(row=0, column=3, padx=5, pady=5) ttk.Button(control_frame, text="生成随机数据", command=generate_random_data).grid(row=0, column=4, padx=5, pady=5) ttk.Button(control_frame, text="选择数据文件", command=load_file).grid(row=0, column=5, padx=5, pady=5) ttk.Button(control_frame, text="开始排序", command=start_sorting).grid(row=0, column=6, padx=5, pady=5) ttk.Button(control_frame, text="停止排序").grid(row=0, column=7, padx=5, pady=5) # 数据展示区域 data_frame = ttk.Frame(window) data_frame.pack(fill="both", expand=True, padx=10, pady=5) # 未排序数据 unsort_frame = ttk.LabelFrame(data_frame, text="未排序数据") unsort_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=5, pady=5) unsort_tree = ttk.Treeview(unsort_frame, columns=("value",), show="headings", height=15) unsort_tree.heading("value", text="数值") unsort_tree.column("value", width=100) unsort_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) unsort_scrollbar = ttk.Scrollbar(unsort_frame, orient=tk.VERTICAL, command=unsort_tree.yview) unsort_scrollbar.pack(side=tk.RIGHT, fill=tk.Y) unsort_tree.configure(yscrollcommand=unsort_scrollbar.set) # 排序后数据 sort_frame = ttk.LabelFrame(data_frame, text="排序后数据") sort_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True, padx=5, pady=5) sort_tree = ttk.Treeview(sort_frame, columns=("value",), show="headings", height=15) sort_tree.heading("value", text="数值") sort_tree.column("value", width=100) sort_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) # 添加pack sort_scrollbar = ttk.Scrollbar(sort_frame, orient=tk.VERTICAL, command=sort_tree.yview) sort_scrollbar.pack(side=tk.RIGHT, fill=tk.Y) sort_tree.configure(yscrollcommand=sort_scrollbar.set) gif_frame = ttk.Frame(window) gif_frame.pack(fill=tk.X, padx=10, pady=5) gif_label = ttk.Label(gif_frame) gif_label.pack() # 状态信息 status_frame = ttk.Frame(window) status_frame.pack(fill=tk.X, padx=10, pady=5) time_label = ttk.Label(status_frame, text="排序耗时: --") time_label.grid(row=0, column=0, padx=10, pady=5, sticky="w") steps_label = ttk.Label(status_frame, text="运算步数: --") steps_label.grid(row=0, column=1, padx=10, pady=5, sticky="w") result_label = ttk.Label(status_frame, text="结果文件: --") result_label.grid(row=0, column=2, padx=10, pady=5, sticky="w") progress = ttk.Progressbar(status_frame, orient=tk.HORIZONTAL, length=200, mode='determinate') progress.grid(row=0, column=3, padx=10, pady=5) status_label = ttk.Label(status_frame, text="就绪", foreground="blue") status_label.grid(row=0, column=4, padx=10, pady=5, sticky="ew") # 操作按钮 button_frame = ttk.Frame(window) button_frame.pack(fill=tk.X, padx=10, pady=10) ttk.Button(button_frame, text="查看结果文件", command=open_file).pack(side=tk.RIGHT, padx=5) ttk.Button(button_frame, text="重置", command=reset).pack(side=tk.RIGHT, padx=5) # 初始加载示例数据 update_gif("bubble.gif") window.mainloop() 在这个ui里添加了停止按钮,帮我定义停止按钮的程式,利用泡泡排序的flog停止
06-21
import tkinter as tk from tkinter import * # 导入GUI库的基础模块 from tkinter import ttk,filedialog,messagebox # 导入更漂亮的控件样式 from bubble import Bubble # 自定义的冒泡排序类 from selection import Selection from insertion import Insertion from shellsort import Shell import pandas as pd # 数据处理库,用于读取CSV import time # 计时功能 import os # 操作系统功能,用于获取文件路径 import random from PIL import Image, ImageTk, ImageSequence import threading window = Tk() window.title("排序方法") window.geometry("1200x800+300+100") # 设置窗口大小和位置(宽x高+X坐标+Y坐标) current_file = "" arr = [] filename ="sort.csv" BATCH_SIZE = 10000 gif_frame = [] gif_index = 0 gif_speed = 200 gif_after = None gif_label = None # 全局变量 def load_gif(file_path,size=(400,300)): global gif_frame,gif_index gif_frame =[] img = Image.open(file_path) for frame in ImageSequence.Iterator(img): resized = frame.copy().resize(size, Image.Resampling.BILINEAR) gif_frame.append(ImageTk.PhotoImage(resized)) gif_index = 0 return bool(gif_frame) def open_gif(): global gif_index,gif_after if gif_frame: gif_label.config(image=gif_frame[gif_index]) gif_index = (gif_index + 1) % len(gif_frame) gif_after = window.after(gif_speed,open_gif) def update_gif(file_path): global gif_after, gif_frame, gif_index if gif_after: window.after_cancel(gif_after) if load_gif(file_path, size=(500, 300)): open_gif() else: gif_label.config(text=f"GIF 加载失败: {file_path}") def load_data(file_path): # 加载CSV文件数据 global arr, current_file # global 全局变量用的函式,不然改不了 chunks = [] total_size = os.path.getsize(file_path) processed = 0 for chunk in pd.read_csv(file_path, chunksize=2000): chunks.append(chunk) processed += chunk.memory_usage(index=True, deep=True).sum() progress_value = min(processed / total_size * 100, 100) if os.path.exists(file_path): df = pd.concat(chunks) arr = df.values.flatten().tolist() current_file = os.path.basename(file_path) update_treeview(unsort_tree, arr) update_treeview(sort_tree, []) def update_treeview(treeview, data): treeview.delete(*treeview.get_children()) for value in data: treeview.insert("", "end", values=(value)) def update_treeview_batch(treeview, data): """分批更新Treeview控件""" treeview.delete(*treeview.get_children()) total = len(data) def add_batch(start_idx=0): end_idx = min(start_idx + BATCH_SIZE, total) for i in range(start_idx, end_idx): treeview.insert("", "end", values=(data[i],)) if end_idx < total: # 使用计时器安排下一批处理 treeview.after(1, add_batch, end_idx) else: treeview.yview_moveto(1.0) def generate_random_data(): global arr try: count = int(entry.get()) if count < 100: messagebox.showerror("错误", "请输入100以上的数字") return # 清空现有数组 arr = [] # 启动线程生成数据 threading.Thread(target=generate_data_thread, args=(count,), daemon=True).start() except ValueError: messagebox.showerror("错误", "请输入有效的数字") def generate_data_thread(count): global arr, current_file, stop_sorting arr = [] # 确保数组为空 stop_sorting = False # 分批生成数据 for i in range(0, count, BATCH_SIZE): batch_size = min(BATCH_SIZE, count - len(arr)) batch = [] for _ in range(batch_size): rand_type = random.choice(["int", "float"]) # 控制整数和浮点数的比例 if len(arr) < count * 0.7: # 70% 整数 batch.append(random.randint(-100000, 100000)) else: batch.append(round(random.uniform(-100000, 100000), 3)) arr.extend(batch) update_treeview(unsort_tree, arr) update_treeview(sort_tree, []) # 保存数据 current_file = "random_data.csv" pd.DataFrame(arr).to_csv(current_file, index=False) def file(): file_path = filedialog.askopenfilename( title="选择数据文件", filetypes=[("CSV文件", "*.csv"), ("所有文件", "*.*")] ) if file_path: load_data(file_path) def choose(): choose = var.get() arr_copy = arr.copy() # 创建数据副本(避免修改原始数据) start_time = time.time() if choose == "bubblesort": sorter = Bubble() # 创建冒泡排序对象 sorter_arr,steps = sorter.sort(arr_copy) # 调用排序方法 title="冒泡排序" elif choose == "selectionsort": sorter = Selection() sorter_arr,steps = sorter.sort(arr_copy) title="选择排序" elif choose == "shellsort": sorter = Shell() sorter_arr, steps = sorter.sort(arr_copy) title = "希尔排序" else: sorter = Insertion() sorter_arr,steps = sorter.sort(arr_copy) title="插入排序" # sorting_thread = threading.Thread(target=choose, daemon=True) # sorting_thread.start() elapsed_time = time.time() - start_time filename = "sort.csv" with open(filename,"a",encoding="utf-8") as f: f.write(f"\n{title}\n") f.write("\n".join(map(str,sorter_arr))) # 将排序结果转为字符串并用换行符连接 label1["text"] = f"排序耗时: {elapsed_time:4f} 秒" label2["text"] = f"运算步数: {steps}" label3["text"] = f"结果保存至:\n{os.path.abspath(filename)}" update_treeview(sort_tree, sorter_arr) def open_file(event=None): """打开文件所在的文件夹""" file_path = os.path.abspath(filename) if file_path and os.path.exists(file_path): os.startfile(file_path) def on_combobox_select(event=None): algorithm = var.get() gif_map = { "bubblesort": "bubble.gif", "selectionsort": "sele.gif", "insertionsort": "inster.gif", "quicksort": "quick.gif", "mergesort": "merge.gif", "shellsort":"shell.gif", "cocktailsort": "cocktail.gif", "gnomesort": "gnome.gif", "combsort": "comb.gif", "countingsort": "counting.gif", "radixsort": "radix.gif", "bucketsort": "bucket.gif", "timsort": "tim.gif", "heapsort": "heap.gif" } gif_path = gif_map.get(algorithm, "sorting.gif") update_gif(gif_path) update_treeview(sort_tree, []) label1.config(text="排序耗时:") label2.config(text="运算步数:") label3.config(text="结果文件:") optuple = ("bubblesort","selectionsort","insertionsort","shellsort","cocktailsort","gnomesort","combsort", "countingsort","radixsort") var = StringVar(value=optuple[0]) # 用于存储用户选择的变量 control_frame = ttk.Frame(window) control_frame.pack(fill=tk.X, padx=10, pady=10) ttk.Label(control_frame, text="选择排序算法:").grid(row=0, column=0, padx=5, pady=5) cb = ttk.Combobox(control_frame, textvariable=var, values=optuple, state="readonly", width=15) cb.grid(row=0, column=1, padx=5, pady=5) cb.bind("<<ComboboxSelected>>", on_combobox_select) ttk.Label(control_frame, text="生成数据量:").grid(row=0, column=2, padx=5, pady=5) entry = ttk.Entry(control_frame, width=10) entry.grid(row=0, column=3, padx=5, pady=5) ttk.Button(control_frame, text="生成随机数据",command=generate_random_data).grid(row=0, column=4, padx=5, pady=5) ttk.Button(control_frame, text="选择数据文件",command=file).grid(row=0, column=5, padx=5, pady=5) ttk.Button(control_frame,text="打开结果文件",command=open_file).grid(row=0,column=6,padx=5,pady=5) ttk.Button(control_frame, text="开始排序",command=choose).grid(row=0, column=7, padx=5, pady=5) ttk.Button(control_frame, text="停止排序").grid(row=0, column=8, padx=5, pady=5) # 数据展示区域 data_frame = ttk.Frame(window) data_frame.pack(fill="both", expand=True, padx=10, pady=5) # 未排序数据 unsort_frame = ttk.LabelFrame(data_frame, text="未排序数据") unsort_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=5, pady=5) unsort_tree = ttk.Treeview(unsort_frame, columns=("value",), show="headings", height=15) unsort_tree.heading("value", text="数值") unsort_tree.column("value", width=100) unsort_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) unsort_scrollbar = ttk.Scrollbar(unsort_frame, orient=tk.VERTICAL, command=unsort_tree.yview) unsort_scrollbar.pack(side=tk.RIGHT, fill=tk.Y) unsort_tree.configure(yscrollcommand=unsort_scrollbar.set) # 排序后数据 sort_frame = ttk.LabelFrame(data_frame, text="排序后数据") sort_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True, padx=5, pady=5) sort_tree = ttk.Treeview(sort_frame, columns=("value",), show="headings", height=15) sort_tree.heading("value", text="数值") sort_tree.column("value", width=100) sort_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) # 添加pack sort_scrollbar = ttk.Scrollbar(sort_frame, orient=tk.VERTICAL, command=sort_tree.yview) sort_scrollbar.pack(side=tk.RIGHT, fill=tk.Y) sort_tree.configure(yscrollcommand=sort_scrollbar.set) gif_frame = ttk.Frame(window) gif_frame.pack(fill=tk.X, padx=10, pady=5) gif_label = ttk.Label(gif_frame) gif_label.pack() # 状态信息 status_frame = ttk.Frame(window) status_frame.pack(fill=tk.X, padx=10, pady=5) label1 = ttk.Label(status_frame, text="排序耗时:") label1.grid(row=0, column=0, padx=10, pady=5, sticky="w") label2 = ttk.Label(status_frame, text="运算步数:") label2.grid(row=0, column=1, padx=10, pady=5, sticky="w") label3 = ttk.Label(status_frame, text="结果文件:") label3.grid(row=0, column=2, padx=10, pady=5, sticky="w") update_gif("bubble.gif") window.mainloop() 如何使用threading来使选择数据文件和生产数据文件的大笔资料能够排序
07-02
### 光流法C++源代码解析与应用 #### 光流法原理 光流法是一种在计算机视觉领域中用于追踪视频序列中运动物体的方法。它基于亮度不变性假设,即场景中的点在时间上保持相同的灰度值,从而通过分析连续帧之间的像素变化来估计运动方向和速度。在数学上,光流场可以表示为像素位置和时间的一阶导数,即Ex、Ey(空间梯度)和Et(时间梯度),它们共同构成光流方程的基础。 #### C++实现细节 在给定的C++源代码片段中,`calculate`函数负责计算光流场。该函数接收一个图像缓冲区`buf`作为输入,并初始化了几个关键变量:`Ex`、`Ey`和`Et`分别代表沿x轴、y轴和时间轴的像素强度变化;`gray1`和`gray2`用于存储当前帧和前一帧的平均灰度值;`u`则表示计算出的光流矢量大小。 #### 图像处理流程 1. **初始化和预处理**:`memset`函数被用来清零`opticalflow`数组,它将保存计算出的光流数据。同时,`output`数组被填充为白色,这通常用于可视化结果。 2. **灰度计算**:对每一像素点进行处理,计算其灰度值。这里采用的是RGB通道平均值的计算方法,将每个像素的R、G、B值相加后除以3,得到一个近似灰度值。此步骤确保了计算过程的鲁棒性和效率。 3. **光流向量计算**:通过比较当前帧和前一帧的灰度值,计算出每个像素点的Ex、Ey和Et值。这里值得注意的是,光流向量的大小`u`是通过`Et`除以`sqrt(Ex^2 + Ey^2)`得到的,再乘以10进行量化处理,以减少计算复杂度。 4. **结果存储与阈值处理**:计算出的光流值被存储在`opticalflow`数组中。如果`u`的绝对值超过10,则认为该点存在显著运动,因此在`output`数组中将对应位置标记为黑色,形成运动区域的可视化效果。 5. **状态更新**:通过`memcpy`函数将当前帧复制到`prevframe`中,为下一次迭代做准备。 #### 扩展应用:Lukas-Kanade算法 除了上述基础的光流计算外,代码还提到了Lukas-Kanade算法的应用。这是一种更高级的光流计算方法,能够提供更精确的运动估计。在`ImgOpticalFlow`函数中,通过调用`cvCalcOpticalFlowLK`函数实现了这一算法,该函数接受前一帧和当前帧的灰度图,以及窗口大小等参数,返回像素级别的光流场信息。 在实际应用中,光流法常用于目标跟踪、运动检测、视频压缩等领域。通过深入理解和优化光流算法,可以进一步提升视频分析的准确性和实时性能。 光流法及其C++实现是计算机视觉领域的一个重要组成部分,通过对连续帧间像素变化的精细分析,能够有效捕捉和理解动态场景中的运动信息
微信小程序作为腾讯推出的一种轻型应用形式,因其便捷性与高效性,已广泛应用于日常生活中。以下为该平台的主要特性及配套资源说明: 特性方面: 操作便捷,即开即用:用户通过微信内搜索或扫描二维码即可直接使用,无需额外下载安装,减少了对手机存储空间的占用,也简化了使用流程。 多端兼容,统一开发:该平台支持在多种操作系统与设备上运行,开发者无需针对不同平台进行重复适配,可在一个统一的环境中完成开发工作。 功能丰富,接口完善:平台提供了多样化的API接口,便于开发者实现如支付功能、用户身份验证及消息通知等多样化需求。 社交整合,传播高效:小程序深度嵌入微信生态,能有效利用社交关系链,促进用户之间的互动与传播。 开发成本低,周期短:相比传统应用程序,小程序的开发投入更少,开发周期更短,有助于企业快速实现产品上线。 资源内容: “微信小程序-项目源码-原生开发框架-含效果截图示例”这一资料包,提供了完整的项目源码,并基于原生开发方式构建,确保了代码的稳定性与可维护性。内容涵盖项目结构、页面设计、功能模块等关键部分,配有详细说明与注释,便于使用者迅速理解并掌握开发方法。此外,还附有多个实际运行效果的截图,帮助用户直观了解功能实现情况,评估其在实际应用中的表现与价值。该资源适用于前端开发人员、技术爱好者及希望拓展业务的机构,具有较高的参考与使用价值。欢迎查阅,助力小程序开发实践。资源来源于网络分享,仅用于学习交流使用,请勿用于商业,如有侵权请联系我删除!
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值