自BLOCK开始的存储区中， C 有10个带符号字数据凌乱无序，试编 制一个程序把它们降序排列，并显示

下面是降序排列并显示这10个带符号字数据的程序：

#include <stdio.h>

#define SIZE 10

void swap(int *a, int *b);

int main() {
    int arr[SIZE] = {5, -2, 8, 0, -3, 1, 6, -4, 9, -7};
    int i, j;

    // 冒泡排序降序排列
    for (i = 0; i < SIZE - 1; i++) {
        for (j = 0; j < SIZE - i - 1; j++) {
            if (arr[j] < arr[j + 1]) {
                swap(&arr[j], &arr[j + 1]);
            }
        }
    }

    // 显示排序后的结果
    for (i = 0; i < SIZE; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

// 交换两个整数的值
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

输出结果：

9 8 6 5 1 0 -2 -3 -4 -7 

相关问题

用X86语言，写自BLOCK开始的存储区中， C 有10个带符号字数据凌乱无序，试编 制一个程序把它们降序排列，并显示

下面是用X86汇编语言编写的程序，可以对存储区中的10个带符号字数据进行降序排列，并将结果显示出来：

section .data
    array dw 123, -456, 789, 0, -12, 34, -567, 890, -1234, 5678
    size equ ($ - array) / 2

section .text
    global _start

_start:
    ; 将数组地址存入 SI 寄存器
    mov si, array
    ; 外层循环，共进行 size-1 次迭代
    mov cx, size
    dec cx
outer_loop:
    ; 将数组地址存入 DI 寄存器
    mov di, si
    ; 内层循环，从第二个元素开始比较
    mov bx, cx
inner_loop:
    ; 比较当前元素和前一个元素的大小
    mov ax, [di]
    mov dx, [di - 2]
    cmp ax, dx
    ; 如果当前元素比前一个元素小，则交换它们的值
    jg not_swap
    xchg ax, dx
    mov [di], ax
    mov [di - 2], dx
not_swap:
    ; 继续比较下一个元素
    sub di, 2
    dec bx
    jnz inner_loop
    ; 准备进行下一轮迭代
    add si, 2
    dec cx
    jnz outer_loop
    ; 将排序后的数组输出到屏幕上
    mov si, array
    mov cx, size
print_loop:
    ; 将当前元素的值转换为字符串并输出
    mov ax, [si]
    call print_signed
    ; 输出一个空格
    mov dl, ' '
    mov ah, 02h
    int 21h
    ; 准备输出下一个元素
    add si, 2
    dec cx
    jnz print_loop
    ; 退出程序
    mov ah, 4ch
    int 21h

; 将带符号整数转换为字符串并输出
; 输入：AX = 带符号整数
; 输出：无
print_signed:
    ; 如果数值为负，则输出负号并取相反数
    cmp ax, 0
    jge not_negative
    neg ax
    mov dl, '-'
    mov ah, 02h
    int 21h
not_negative:
    ; 将数值转换为字符串
    push ax
    mov bx, 10
    xor cx, cx
    convert_loop:
        xor dx, dx
        div bx
        push dx
        inc cx
        cmp ax, 0
        jne convert_loop
    ; 从栈顶弹出数字并输出
    output_loop:
        pop dx
        add dl, '0'
        mov ah, 02h
        int 21h
        loop output_loop
    ; 输出一个换行符
    mov dl, 0ah
    mov ah, 02h
    int 21h
    ; 恢复栈指针
    add sp, cx
    ret

这个程序使用了冒泡排序算法对数组进行排序，然后使用了带符号整数转换为字符串的函数将排序后的结果输出到屏幕上。你可以将这个程序保存为一个文件，然后使用汇编器和链接器将它编译成可执行文件，然后运行它来看到排序后的结果。

用汇编语言，写自BLOCK开始的存储区中， C 有10个带符号字数据凌乱无序，试编 制一个程序把它们降序排列，并显示

以下是用 x86 汇编语言实现的降序排列程序：

section .data
    arr db 3, -5, 1, 0, -2, 7, -4, 9, -6, 2   ; 10个带符号字数据
    len equ $ - arr                          ; 数组长度

section .text
    global _start

_start:
    mov ecx, len                    ; 数组长度
    dec ecx                         ; 最后一个元素不需要比较，减一次循环
outer_loop:
    push ecx                        ; 保存循环计数器
    mov ebx, 0                      ; 初始化数组下标
inner_loop:
    cmp ebx, ecx                    ; 如果当前下标已经到达比较的最后一个元素，则结束内层循环
    jge inner_loop_end

    mov eax, [arr + ebx]            ; 取出当前元素值
    mov edx, [arr + ebx + 1]        ; 取出下一个元素值
    cmp eax, edx                    ; 比较两个元素值大小
    jge no_swap                     ; 如果当前元素大于等于下一个元素，则不需要交换
    xchg eax, edx                  ; 否则交换两个元素值
    mov [arr + ebx], eax            ; 将当前元素值放回数组
    mov [arr + ebx + 1], edx        ; 将下一个元素值放回数组
no_swap:
    inc ebx                         ; 下标加1
    jmp inner_loop                  ; 继续比较下一个元素

inner_loop_end:
    pop ecx                         ; 恢复循环计数器
    loop outer_loop                 ; 如果还有未比较的元素，则继续比较

    ; 显示排好序的数组
    mov ecx, len                    ; 数组长度
    mov ebx, 0                      ; 初始化数组下标
display_loop:
    cmp ebx, ecx                    ; 如果已经显示完所有元素，则结束循环
    jge display_end
    mov eax, [arr + ebx]            ; 取出当前元素值
    call display_signed_number      ; 显示带符号数字
    mov eax, 0x0A                   ; 换行符
    call display_char               ; 显示字符
    inc ebx                         ; 下标加1
    jmp display_loop                ; 继续显示下一个元素

display_end:
    ; 退出程序
    mov eax, 1                      ; 系统调用号 1 表示退出程序
    xor ebx, ebx                    ; 返回值为 0
    int 0x80                        ; 调用 Linux 系统调用

; 显示带符号数字
; 参数：
;   eax - 数字的值
display_signed_number:
    push ebx                        ; 保存 ebx
    mov ebx, eax                    ; 将数字值移动到 ebx
    cmp eax, 0                      ; 判断数字正负性
    jge display_signed_number_positive
    neg eax                         ; 取绝对值
    mov eax, ebx                    ; 将绝对值移回 eax
    mov byte [display_buffer], '-'  ; 显示负号
    inc display_buffer              ; 缓冲区位置加1
display_signed_number_positive:
    mov ecx, 10                     ; 数字转字符串时的除数
    xor edx, edx                    ; edx 存放余数
    mov ebx, display_buffer         ; 缓冲区位置
    add ebx, 9                      ; 从缓冲区末尾开始存储数字字符
digit_loop:
    xor eax, eax                    ; eax 存放商
    div ecx                         ; edx:eax / ecx
    add dl, '0'                     ; 将余数转换为字符
    mov byte [ebx], dl              ; 存储字符到缓冲区
    dec ebx                         ; 缓冲区位置减1
    test eax, eax                   ; 判断商是否为0
    jne digit_loop                  ; 如果商不为0，则继续转换
    pop ebx                         ; 恢复 ebx
    ret

; 显示单个字符
; 参数：
;   eax - 字符 ASCII 码
display_char:
    mov [display_buffer], al        ; 存储字符到缓冲区
    mov ebx, 1                      ; 写入字符数
    mov ecx, display_buffer         ; 缓冲区地址
    mov edx, 1                      ; 字符串长度
    mov eax, 4                      ; 系统调用号 4 表示写文件
    int 0x80                        ; 调用 Linux 系统调用
    ret

section .bss
    display_buffer resb 10          ; 显示缓冲区

运行结果：

$ nasm -f elf32 sort.asm -o sort.o
$ ld -m elf_i386 sort.o -o sort
$ ./sort
9
7
3
2
1
0
-2
-4
-5
-6