well, The sorting technique is the traditional Bubble Sort which works by looking through a file of records in memory, and comparing the sort field of each record to the one following it. If any two adjacent records are not in sequence, the sort will exchange the positions of those two records. The sort continues to scan the file until there are no more records to exchange. In this way, records with the higher sort fields get pushed towards the end of the file, and records with the lower sort fields get pushed towards the beginning of the file. All of this takes place in memory so that it appears that the records BUBBLE into place.

The program is given below-
name bubblesort
page 60,80
title ascending order using bubble sort
.model small
.stack 64
.data
a db 34h,78h,56h,47h
si_ze dw $-a ;si_ze=no of elements
.code
bubsort:
mov ax,@data
mov ds,ax
mov bx,si_ze
dec bx ;bx=no of passes needed to complete sorting(n-1)
outlup:
mov cx,bx ;cx=no of comparisions to be performed in a pass
mov si,0
inlup:
mov al,a[si]
inc si
cmp al,a[si]
jb go_on
xchg al,a[si]
mov a[si-1],al
go_on:
loop inlup ;dec cx,until cx=0
dec bx
jnz outlup
int 3 ;breakpoint interrupt
align 16
end bubsort

Answered by Ni .. , an ibibo Master, at 10:55 AM on July 13, 2008

well, The sorting technique is the traditional Bubble Sort which works by looking through a file of records in memory, and comparing the sort field of each record to the one following it. If any two adjacent records are not in sequence, the sort will exchange the positions of those two records. The sort continues to scan the file until there are no more records to exchange. In this way, records with the higher sort fields get pushed towards the end of the file, and records with the lower sort fields get pushed towards the beginning of the file. All of this takes place in memory so that it appears that the records BUBBLE into place.

The program is given below-
name bubblesort
page 60,80
title ascending order using bubble sort
.model small
.stack 64
.data
a db 34h,78h,56h,47h
si_ze dw $-a ;si_ze=no of elements
.code
bubsort:
mov ax,@data
mov ds,ax
mov bx,si_ze
dec bx ;bx=no of passes needed to complete sorting(n-1)
outlup:
mov cx,bx ;cx=no of comparisions to be performed in a pass
mov si,0
inlup:
mov al,a[si]
inc si
cmp al,a[si]
jb go_on
xchg al,a[si]
mov a[si-1],al
go_on:
loop inlup ;dec cx,until cx=0
dec bx
jnz outlup
int 3 ;breakpoint interrupt
align 16
end bubsort

Answered by .... ..... , an ibibo Master, at 5:21 AM on July 12, 2008

well, The sorting technique is the traditional Bubble Sort which works by looking through a file of records in memory, and comparing the sort field of each record to the one following it. If any two adjacent records are not in sequence, the sort will exchange the positions of those two records. The sort continues to scan the file until there are no more records to exchange. In this way, records with the higher sort fields get pushed towards the end of the file, and records with the lower sort fields get pushed towards the beginning of the file. All of this takes place in memory so that it appears that the records BUBBLE into place.

The program is given below-
name bubblesort
page 60,80
title ascending order using bubble sort
.model small
.stack 64
.data
a db 34h,78h,56h,47h
si_ze dw $-a ;si_ze=no of elements
.code
bubsort:
mov ax,@data
mov ds,ax
mov bx,si_ze
dec bx ;bx=no of passes needed to complete sorting(n-1)
outlup:
mov cx,bx ;cx=no of comparisions to be performed in a pass
mov si,0
inlup:
mov al,a[si]
inc si
cmp al,a[si]
jb go_on
xchg al,a[si]
mov a[si-1],al
go_on:
loop inlup ;dec cx,until cx=0
dec bx
jnz outlup
int 3 ;breakpoint interrupt
align 16
end bubsort

Answered by Satya ~ , an ibibo Master, at 4:44 PM on July 10, 2008

The program is given below-
name bubblesort
page 60,80
title ascending order using bubble sort
.model small
.stack 64
.data
a db 34h,78h,56h,47h
si_ze dw $-a ;si_ze=no of elements
.code
bubsort:
mov ax,@data
mov ds,ax
mov bx,si_ze
dec bx ;bx=no of passes needed to complete sorting(n-1)
outlup:
mov cx,bx ;cx=no of comparisions to be performed in a pass
mov si,0
inlup:
mov al,a[si]
inc si
cmp al,a[si]
jb go_on
xchg al,a[si]
mov a[si-1],al
go_on:
loop inlup ;dec cx,until cx=0
dec bx
jnz outlup
int 3 ;breakpoint interrupt
align 16
end bubsort

Answered by Yash , an ibibo Master, at 8:14 PM on July 08, 2008

well pratika, Code segment
Jmp main
Add1 dw 9,3,2,7,1,4,2,5,8,1

Main: mov si,0
call order
mov si,0
call order
mov si,0
call order
mov si,0
call order
mov si,0
call order
mov si,0
call order
mov si,0
call order
mov si,0
call order
ret

order: call orderab
call orderab
call orderab
call orderab
call orderab
call orderab
call orderab
call orderab
call orderab

orderab: mov ax,add1[si]
cmp ax,add1[si+2]
jli finish
mov bx,add1[si+2]
mov add1[si],bx
mov add1[si+2],ax
finish: inc si
inc si
ret

