汇编实现排序——希尔排序

希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。

以下是汇编实现的代码:

S0  SEGMENT STACK
    DW  20 DUP(?)
TOP LABEL   WORD
S0  ENDS

S1  SEGMENT
TIP DB  "Input ten number and separate the numbers with space:", 0DH, 0AH, 24H
ARY DW  20 DUP(0)
CRLF    DB  0DH, 0AH, 24H
N   DW  0
D   DW  5
AD  DW  10
E   DW  0
S1  ENDS

S2  SEGMENT
    ASSUME  SS:S0, DS:S1, CS:S2, ES:S1
P   PROC    FAR
    MOV AX, S0
    MOV SS, AX
    LEA SP, TOP

    MOV AX, S1
    MOV DS, AX

    MOV AX, S1
    MOV ES, AX

    LEA DX, TIP
    MOV AH, 9
    INT 21H

    LEA SI, ARY

    XOR DX, DX
    MOV BL, 10
    MOV CX, 10

INPUT:  MOV AH, 1
    INT 21H
    CMP AL, 20H ;空格分隔字符
    JE  SAVE
    ;输入十进制数,将数存入SI对应的内存单元
    MOV DL, AL
    MOV AX, [SI]
    MUL BL
    SUB DL, 30H
    ADD AL, DL
    MOV [SI], AX
    JMP INPUT
SAVE:
    ADD SI, 2
    LOOP    INPUT
    ;数组保存完毕

    LEA SI, ARY
    MOV DI, SI
    ADD DI, 18
    MOV E, DI   ;数组末尾地址
    MOV DI, SI

GO: MOV AX, D ;D表示增量,AD表示实际加的数
    SHL AX, 1
    MOV AD, AX ;假设增量为5,由于数组存储类型是DW,每次就需要加10

CMPA:   ADD SI, AD
    MOV AX, SI
    SUB SI, AD
    CMP AX, E ;判断加了增量后是否越界
    JA  CON
    MOV BX, [SI] ;比较当前数与增量后的数
    ADD SI, AD
    MOV AX, [SI]
    SUB SI, AD
    CMP BX, AX
    JA  CHANGE
    ADD SI, 2
    JMP CMPA

CHANGE: ADD SI, AD  ;交换两个数的位置
    MOV AX, [SI]
    SUB SI, AD
    MOV [SI], AX
    ADD SI, AD
    MOV [SI], BX
    SUB SI, AD
    ADD SI, 2
    CALL    PRINT
    JMP CMPA

CON:    MOV AX, D
    SHR AX, 1 ;增量除以2
    MOV D, AX
    MOV SI, DI ;从头开始
    CMP AX, 0 ;增量为0时说明排序完成
    JNE GO

EXIT:   MOV AH, 4CH
    INT 21H

P   ENDP

;以下为十进制输出数组中的所有数
PRINT   PROC    NEAR
    PUSH    SI
    PUSH    CX
    PUSH    AX
    PUSH    DX
    LEA DX, CRLF
    MOV AH, 9
    INT 21H

    LEA SI, ARY
    MOV CX, 10
L1: MOV AX, [SI]
    MOV N, AX
    CALL    OUTPUT
    ADD SI, 2
    MOV DX, 20H
    MOV AH, 2
    INT 21H
    LOOP    L1

    POP DX
    POP AX
    POP CX
    POP SI
    RET

PRINT   ENDP

OUTPUT  PROC    NEAR
    PUSH    AX
    PUSH    BX
    PUSH    CX
    PUSH    DX

    XOR CX, CX
    MOV AX, N
    MOV BX, 10
L2: XOR DX, DX
    DIV BX
    PUSH    DX
    INC CX
    CMP AX, 0
    JNE L2

L3: POP DX
    ADD DX, 30H
    MOV AH, 2
    INT 21H
    LOOP    L3

    POP DX
    POP CX
    POP BX
    POP AX
    RET
OUTPUT  ENDP

S2  ENDS
    END P   

时间: 2024-11-03 18:08:17

汇编实现排序——希尔排序的相关文章

排序算法3--插入排序--希尔排序(缩小增量排序)

希尔排序(缩小增量排序) 希尔排序(Shell Sort)是插入排序的一种.也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本. 该方法的基本思想是:先将整个待排元素序列分割成若干个子序列(由相隔某个“增量”的元素组成的)分别进行直接插入排序,然后依次缩减增量再进行排序,待整个序列中的元素基本有序(增量足够小)时,再对全体元素进行一次直接插入排序.因为直接插入排序在元素基本有序的情况下(接近最好情况),效率是很高的,因此希尔排序在时间效率上比前两种方法有较大提高. 以n=10的一个数组4

