冒泡法和二分法的汇编实现

冒泡排序法(bubble sort),对小数组工作得非常好,但对大数组就非常低效了.因为这是个时间复杂度为O(n²)的算法.其代码实现如下:

;-----------------------------------------------------
BubbleSort PROC USES eax ecx esi,
    pArray:PTR DWORD,        ; pointer to array
    Count:DWORD        ; array size
; Sort an array of 32-bit signed integers in ascending order
; using the bubble sort algorithm.
; Receives: pointer to array, array size
; Returns: nothing
;-----------------------------------------------------

    mov ecx,Count
    dec ecx        ; decrement count by 1

L1:push ecx        ; save outer loop count
    mov esi,pArray        ; point to first value

L2:mov eax,[esi]        ; get array value
    cmp [esi+4],eax        ; compare a pair of values
    jge L3        ; if [esi] <= [edi], don't exch
    xchg eax,[esi+4]        ; exchange the pair
    mov [esi],eax

L3:add esi,4        ; move both pointers forward
    loop L2        ; inner loop

    pop ecx        ; retrieve outer loop count
    loop L1        ; else repeat outer loop

L4:ret
BubbleSort ENDP

二分查找(binary search),非常高效的算法,因为它使用了分治策略(divide and conquer),每次循环后查找范围都会减半,算法时间复杂度为O(log₂n).汇编实现代码如下:

;-----------------------------------------------------
BinarySearch PROC USES ebx edx esi edi,
    pArray:PTR DWORD,        ; pointer to array
    Count:DWORD,        ; array size
    searchVal:DWORD        ; search value
LOCAL first:DWORD,        ; first position
    last:DWORD,        ; last position
    mid:DWORD        ; midpoint
; Search an array of signed integers for a single value.
; Receives: Pointer to array, array size, search value.
; Returns: If a match is found, EAX = the array position of the
; matching element; otherwise, EAX = -1.
;-----------------------------------------------------

    mov    first,0        ; first = 0
    mov    eax,Count        ; last = (count - 1)
    dec    eax
    mov    last,eax
    mov    edi,searchVal        ; EDI = searchVal
    mov    ebx,pArray        ; EBX points to the array

L1:; while first <= last
    mov    eax,first
    cmp    eax,last
    jg    L5        ; exit search

; mid = (last + first) / 2
    mov    eax,last
    add    eax,first
    shr    eax,1
    mov    mid,eax

; EDX = values[mid]
    mov    esi,mid
    shl    esi,2        ; scale mid value by 4
    mov    edx,[ebx+esi]        ; EDX = values[mid]

; if ( EDX < searchval(EDI) )
;    first = mid + 1;
    cmp    edx,edi
    jge    L2
    mov    eax,mid        ; first = mid + 1
    inc    eax
    mov    first,eax
    jmp    L4

; else if( EDX > searchVal(EDI) )
;    last = mid - 1;
L2:cmp    edx,edi        ; optional
    jle    L3
    mov    eax,mid        ; last = mid - 1
    dec    eax
    mov    last,eax
    jmp    L4

; else return mid
L3:mov    eax,mid          ; value found
    jmp    L9        ; return (mid)

L4:jmp    L1        ; continue the loop

L5:mov    eax,-1        ; search failed
L9:ret
BinarySearch ENDP