for a musical research project where i work with the sorting processes of different sorting algorithms (bubble-sort, heap-sort ...), i have to program such algorithms myself. the ide is that not only the end result of the algorithm is visible but also the constant changes (the mechansim). here the first: bubble-sort.

very simple and inelegant programmed - but the thing i need to have  :-)

 

bubble-sort:

https://en.wikipedia.org/wiki/Bubble_sort

 

have a look to different sorting algorithms:

 

 

greetings

andré

 

;;; bubble-sort -> with all GEN's to see the process of sorting
;;; end-test "until (equal (sort-asc alist) list)" very uncommon (and strange), 
;;; but most simple-stupid test to check the end, only okay for this kind of idea ("watching the process not the endresult")

(defun bubble-sort (seq)
  (let ((alist))
    (progn
      (setf alist (cond ((pitchp (car seq))
                         (pitch-to-midi seq))
                        ((lengthp (car seq))
                         (omn :length seq))
                        (t seq)))
      
      
      (setf alist (loop until (equal (sort-asc alist) list) 
                    with list = alist
                    append (loop 
                             for i from 0 to (- (length list) 2)
                             for j from 1 to (- (length list) 1)
                             when (> (nth i list) (nth j list))
                             collect (setf list (position-swap (list j i) list))
                             else do (setf list list))))
      
      (cond ((pitchp (car seq))
             (midi-to-pitch alist))
            (t alist)))))
 
  

(bubble-sort (rnd-order '(c5 e4 g3 b7)))
(bubble-sort (rnd-order '(t s e q h w)))
(bubble-sort '(1 6 334 2 6 4 111))

 

Nice. You might like the graphical explanation of search algorithms and other algorithms at https://idea-instructions.com. They are visualising such algorithms basically following an IKAE style of graphics. 

 

Best,

Torsten