排序——希尔排序

希尔排序(Shell Sort)是插入排序的一种.是针对直接插入排序算法的改进.该方法又称缩小增量排序,因DL.Shell于1959年提出而得名. 基本思想: 先取一个小于n的整数d1作为第一个增量,把文件的全部记录分组.所有距离为d1的倍数的记录放在同一个组中.先在各组内进行直接插入排序:然后,取第二个增量d2<d1重复上述的分组和排序,直至所取的增量dt=1(dt<dt-l<-<d2<d1),即所有记录放在同一组中进行直接插入排序为止. 希尔排序的实现代码: #inclu

python排序-希尔排序

Shell 排序利用分组加速部分有序数组排序,分组定长跳跃冒泡 希尔排序的时间性能优于直接插入排序的原因: ①当文件初态基本有序时直接插入排序所需的比较和移动次数均较少. ②当n值较小时,n和 n^2 的差别也较小,即直接插入排序的最好时间复杂度O(n)和最坏时间复杂度0( )差别不大. ③在希尔排序开始时增量较大,分组较多,每组的记录数目少,故各组内直接插入较快,后来增量di逐渐缩小,分组数逐渐减少,而各组的记录数目逐渐增多,但由于已经按di-1作为距离排过序,使文件较接近于有序状态,所以新的

数据结构排序-希尔排序

希尔排序也是插入排序的一种,但是它效率高于直接插入排序. 基本思想是: 首先取一个小于n的整数d1作为第一个增量,把文件的全部记录分组.所有距离为d1的倍数的记录放在同一个组中.先在各组内进行直接插入排序: 然后,取第二个增量d2<的重复上述的分组和排序,直到所取的增量dt=1. 增量序列尤其关键,一般的初次取序列的一半为增量,以后每次减半,直到增量为1. 1 #include <stdio.h> 2 #include <stdlib.h> 3 4 int n; 5 6 /*

数据结构——排序——希尔排序算法

希尔排序,也称递减增量排序算法,是插入排序的一种更高效的改进版本.希尔排序是非稳定排序算法. 希尔排序是基于插入排序的以下两点性质而提出改进方法的: 插入排序在对几乎已经排好序的数据操作时, 效率高, 即可以达到线性排序的效率 但插入排序一般来说是低效的, 因为插入排序每次只能将数据移动一位 原始的算法实现在最坏的情况下需要进行O(n2)的比较和交换.V. Pratt的书对算法进行了少量修改,可以使得性能提升至O(nlog2n).这比最好的比较算法的O(nlogn)要差一些. 希尔排序通过将比较

排序——希尔排序算法实现

最近在和师兄探讨希尔排序的实现原理,得到了师兄的点拨. 进入正题,讲希尔排序首先就要将插入排序,插入排序的原理很简单:给定数组a的[ first,last)区间,经过 i-1次排序之后,a[first]...a[first+i-1]已排好序.第 i  遍处理就是将 a[first+i]插入到a[first]...a[first+i-1]中合适的位置.,是的啊a[first]...a[first+i]成为一个排好序的序列.     可以利用顺序比较的方法来实现. 由于插入排序很简单,所以就不BB了

js排序 希尔排序,快速排序

希尔排序: 定义一个间隔序列,例如是5,3,1.第一次处理,会处理所有间隔为5的,下一次会处理间隔为3的,最后一次处理间隔为1的元素.也就是相邻元素执行标准插入排序. 在开始最后一次处理时,大部分元素都将在正确的位置,算法就不必对很多元素进行交换,这是比插入元素高级的地方. 时间复杂度O(n*logn) 1 function shellSort(){ 2 var N=arr.length; 3 var h=1; 4 while(h<N/3){ 5 h=3*h+1;//设置间隔 6 } 7 whi

经典排序——希尔排序

感谢太原理工大学的算法演示:http://www.tyut.edu.cn/kecheng1/site01/suanfayanshi/shell_sort.asp 在希尔排序中主要是要明白在最底层是通过一次又一次的插入排序来实现的.每次都看成是h(k)个独立的数组,进行插入排序,然后循环h(k-1),h(k-2).....h(1): 代码如下:如果gap=1:那就是最后的插入排序了,不明白插入排序可以看我的插入排序 1 public static void Shell(int [] test){

排序 - 希尔排序(缩小增量排序)

排序过程:先取一个正整数d1 < n, 把所有相隔d1的记录放一组,每个组内进行直接插入排序:然后d2 < d1,重复上述分组和排序操作:直至di = 1,即所有记录放进一个组中排序为止. 希尔排序是不稳定的. 代码: #include <iostream> #include <cstdio> #include <ctime> #include <iomanip> using namespace std; int arr[10000]; void