1 冒泡排序
http://blog.csdn.net/a123443/article/details/6779137
;冒泡排序
;author JRH
;2011.7.10
assume ds:data
data segment
a dw 1,4,2,5,7,9,6,3
data ends
code segment
start:
mov ax,data
mov ds,ax
mov cx,8
dec cx
lop1:
push cx
mov dx,0
mov si,0
lop2:
mov bp,a[si]
cmp bp,a[si+2]
jnb go_on
xchg bp,a[si+2]
mov a[si],bp
mov dx,1 ;标志位
go_on:
add si,2
loop lop2
pop cx
cmp dx,0
jz over
loop lop1
over:
mov ax,4c00h
int 21h
code ends
end start以下代码来自RadASM自带库；
2 递归排序
assort.asm
.486 ; force 32 bit code
.model flat, stdcall ; memory model & calling convention
option casemap :none ; case sensitive
asqsort PROTO :DWORD,:DWORD,:DWORD,:DWORD,:DWORD
acisort PROTO :DWORD,:DWORD
.code
assort proc arr:DWORD,cnt:DWORD,rdi:DWORD
.if rdi == 0
mov rdi, 100 ; set default maximum recursion depth
.endif
mov eax, cnt
sub eax, 1
invoke asqsort,arr,0,eax,0,rdi
xor eax, eax ; exit with EAX = 0 is quick sorted
test edx, edx ; if EDX = 0 quick sort failed by
jnz @F ; exceeding maximum recursion depth
invoke acisort,arr,cnt
mov eax, 1 ; exit with EAX = 1 is CISORTed
@@:
ret
assort endp
endrdi为最大递归深度
本过程调用了asqsort和acisort
3 快速排序
asqsort.asm
.486 ; force 32 bit code
.model flat, stdcall ; memory model & calling convention
option casemap :none ; case sensitive
.code
asqsort proc arr:DWORD,i:DWORD,j:DWORD,rec:DWORD,ind:DWORD
test edx, edx
jz quit
mov eax, i
cmp eax, j
jge quit
add rec, 1 ; increment recursion depth indicator
mov eax, rec
cmp eax, ind
jl @F
xor edx, edx ; set bailout indicator
jmp quit
@@:
mov [esp-8], ebx
mov [esp-12], esi
mov [esp-16], edi
mov edi, arr
mov esi, i
mov ebx, j
mov [esp-20], ebp ; save EBP
mov edx, [edi+ebx*4] ; pivot is from higher index value
sub ebx, 1
cmp esi, ebx
jg lbl5
lbl0:
sub esi, 1
align 4
lbl1:
add esi, 1 ; increment lower index
; ***************************
mov ecx, [edi+esi*4] ; load lower index string
mov ebp, -1
sts0:
add ebp, 1
mov al, [ecx+ebp] ; compare lower and pivot strings
cmp al, [edx+ebp]
jg nxt0
jl lbl1
test al, al
jnz sts0
nxt0:
; ***************************
align 4
lbl2:
; ***************************
mov ecx, [edi+ebx*4] ; load upper index string
mov ebp, -1
sts1:
add ebp, 1
mov al, [ecx+ebp] ; compare upper and pivot strings
cmp al, [edx+ebp]
jg nxt1
jl lbl3
test al, al
jnz sts1
nxt1:
; ***************************
sub ebx, 1 ; decrement upper index
cmp ebx, esi
jge lbl2
lbl3:
cmp esi, ebx
jg lbl5
mov eax, [edi+esi*4] ; swap pointers
mov ecx, [edi+ebx*4]
mov [edi+esi*4], ecx
mov [edi+ebx*4], eax
add esi, 1
sub ebx, 1
cmp esi, ebx
jle lbl0
lbl5:
mov ebp, [esp-20] ; restore EBP before using LOCAL
mov eax, j
mov edx, [edi+esi*4]
mov ecx, [edi+eax*4]
mov [edi+esi*4], ecx
mov [edi+eax*4], edx
mov eax, esi
mov ebx, [esp-8]
mov esi, [esp-12]
mov edi, [esp-16]
push eax
sub eax, 1
invoke asqsort,arr,i,eax,rec,ind
@@:
pop eax
add eax, 1
invoke asqsort,arr,eax,j,rec,ind
quit:
ret
asqsort endp
end快速排序（Quicksort）是对冒泡排序的一种改进。
它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外
一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归
进行，以此达到整个数据变成有序序列。
输入参数为i,j,rec,ind；四个DWORD类型；
如果edx为0直接退出；
i小于j直接退出；
JGE：如果大于或等于(>=)则跳转
rec：递归深度指示变量
首先把ebx,esi,edi的值存入堆栈；
数组首址是arr，放入edi；
在lbl5段和@@段中调用了自身；
4 acisort
acisort.asm
.486 ; force 32 bit code
.model flat, stdcall ; memory model & calling convention
option casemap :none ; case sensitive
include \masm32\macros\macros.asm
aissort PROTO :DWORD,:DWORD
.code
align 4
acisort proc arr:DWORD,cnt:DWORD
LOCAL gap :DWORD
LOCAL sflag :DWORD
LOCAL hflag :DWORD
LOCAL eflag :DWORD
push ebx
push esi
push edi
mov eax, cnt
mov gap, eax ; copy cnt to gap
mov ebx, arr ; address of 1st element
dec cnt
; --------------------------------------------------
; bi-directional COMB preordering pass
; --------------------------------------------------
setgap:
fild gap ; load integer memory operand to divide
fdiv FP8(1.35) ; divide gap by constant
fistp gap ; store result back in integer memory operand
sub gap, 1 ; round down by 1
cmp gap, 10
jg @F
cmp gap, 9 ; comb 11 code
jl @F
mov gap, 11
@@:
cmp gap, 1
jle nxt ; exit when gap <= 1
mov edi, cnt
sub edi, gap
mov eflag, edi
xor ecx, ecx ; low value index
inner:
mov edx, ecx
add edx, gap ; high value index
push ebp
mov ebp, [ebx+ecx*4] ; lower value
mov esi, [ebx+edx*4] ; swap values
mov edi, -1
; ===========================================
cmpstrings:
add edi, 1
mov al, [ebp+edi] ; compare both strings
cmp al, [esi+edi]
jl noswap ; ascending sort
jg swap ; swap these two labels for descending
test al, al
jnz cmpstrings
; ===========================================
jmp noswap
swap:
mov [ebx+edx*4], ebp
mov [ebx+ecx*4], esi
noswap:
pop ebp
add ecx, 1
cmp ecx, eflag
jle inner
; *******************************
fild gap ; load integer memory operand to divide
fdiv FP8(1.4) ; divide gap by constant
fistp gap ; store result back in integer memory operand
sub gap, 1 ; round down by 1
cmp gap, 10
jg @F
cmp gap, 9 ; comb 11 code
jl @F
mov gap, 11
@@:
cmp gap, 1
jle nxt ; exit when gap <= 1
mov ecx, cnt
sub ecx, gap ; calculate ECX as cnt - gap
rinner:
mov edx, ecx
add edx, gap ; high value index
push ebp
mov ebp, [ebx+ecx*4] ; lower value
mov esi, [ebx+edx*4] ; swap values
mov edi, -1
; ===========================================
rcmpstrings:
add edi, 1
mov al, [ebp+edi] ; compare both strings
cmp al, [esi+edi]
jl rnoswap ; ascending sort
jg rswap ; swap these two labels for descending
test al, al
jnz rcmpstrings
; ===========================================
jmp rnoswap
rswap:
mov [ebx+edx*4], ebp
mov [ebx+ecx*4], esi
rnoswap:
pop ebp
sub ecx, 1
jnz rinner
jmp setgap
nxt:
inc cnt
invoke aissort,arr,cnt ; call the insertion sort to clean up the rest
done:
pop edi
pop esi
pop ebx
ret
acisort endp
end输入参数：arr,cnt；数组和个数；
本地变量：gap,sflag,hflag,eflat；三个标志变量；
调用了插入排序(aissort)来清除rest；
rcmpstrings段：
比较ebp+edi指向的值和esi+edi指向的值，
小于转到rnoswap
大于转到rswap
rswap-交换：
把ebp存入ebx+edx*4的地址；
把esi存入ebx+ecx*4的地址；
5 插入排序(升序)
aissort.asm
.486 ; force 32 bit code
.model flat, stdcall ; memory model & calling convention
option casemap :none ; case sensitive
.code
OPTION PROLOGUE:NONE
OPTION EPILOGUE:NONE
align 4
aissort proc arr:DWORD,cnt:DWORD
; -------------------------------
; ascending insertion string sort
; -------------------------------
mov [esp-8], ebx
mov [esp-12], esi
mov [esp-16], edi
mov [esp-20], ebp
mov edi, [esp+4] ; array address
mov edx, 1
cmp edx, [esp+8] ; compare count to EDX
jge quit
xor eax, eax ; clear EAX of previous content
entry:
mov ebx, [edi+edx*4]
mov esi, edx
inner:
mov ecx, [edi+esi*4-4]
mov ebp, -1
stcmp: ; string comparison loop
add ebp, 1
mov al, [ecx+ebp]
cmp al, [ebx+ebp]
jl outer
jg swap
test al, al
jnz stcmp
jmp outer
swap:
mov [edi+esi*4], ecx
sub esi, 1
jnz inner
outer:
mov [edi+esi*4], ebx
add edx, 1
cmp edx, [esp+8] ; compare count to EDX
jl entry
quit:
mov ebx, [esp-8]
mov esi, [esp-12]
mov edi, [esp-16]
mov ebp, [esp-20]
ret 8
aissort endp
OPTION PROLOGUE:PrologueDef
OPTION EPILOGUE:EpilogueDef
end
.486 ; force 32 bit code
.model flat, stdcall ; memory model & calling convention
option casemap :none ; case sensitive
.code
OPTION PROLOGUE:NONE
OPTION EPILOGUE:NONE
align 4
aissort proc arr:DWORD,cnt:DWORD
; -------------------------------
; ascending insertion string sort
; -------------------------------
mov [esp-8], ebx
mov [esp-12], esi
mov [esp-16], edi
mov [esp-20], ebp
mov edi, [esp+4] ; array address
mov edx, 1
cmp edx, [esp+8] ; compare count to EDX
jge quit
xor eax, eax ; clear EAX of previous content
entry:
mov ebx, [edi+edx*4]
mov esi, edx
inner:
mov ecx, [edi+esi*4-4]
mov ebp, -1
stcmp: ; string comparison loop
add ebp, 1
mov al, [ecx+ebp]
cmp al, [ebx+ebp]
jl outer
jg swap
test al, al
jnz stcmp
jmp outer
swap:
mov [edi+esi*4], ecx
sub esi, 1
jnz inner
outer:
mov [edi+esi*4], ebx
add edx, 1
cmp edx, [esp+8] ; compare count to EDX
jl entry
quit:
mov ebx, [esp-8]
mov esi, [esp-12]
mov edi, [esp-16]
mov ebp, [esp-20]
ret 8
aissort endp
OPTION PROLOGUE:PrologueDef
OPTION EPILOGUE:EpilogueDef
end数组地址存入edi；
比较次数存入edx；
stcmp-字符串比较循环：比较的是ecx+ebp地址处的值和ebx+ebp地址处的值
6 插入排序(降序)
.486 ; force 32 bit code
.model flat, stdcall ; memory model & calling convention
option casemap :none ; case sensitive
.code
OPTION PROLOGUE:NONE
OPTION EPILOGUE:NONE
align 4
dissort proc arr:DWORD,cnt:DWORD
; --------------------------------
; descending insertion string sort
; --------------------------------
mov [esp-8], ebx
mov [esp-12], esi
mov [esp-16], edi
mov [esp-20], ebp
mov edi, [esp+4] ; array address
mov edx, 1
cmp edx, [esp+8] ; compare count to EDX
jge quit
xor eax, eax ; clear EAX of previous content
entry:
mov ebx, [edi+edx*4]
mov esi, edx
inner:
mov ecx, [edi+esi*4-4]
mov ebp, -1
stcmp: ; string comparison loop
add ebp, 1
mov al, [ecx+ebp]
cmp al, [ebx+ebp]
jg outer
jl swap
test al, al
jnz stcmp
jmp outer
swap:
mov [edi+esi*4], ecx
sub esi, 1
jnz inner
outer:
mov [edi+esi*4], ebx
add edx, 1
cmp edx, [esp+8] ; compare count to EDX
jl entry
quit:
mov ebx, [esp-8]
mov esi, [esp-12]
mov edi, [esp-16]
mov ebp, [esp-20]
ret 8
dissort endp
OPTION PROLOGUE:PrologueDef
OPTION EPILOGUE:EpilogueDef
end