选择排序算法，写个编程

选择排序是一种简单直观的排序算法，它的工作原理是每一次从未排序的部分中选出最小（或最大）的元素，放到已排序部分的末尾。算法步骤如下：

1. 找到剩余元素中的最小值（或最大值），并将其与未排序的第一个元素交换位置。
2. 移动到剩余元素中，继续寻找最小值（或最大值），并与未排序的第二个元素交换。
3. 重复这个过程，直到所有元素都按照升序或降序排列。

以下是选择排序的一个基本实现，这里以升序为例，使用 Python 编程语言：

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

# 测试选择排序
arr = [64, 25, 12, 22, 11]
sorted_arr = selection_sort(arr)
print("排序后的数组:", sorted_arr)

相关问题

汇编语言选择排序算法编程

下面是一个简单的汇编语言选择排序算法编程示例：

; 选择排序算法汇编语言实现

; 定义常数
MAX_NUMS EQU 10 ; 待排序元素个数
ARRAY_SIZE EQU MAX_NUMS * 2 ; 数组大小

; 定义数据段
DATA SEGMENT
    ARRAY DW MAX_NUMS DUP(?) ; 待排序的数组
DATA ENDS

; 定义代码段
CODE SEGMENT
    ASSUME CS:CODE, DS:DATA
START:
    ; 初始化数组
    MOV CX, MAX_NUMS ; 循环次数
    MOV SI, 0 ; 数组下标
    MOV AX, 0 ; 数组元素值
INIT_ARRAY:
    MOV [ARRAY + SI], AX ; 存储元素值
    ADD SI, 2 ; 移动下标
    INC AX ; 更新元素值
    LOOP INIT_ARRAY ; 循环初始化数组

    ; 选择排序
    MOV CX, MAX_NUMS ; 循环次数
OUTER_LOOP:
    MOV DI, CX ; 记录当前最大值下标
    MOV SI, 0 ; 数组下标
INNER_LOOP:
    CMP [ARRAY + SI], [ARRAY + DI] ; 比较当前元素和最大值元素
    JLE SKIP_SWAP ; 如果当前元素小于等于最大值元素，则跳过交换
    MOV DI, SI ; 更新最大值下标
SKIP_SWAP:
    ADD SI, 2 ; 移动下标
    LOOP INNER_LOOP ; 循环内部循环

    MOV AX, [ARRAY + CX * 2] ; 获取当前元素值
    XCHG AX, [ARRAY + DI * 2] ; 交换当前元素和最大值元素
    MOV [ARRAY + CX * 2], AX ; 存储交换后的元素值

    LOOP OUTER_LOOP ; 循环外部循环

    ; 输出排序结果
    MOV CX, MAX_NUMS ; 循环次数
    MOV SI, 0 ; 数组下标
OUTPUT_ARRAY:
    MOV AX, [ARRAY + SI] ; 获取元素值
    ADD SI, 2 ; 移动下标
    CALL WRITE_NUM ; 输出元素值
    LOOP OUTPUT_ARRAY ; 循环输出数组

    ; 程序结束
    MOV AH, 4CH
    INT 21H
CODE ENDS

; 定义输出子程序
WRITE_NUM PROC
    PUSH AX ; 保存 AX
    PUSH BX ; 保存 BX
    PUSH CX ; 保存 CX
    PUSH DX ; 保存 DX

    MOV CX, 0 ; 初始化计数器
    MOV BX, 10 ; 除数
    MOV DX, 0 ; 初始化余数
    DIV BX ; AX 除以 BX，商存入 AX，余数存入 DX
    PUSH DX ; 保存余数
    INC CX ; 计数器加 1
    CMP AX, 0 ; 如果商为 0，则跳过循环
    JNE DIV_LOOP
DIV_LOOP:
    MOV AH, 2 ; 输出一个字符
    POP DX ; 弹出余数
    ADD DL, '0' ; 转换为 ASCII 码
    INT 21H ; 输出余数
    DEC CX ; 计数器减 1
    JNZ DIV_LOOP ; 如果计数器不为 0，则继续循环

    MOV AH, 2 ; 输出一个字符
    MOV DL, ',' ; 输出逗号
    INT 21H ; 输出逗号

    POP DX ; 恢复 DX
    POP CX ; 恢复 CX
    POP BX ; 恢复 BX
    POP AX ; 恢复 AX

    RET ; 返回
WRITE_NUM ENDP

; 程序结束
END START

该程序使用汇编语言实现了选择排序算法，并在程序中输出了排序结果。同样需要注意，该程序只是一个简单的示例，实际使用中可能需要根据具体情况进行修改和优化。

汇编语言实现选择排序算法编程

好的，以下是汇编语言实现选择排序算法的代码：

; 选择排序算法
; 参数: 
;   - array: 数组地址
;   - length: 数组长度
; 返回值:
;   无

section .text
global selection_sort

selection_sort:
    ; 循环次数, 初始化为数组长度减1
    mov ecx, [esp + 4 + 4]  ; ecx = length
    dec ecx

    ; 数组地址
    mov ebx, [esp + 4 + 8]  ; ebx = array

    ; 循环
    xor esi, esi  ; esi = i
    .loop:
        ; 内层循环次数, 初始化为数组长度减i
        mov edx, ecx  ; edx = n - i

        ; 最大值下标, 初始化为i
        mov edi, esi  ; edi = i

        ; 内层循环
        xor ecx, ecx
        .inner_loop:
            ; 比较array[j]和array[max], 如果array[j]大于array[max], 则更新max
            mov eax, [ebx + ecx * 4]  ; eax = array[j]
            cmp eax, [ebx + edi * 4]  ; cmp array[j], array[max]
            jle .skip_update
            mov edi, ecx  ; max = j
            .skip_update:
            inc ecx
            cmp ecx, edx
            jl .inner_loop

        ; 交换array[max]和array[n-i-1]
        mov eax, [ebx + edi * 4]
        mov ecx, [ebx + edx * 4 - 4]
        mov [ebx + edx * 4 - 4], eax
        mov [ebx + edi * 4], ecx

        ; i++
        inc esi
        cmp esi, [esp + 4 + 4]
        jl .loop

    ret

以上代码实现了一个选择排序算法，使用的是x86汇编语言。该算法的时间复杂度为O(n^2)，适用于小规模的数据排序。