Bubble Sort Common Lisp Error - sorting

Question

I'm trying to implement Bubble Sort in Common Lisp, and I'm having a tough time getting my bearings.[See Below] is what I've got so far, which follows the algorithm as far as I can tell, but I'm getting the error " Undefined function SORTED called with arguments ()." when I run it. I can't seem to find what's the cause of that.
(defun bubble (lis)
(let ((sorted nil) (j 0))
(do () ((not sorted))
(progn
(setf sorted t)
(do (i j (+ i 1))
(if (< (nth i lis) (nth (+ i 1) lis))
(progn
(swap1 (lis (nth i lis) (nth (+ i 1) lis)))
(setf sorted nil)
)
)
)
)
)
)
)

Answer 1

Each call to NTH needs to iterate over the list. If you treat a list like a vector, you probably should use vectors instead. And in the case you don't really care about being efficient, you might still want to use ELT instead of NTH, since ELT works on any kind of sequence. That way, you can pass either vectors or lists and at least one of them will work reasonably well (as far as bubble sort can be efficient).
You might end up having something like the one from Rosetta Code.
By the way, Rosetta Code has an example of an iterative Bubble sort for lists, so I won't copy it. Instead, here below is a recursive version that I adapted from a Prolog one (by Roman Barták). As such it is not necessarily better, but it uses multiple values, ETYPECASE, DESTRUCTURING-BIND, ... features that are apparently not usually taught.
(defun bubble-sort (list)
(labels
((bsort (list acc)
(etypecase list
(null acc)
(cons (destructuring-bind (head . tail) list
(multiple-value-bind (new-tail max)
(bubble head tail)
(bsort new-tail
(cons max acc)))))))
(bubble (x list)
(etypecase list
(null (values nil x))
(cons (destructuring-bind (y . tail) list
(multiple-value-bind (new-tail max)
(bubble (max x y) tail)
(values (cons (min x y) new-tail)
max)))))))
(bsort list nil)))

Answer 2

There are quite a few things we can do to improve this code.
And something you can do to improve your question. If you ask again please provide the test cases and the specific issue.
Indenting
Lisp has relatively little syntax, but we use indenting to help highlight the structure of the code. Most Lisp aware editors help manage that. The most obvious departure from the conventional indenting approach is closing parentheses on following lines. I've Indented the mergelist function to show a more readable function body - well, at least to me.
(defun bubble (lis)
(let ((sorted nil) (j 0))
(do () ((not sorted))
(progn
(setf sorted t)
(do (i j (+ i 1))
(if (< (nth i lis) (nth (+ i 1) lis))
(progn
(swap1 (lis (nth i lis) (nth (+ i 1) lis)))
(setf sorted nil))))))))
Loop vs DO
DO has a long pedigree in lisp, but to be honest, I always make mistakes with DO, so don't use it very often. I can never remember where to return form goes, the increment. I tend to use LOOP
But first off, we don't need to use progn. Most looping constructs have an implicit progn for the code they are iterating so
(defun bubble-1 (lis)
(let ((sorted nil) (j 0))
(do () ((not sorted))
(setf sorted t)
(do (i j (+ i 1))
(if (< (nth i lis) (nth (+ i 1) lis))
(swap1 (lis (nth i lis) (nth (+ i 1) lis)))
(setf sorted nil))))))
Slightly nicer. Looking at your code there is the call to swap1, which must be a defun supplied somewhere. THis line also has a syntax problem as 'lis' appears as a function call.
Lets try to evaluate the function and see what happens
; in: DEFUN BUBBLE-1
; (LET ((SORTED NIL) (J 0))
; (DO ()
; ((NOT SORTED))
; (SETF SORTED T)
; (DO (I
; J
; (+ I 1))
; (IF (< # #) (SWAP1 #) (SETF #)))))
;
; caught STYLE-WARNING:
; The variable J is defined but never used.
; in: DEFUN BUBBLE-1
; (DO (I
; J
; (+ I 1))
; (IF
; (< (NTH I LIS) (NTH (+ I 1) LIS))
; (SWAP1 (LIS (NTH I LIS) (NTH # LIS)))
; (SETF SORTED NIL)))
; --> BLOCK
; ==>
; (LET (I J (+ I))
; (TAGBODY
; (GO #:G3)
; #:G2
; (TAGBODY)
; (PSETQ + 1)
; #:G3
; (UNLESS IF (GO #:G2))
; (RETURN-FROM NIL (PROGN (< # #) (SWAP1 #) (SETF #)))))
;
; caught WARNING:
; undefined variable: I
; --> BLOCK LET TAGBODY UNLESS
; ==>
; (IF IF
; NIL
; (GO #:G2))
;
; caught WARNING:
; undefined variable: IF
; (LIS (NTH I LIS) (NTH (+ I 1) LIS))
;
; caught STYLE-WARNING:
; undefined function: LIS
; (SWAP1 (LIS (NTH I LIS) (NTH (+ I 1) LIS)))
;
; caught STYLE-WARNING:
; undefined function: SWAP1
;
; compilation unit finished
; Undefined functions:
; LIS SWAP1
; Undefined variables:
; I IF
; caught 2 WARNING conditions
; caught 3 STYLE-WARNING conditions`enter code here`
Wow. THis is telling us a few things
The variable J in the nested DO is not used. Remove it.
The syntax for DO in the nested loop is wrong. It needs to be of the general form
(DO ((var init step))
(termination-test result-form)
statement)
The nested do is missing its termination test. Also the variable declaration for i is missing its initialization.
The Let is kind of redundant you can move the declaration of sorted into the do
(do ((sorted nil)) ((not sorted ) ... )
The form
(SWAP1 (LIS (NTH I LIS) (NTH (+ I 1) LIS)))
has two problems. Firstly SWAP1 is undefined. Secondly the form (LIS (NTH I LIS) (NTH (+ I 1) LIS)) can't possibly be right as LIS appears in a function call position. Anything that appears at the front of a form must be a function. In this cas LIS is a parameter.
Fortunately Common Lisp has an inbuilt function that will swap to values for us - its called rotatef. So the entires form would need to look like
(rotatef (nth I lis) (nth (1+ i) lis))
Once function runs, it has no result form in the do, so the sorted array will never be returned to the caller. You will see no output. You need to think about the fact you have nested loops here.
I would think a bit about your algorithm. As Zephyr Pellerin says above, a recursive solution would be much nicer, so unless your assignment is to use an iterative solution

Answer 3

You should study the answer of David Hodge that details all the problems of your code. Here I offer an iterative version of Bubble Sort that uses the do special form. The only main difference from the algorithm that you tried to implement with your code is the use of a variable end which is decremented each time to reduce the number of tests:
(defun bubble (lis)
(let ((sorted nil)
(end (length lis)))
(do () (sorted lis)
(setf sorted t)
(decf end)
(do ((i 0 (1+ i)))
((>= i end))
(when (< (nth i lis) (nth (1+ i) lis))
(rotatef (nth i lis) (nth (1+ i) lis))
(setf sorted nil))))))