选择排序

选择排序

选择排序是一个基于比较的排序算法,通过重复选择最小的元素并将其与第一个未排序的元素进行交换从而实现排序

算法详情

算法步骤

1. 选择一个最小的元素，并将其与第一个元素进行交换,在这个步骤中我们将最小的元素放到了正确的位置
2. 此时待排序的数组分为了 已排序 及 未排序 两个部分
3. 遍历整个未排序的数组，确认 已排序 部分中是整个数组中最小的部分
4. 在 未排序 部分中重复上述步骤，直到 未排序 部分被筛选完毕

算法流程图

flowchart TD Start([Start]) --> InputArray[Input Array] InputArray --> InitializeVars[Initialize: i = 0] InitializeVars --> CheckOuterLoop{Is i < array.length - 1?} CheckOuterLoop -->|Yes| SetMinIndex[Set minIndex = i] CheckOuterLoop -->|No| End([End]) SetMinIndex --> InitializeJ[Initialize: j = i + 1] InitializeJ --> CheckInnerLoop{"Is j < array.length?"} CheckInnerLoop -->|Yes| CompareValues{"Is array[j] < array[minIndex]?"} CheckInnerLoop -->|No| SwapValues["Swap array[i] and array[minIndex]"] CompareValues -->|Yes| UpdateMinIndex[Update minIndex = j] CompareValues -->|No| IncrementJ[Increment j] UpdateMinIndex --> IncrementJ IncrementJ --> CheckInnerLoop SwapValues --> IncrementI[Increment i] IncrementI --> CheckOuterLoop

伪代码

function selection_sort
    for i in 0..arr.len
        minIndex = i
        for j in i+1 ..arr.len
            if arr[j] < arr[minIndex]
                minIndex = j
        swap(a[minIndex],a[i])

详细代码

正常实现

基于 rust 实现的代码

use std::vec::Vec;

fn selection_sorting<T: PartialOrd>(vec: &mut Vec<T>) {
    for i in 0..vec.len() {
        let mut min_index = i;
        for j in (i + 1)..vec.len() {
            if vec[j] < vec[i] {
                min_index = j;
            }
        }
        vec.swap(min_index, i);
    }
}
fn main() {
    let mut test = [5, 4, 3, 10, 1].to_vec();
    selection_sorting(&mut test);
    println!("{:?}", test);
}

递归实现

• 具体思路

我们需要先搞清楚有哪些步骤是可以重复的

• 选择排序分为两个部分,一个是未排序部分,另外一个是排序部分
• 重复的工作在于要对未排序部分进行最小元素的筛选

根据以上思路,我们继续细化相关条件

• 因为要对未排序数组进行筛选,所以我们的工作之一就是确定未排序数组
• 所以我们需要一个 index 来确定未排序数组长度未 index..arr.len()
• 同时,在未排序数组内循环并且执行交换操作是递归部分的最小操作单元
• 递归的推出在于 index > arr.len()

• 伪代码

function recursive_selection_sort(itx,arr)
    if itx < arr.len -1
        min_itx = itx
        for i in itx+1..arr.len
            if arr[i] < arr[min_itx]
                min_itx = i
        swap(arr[min_itx],arr[itx])
        recursive(index+1,arr)

• rust 实现

fn recursive_selection_sort<T: PartialOrd>(index: usize, vec: &mut Vec<T>) {
    if index >= vec.len() - 1 {
        return;
    }
    let mut min_index = index;
    for itx in (index + 1)..vec.len() {
        if vec[itx] < vec[min_index] {
            min_index = itx;
        }
    }
    vec.swap(index, min_index);
    recursive_selection_sort(index + 1, vec);
}

算法解释

• 时间复杂度

因为需要对算法进行循环, 所以:

循环一次的复杂度为 $O_(n)$

又一共需要 n 次循环, 所以复杂度为 $O_(n*n)=O(n^2)$

• 是否为稳定排序

并不是稳定排序，如数组 $[5,4,10,10,1]$ 最后会排序成 $[1,4,5,10(3),10(2)]$ , 所以并不是稳定排序

• 空间复杂度

不需要额外的空间，所以空间复杂度是 $O_(1)$