Answered by Raksha , an ibibo Master, at 3:27 PM on June 22, 2008

name bubblesort
page 60,80
title ascending order using bubble sort
.model small
.stack 64
.data
a db 34h,78h,56h,47h
si_ze dw $-a ;si_ze=no of elements
.code
bubsort:
mov ax,@data
mov ds,ax
mov bx,si_ze
dec bx ;bx=no of passes needed to complete sorting(n-1)
outlup:
mov cx,bx ;cx=no of comparisions to be performed in a pass
mov si,0
inlup:
mov al,a[si]
inc si
cmp al,a[si]
jb go_on
xchg al,a[si]
mov a[si-1],al
go_on:
loop inlup ;dec cx,until cx=0
dec bx
jnz outlup
int 3 ;breakpoint interrupt
align 16
end bubsort

Answered by Madhurima , an ibibo Master, at 6:16 PM on June 19, 2008

well, The sorting technique is the traditional Bubble Sort which works by looking through a file of records in memory, and comparing the sort field of each record to the one following it. If any two adjacent records are not in sequence, the sort will exchange the positions of those two records. The sort continues to scan the file until there are no more records to exchange. In this way, records with the higher sort fields get pushed towards the end of the file, and records with the lower sort fields get pushed towards the beginning of the file. All of this takes place in memory so that it appears that the records BUBBLE into place.

The program is given below-
name bubblesort
page 60,80
title ascending order using bubble sort
.model small
.stack 64
.data
a db 34h,78h,56h,47h
si_ze dw $-a ;si_ze=no of elements
.code
bubsort:
mov ax,@data
mov ds,ax
mov bx,si_ze
dec bx ;bx=no of passes needed to complete sorting(n-1)
outlup:
mov cx,bx ;cx=no of comparisions to be performed in a pass
mov si,0
inlup:
mov al,a[si]
inc si
cmp al,a[si]
jb go_on
xchg al,a[si]
mov a[si-1],al
go_on:
loop inlup ;dec cx,until cx=0
dec bx
jnz outlup
int 3 ;breakpoint interrupt
align 16
end bubsort

Answered by Saurabh , an ibibo Master, at 9:05 AM on June 18, 2008

name bubblesort
page 60,80
title ascending order using bubble sort
.model small
.stack 64
.data
a db 34h,78h,56h,47h
si_ze dw $-a ;si_ze=no of elements
.code
bubsort:
mov ax,@data
mov ds,ax
mov bx,si_ze
dec bx ;bx=no of passes needed to complete sorting(n-1)
outlup:
mov cx,bx ;cx=no of comparisions to be performed in a pass
mov si,0
inlup:
mov al,a[si]
inc si
cmp al,a[si]
jb go_on
xchg al,a[si]
mov a[si-1],al
go_on:
loop inlup ;dec cx,until cx=0
dec bx
jnz outlup
int 3 ;breakpoint interrupt
align 16
end bubsort

Answered by Sharad Singh , an ibibo Master, at 5:54 PM on June 17, 2008

hi there

name bubblesort
page 60,80
title ascending order using bubble sort
.model small
.stack 64
.data
a db 34h,78h,56h,47h
si_ze dw $-a ;si_ze=no of elements
.code
bubsort:
mov ax,@data
mov ds,ax
mov bx,si_ze
dec bx ;bx=no of passes needed to complete sorting(n-1)
outlup:
mov cx,bx ;cx=no of comparisions to be performed in a pass
mov si,0
inlup:
mov al,a[si]
inc si
cmp al,a[si]
jb go_on
xchg al,a[si]
mov a[si-1],al
go_on:
loop inlup ;dec cx,until cx=0
dec bx
jnz outlup
int 3 ;breakpoint interrupt
align 16
end bubsort

Answered by Reeta K , an ibibo Master, at 4:18 PM on June 17, 2008

well, The Sort only requires 182 bytes and the machine language is relocatable, therefore you can load and execute this sort anywhere in memory. Although you can put the Sort in any program you like, your file size is going to be limited by available memory. For large files, it is best to write a small Basic program that contains only this Sort, a String large enough to hold your file, and whatever Basic statements it takes to load a file, call the Sort and write out the new sequenced file.

Although the Sort works very fast, its speed can be improved by about 30% by turning Antic off. Just before calling the sort, save the value at PEEK(559) then POKE in a zero. All this does is shut down the screen display, but in so doing, it makes about 30% more CPU cycles available to the Sort. After the sort, POKE the saved valued back into 559 and the screen display will turn back on.

All sort parameters are passed to the Sort in the Basic USR call in the following sequence: 1. Address of the String containing the file. 2. Length of the records. 3. Number of records to be sorted. The next parameters specify the fields to be sorted by; 4.1. Position of the first byte of the field. 4.2. Length of the field. 4.3. '0' for ascending sequence, or '1' for descending sequence. Sort Fields are specified in Major to Minor order. That is, if you want to sort on State, and Zip Code within State, then State is the Major order and should be the first set of Sort Field parameters. The only limitation on the number of sort fields is the number of parameters that fit in the Basic statement calling the Sort.

Answered by Uttam , an ibibo Master, at 8:06 PM on June 16, 2008