排序算法之快速排序

快速排序

快速排序(Quick Sort)使用分治法策略。
它的基本思想是：选择一个基准数，通过一趟排序将要排序的数据分割成独立的两部分；其中一部分的所有数据都比另外一部分的所有数据都要小。然后，再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

快速排序流程：
(1) 从数列中挑出一个基准值。
(2) 将所有比基准值小的摆放在基准前面，所有比基准值大的摆在基准的后面(相同的数可以到任一边)；在这个分区退出之后，该基准就处于数列的中间位置。
(3) 递归地把"基准值前面的子数列"和"基准值后面的子数列"进行排序。

 

按照同样的方法，对子数列进行递归遍历。最后得到有序数组！

 

1.Python实现

def SORT(array, i, j):
    if i>j:
        return
    left = i
    right = j
    x = array[i]
    while i < j:

        while i<j:

            if array[j] < x:
                array[i] = array[j]
                i += 1
                break
            j -= 1

        while i<j :
            if array[i] > x:
                array[j] = array[i]
                j -= 1
                break
            i += 1



    array[i] = x
    SORT(array, left, i - 1)
    SORT(array, i + 1, right)


if __name__ == "__main__":
    ARRAY = [20, 40, 30, 10, 60, 50]
    SORT(ARRAY, 0, len(ARRAY) - 1)
    print(ARRAY)

2.C语言实现

void quick_sort(int a[], int l, int r)
{
   
    if (l < r)
    {
        int i,j,x;

        i = l;
        j = r;
        x = a[i];
        while (i < j)
        {
            while(i < j && a[j] > x)
                j--; // 从右向左找第一个小于x的数
            if(i < j)
                a[i++] = a[j];
            while(i < j && a[i] < x)
                i++; // 从左向右找第一个大于x的数
            if(i < j)
                a[j--] = a[i];
        }
        a[i] = x;
        quick_sort(a, l, i-1); /* 递归调用 */
        quick_sort(a, i+1, r); /* 递归调用 */
    }
}


 

3.汇编语言

;完成快速排序 5/5 TODO DOC
S0	SEGMENT STACK
	DW 30H DUP(?)
TOP	LABEL WORD
S0	ENDS
S1	SEGMENT
ARRAY	DW 20,40,30,10,50,60
COUNT	DW ($-ARRAY) ;元素个数*2
HCHH	DB 0DH,0AH,24H ;回车换行
FG		DB 2CH,20H,24H ;逗号，空格

S1	ENDS
S2	SEGMENT
	ASSUME SS:S0,DS:S1,CS:S2
MAIN	PROC FAR
	MOV AX,S0
	MOV SS,AX
	LEA SP,TOP
	MOV AX,S1
	MOV DS,AX
	MOV ES,AX
	
	XOR AX,AX
	CALL OUTP
	
QQSORT:
	MOV BX,0
	MOV BP,COUNT
	SUB BP,2
	CALL Qsort
	
FINISH:
	JMP EXIT
	
EXIT:
	MOV AH,4CH
	INT 21H
	
MAIN	ENDP
Qsort PROC NEAR ;快排递归程序
	PUSH BX
	PUSH BP
	PUSH DI
	
QsortC1:
	CMP BX,BP
	JGE QsortC2
	CALL GetP
	CALL OUTP
	PUSH DI
	PUSH BP
	MOV BP,DI
	SUB BP,2
	CALL Qsort
	POP BP
	POP DI
	PUSH BX
	MOV BX,DI
	ADD BX,2
	CALL Qsort
	POP BP
	
QsortC2:
	POP DI
	POP BP
	POP BX
	RET
Qsort	ENDP

GetP PROC NEAR ;快排获取基准数子程序
	PUSH AX
	PUSH DX
	PUSH BX
	PUSH BP
	
	MOV AX,ARRAY[BX]
	MOV DX,AX
	
GetP_W0:			;获取基准的第一个while循环
	CMP BX,BP
	JGE GetPC1
	
GetP_W1:			;获取基准的第二个while循环
	CMP BX,BP
	JGE GetPCHG1
	CMP ARRAY[BP],AX
	JL GetPCHG1
	SUB BP,2
	JMP GetP_W1
	
GetPCHG1:		;第一个while的赋值
	MOV CX,ARRAY[BP]
	MOV ARRAY[BX],CX

GetP_W2:			;获取基准的第三个while循环
	CMP BX,BP
	JAE GetPCHG2
	CMP ARRAY[BX],AX
	JG GetPCHG2
	ADD BX,2
	JMP GetP_W2
	
GetPCHG2:		;第二个while的赋值
	MOV CX,ARRAY[BX]
	MOV ARRAY[BP],CX
	
	JMP GetP_W0
	
GetPC1:
	MOV ARRAY[BX],DX
	MOV DI,BX
	
	
	POP BP
	POP BX
	POP DX
	POP AX
	RET
	
GetP ENDP
OUTP PROC NEAR
;这段程序是用来输出数组里面的内容的，用逗号，空格分隔，最后输出回车换行
	PUSH AX
	PUSH BX
	PUSH CX
	PUSH DX
	PUSH BP
	PUSH DI
	PUSH SI
	
	MOV BX,0
	MOV CX,COUNT
	LEA SI,ARRAY
	SHR CX,1
	
OUTP_PRINT:
	MOV BX,[SI]
	MOV AX,BX
	OR AX,AX
	JNS OUTP_ZS;ZS表示->正数
	MOV AH,2
	MOV DL,2DH
	INT 21H
	NEG BX
OUTP_ZS:
	MOV AX,BX
	XOR BP,BP
OUTP_L1:
	XOR DX,DX
	MOV DI,10
	DIV DI
	INC BP
	PUSH DX
	CMP AX,0
	JNE OUTP_L1

OUTP_L2:
	POP DX
	ADD DL,30H
	MOV AH,2
	INT 21H
	DEC BP
	JNE OUTP_L2
	
	;, 分隔
	CMP CX,2
	JS  OUTP_L3
	MOV AH,9
	LEA DX,FG
	INT 21H
	
OUTP_L3:
	ADD SI,2
	LOOP OUTP_PRINT
	
	;回车换行
	LEA DX,HCHH
	MOV AH,9
	INT 21H
	
	POP SI
	POP DI
	POP BP
	POP DX
	POP CX
	POP BX
	POP AX
	RET
OUTP ENDP

CRLF PROC NEAR ;回车换行
	PUSH DX
	PUSH AX
	LEA DX,HCHH
	MOV AH,9
	INT 21H
	POP AX
	POP DX
	RET
CRLF ENDP
	
S2	ENDS
	END MAIN