冒泡排序不返回排序数组答案

【问题标题】：bubble sort doesn´t return a sorted array冒泡排序不返回排序数组
【发布时间】：2023-03-28 21:10:01
【问题描述】：

这是由 if´s only 组成的冒泡排序。这是我在 Lisp 中的第一个代码，这就是为什么我没有使用函数“循环”或“DO”，因为我不知道如何使用它们。

(defun bubble()
    ((let (array (make-array '(4))))
          (setf (aref array 0) 7)
          (setf (aref array 1) 2)
          (setf (aref array 2) 4)
          (setf (aref array 3) 5))     
    (setf i 0)
    (defun c1 (IF (<= i (- n 1))
         (progn (setq j 1)
               (defun c2 (j) (IF (<= j (- n i))
                                     (progn(IF (> (aref array j) (aref array (+ j 1)))
                                           (progn (setq aux (aref array (+ j 1)))
                                                   (setq (aref array (+ j 1)) (aref array j))
                                                   (setq (aref array j) aux)
                                                   (c2 (setq j (+ j 1))))

                                                 (c2 (setq j (+ j 1)))
                                            );if
                                     );progn

                                     (c1 (setq i (+ i 1))) 
                                 );if
               );c2   
          );progn
         array();
        ) 
     );c1
);bubble

问题是它不打印数组，它只打印单词 BUBBLE。有人在之前的帖子中说过 defun 总是返回函数的名称，但是没有 defun 我怎么能创建一个名为 bubble 的函数返回一个数组？？？

【问题讨论】：

嵌套 DEFUN 错误。将 LABELS 或 FLET 用于本地函数。
您可能还想正确缩进和格式化代码以使其可读。

标签： lisp

【解决方案1】：

我认为我们必须把这个分开。

如果你使用适当的缩进，你就不需要注释你的括号，这使得整体编码体验更好：

(defun bubble ()
  ((let (array (make-array '(4))))
   (setf (aref array 0) 7)
   (setf (aref array 1) 2)
   (setf (aref array 2) 4)
   (setf (aref array 3) 5))     
  (setf i 0)
  (defun c1 (IF (<= i (- n 1))
                (progn (setq j 1)
                       (defun c2 (j) (if (<= j (- n i))
                                         (progn (if (> (aref array j) (aref array (+ j 1)))
                                                    (progn (setq aux (aref array (+ j 1)))
                                                           (setq (aref array (+ j 1)) (aref array j))
                                                           (setq (aref array j) aux)
                                                           (c2 (setq j (+ j 1))))
                                                    (c2 (setq j (+ j 1)))))
                                         (c1 (setq i (+ i 1))))))
                array
                ())))

现在，有一些语法错误。我不知道在没有警告的情况下如何编译。

您的defun c1 ... 表单缺少参数列表。

(defun bubble ()
  ((let (array (make-array '(4))))
   (setf (aref array 0) 7)
   (setf (aref array 1) 2)
   (setf (aref array 2) 4)
   (setf (aref array 3) 5))     
  (setf i 0)
  (defun c1 ()
    (if (<= i (- n 1))
        (progn (setq j 1)
               (defun c2 (j) (if (<= j (- n i))
                                 (progn (if (> (aref array j) (aref array (+ j 1)))
                                            (progn (setq aux (aref array (+ j 1)))
                                                   (setq (aref array (+ j 1)) (aref array j))
                                                   (setq (aref array j) aux)
                                                   (c2 (setq j (+ j 1))))
                                            (c2 (setq j (+ j 1)))))
                                 (c1 (setq i (+ i 1))))))
        array
        ())))

您的let 表单完全混乱。 Let 可以创建多个绑定，因此您需要将绑定包装在一个列表中。 let 表单也不是有效的运算符。它的主体需要在表单内部。绑定只有主体的范围。

(defun bubble ()
  (let ((array (make-array '(4))))
    (setf (aref array 0) 7)
    (setf (aref array 1) 2)
    (setf (aref array 2) 4)
    (setf (aref array 3) 5)
    (setf i 0)
    (defun c1 ()
      (if (<= i (- n 1))
          (progn (setq j 1)
                 (defun c2 (j) (if (<= j (- n i))
                                   (progn (if (> (aref array j) (aref array (+ j 1)))
                                              (progn (setq aux (aref array (+ j 1)))
                                                     (setq (aref array (+ j 1)) (aref array j))
                                                     (setq (aref array j) aux)
                                                     (c2 (setq j (+ j 1))))
                                              (c2 (setq j (+ j 1)))))
                                   (c1 (setq i (+ i 1))))))
          array
          ()))))

c1 中的 if 表单有四个参数，但 if 只需要三个参数。我将在最后删除()，这似乎很荒谬：

(defun bubble ()
  (let ((array (make-array '(4))))
    (setf (aref array 0) 7)
    (setf (aref array 1) 2)
    (setf (aref array 2) 4)
    (setf (aref array 3) 5)
    (setf i 0)
    (defun c1 ()
      (if (<= i (- n 1))
          (progn (setq j 1)
                 (defun c2 (j) (if (<= j (- n i))
                                   (progn (if (> (aref array j) (aref array (+ j 1)))
                                              (progn (setq aux (aref array (+ j 1)))
                                                     (setq (aref array (+ j 1)) (aref array j))
                                                     (setq (aref array j) aux)
                                                     (c2 (setq j (+ j 1))))
                                              (c2 (setq j (+ j 1)))))
                                   (c1 (setq i (+ i 1))))))
          array))))

不要试图嵌套defuns。这不像你想象的那样工作。它仍然会定义全局函数定义，只是在不同的时间。对于局部函数定义，使用labels 或flet：

(defun bubble ()
  (let ((array (make-array '(4))))
    (setf (aref array 0) 7)
    (setf (aref array 1) 2)
    (setf (aref array 2) 4)
    (setf (aref array 3) 5)
    (setf i 0)
    (labels ((c1 ()
               (if (<= i (- n 1))
                   (progn (setq j 1)
                          (labels ((c2 (j)
                                     (if (<= j (- n i))
                                         (progn (if (> (aref array j) (aref array (+ j 1)))
                                                    (progn (setq aux (aref array (+ j 1)))
                                                           (setq (aref array (+ j 1)) (aref array j))
                                                           (setq (aref array j) aux)
                                                           (c2 (setq j (+ j 1))))
                                                    (c2 (setq j (+ j 1)))))
                                         (c1 (setq i (+ i 1))))))))
                   array))))))

让我们缩短数组初始化时间：

(defun bubble ()
  (let ((array (copy-seq #(7 2 4 5))))
    (setf i 0)
    (labels ((c1 ()
               (if (<= i (- n 1))
                   (progn (setq j 1)
                          (labels ((c2 (j)
                                     (if (<= j (- n i))
                                         (progn (if (> (aref array j) (aref array (+ j 1)))
                                                    (progn (setq aux (aref array (+ j 1)))
                                                           (setq (aref array (+ j 1)) (aref array j))
                                                           (setq (aref array j) aux)
                                                           (c2 (setq j (+ j 1))))
                                                    (c2 (setq j (+ j 1)))))
                                         (c1 (setq i (+ i 1))))))))
                   array))))))

Aux、n、j 和 i 未定义。通过设置它们，您可以创建可能是也可能不是特殊的新全局变量。不要那样做。首先使用let 为它们创建绑定。此外，单个表单不需要progn。

(defun bubble ()
  (let ((array (copy-seq #(7 2 4 5)))
        (n 4)
        (i 0)
        (aux 0))
    (labels ((c1 ()
               (if (<= i (- n 1))
                   (let ((j 1))
                     (labels ((c2 (j)
                                (if (<= j (- n i))
                                    (if (> (aref array j) (aref array (+ j 1)))
                                        (progn (setq aux (aref array (+ j 1)))
                                               (setq (aref array (+ j 1)) (aref array j))
                                               (setq (aref array j) aux)
                                               (c2 (setq j (+ j 1))))
                                        (c2 (setq j (+ j 1))))
                                    (c1 (setq i (+ i 1))))))))
                   array))))))

我认为我们现在已经讨论了句法问题。让我们来简化一下。

可以使用rotatef 交换两个（或更多）位置，您无需为此创建临时变量。有一个函数1+ 可以给某物加1。

(defun bubble ()
  (let ((array (copy-seq #(7 2 4 5)))
        (n 4)
        (i 0))
    (labels ((c1 ()
               (if (<= i (- n 1))
                   (let ((j 1))
                     (labels ((c2 (j)
                                (if (<= j (- n i))
                                    (if (> (aref array j) (aref array (1+ j)))
                                        (progn (rotatef (aref array j)
                                                        (aref array (1+ j)))
                                               (c2 (setq j (1+ j))))
                                        (c2 (setq j (1+ j))))
                                    (c1 (setq i (1+ i))))))))
                   array))))))

通过incf 增加变量的值并将其存储回该变量：

(defun bubble ()
  (let ((array (copy-seq #(7 2 4 5)))
        (n 4)
        (i 0))
    (labels ((c1 ()
               (if (<= i (- n 1))
                   (let ((j 1))
                     (labels ((c2 (j)
                                (if (<= j (- n i))
                                    (if (> (aref array j) (aref array (1+ j)))
                                        (progn (rotatef (aref array j)
                                                        (aref array (1+ j)))
                                               (c2 (incf j)))
                                        (c2 (incf j)))
                                    (c1 (incf i)))))))
                   array))))))

不要使用<= 对比整数小一 进行测试，而是使用< 对整数本身进行测试：

(defun bubble ()
  (let ((array (copy-seq #(7 2 4 5)))
        (n 4)
        (i 0))
    (labels ((c1 ()
               (if (< i n)
                   (let ((j 1))
                     (labels ((c2 (j)
                                (if (< j n)
                                    (if (> (aref array j) (aref array (1+ j)))
                                        (progn (rotatef (aref array j)
                                                        (aref array (1+ j)))
                                               (c2 (incf j)))
                                        (c2 (incf j)))
                                    (c1 (incf i)))))))
                   array))))))

不要重复对c2的内部调用，而是将你想做的事情移到一级之前。

(defun bubble ()
  (let ((array (copy-seq #(7 2 4 5)))
        (n 4)
        (i 0))
    (labels ((c1 ()
               (if (< i n)
                   (let ((j 1))
                     (labels ((c2 (j)
                                (if (< j n)
                                    (progn
                                      (when (> (aref array j)
                                               (aref array (1+ j)))
                                        (rotatef (aref array j)
                                                 (aref array (1+ j))))
                                      (c2 (incf j)))
                                    (c1 (incf i)))))))
                   array))))))

你的内部函数永远不会被调用。让我们解决这个问题，并清理参数处理：

(defun bubble ()
  (let ((array (copy-seq #(7 2 4 5)))
        (n 4))
    (labels ((c1 (i)
               (if (< i n)
                   (labels ((c2 (j)
                              (if (< j n)
                                  (progn
                                    (when (> (aref array j)
                                             (aref array (1+ j)))
                                      (rotatef (aref array j)
                                               (aref array (1+ j))))
                                    (c2 (1+ j)))
                                  (c1 (1+ i)))))
                     (c2 1))
                   array)))
      (c1 0))))

J 不应从 1 运行，而应从 i 运行。 I 和 j 只能运行到 (1- n) 以下，因为 (1+ j) 需要是有效的数组索引。

(defun bubble ()
  (let ((array (copy-seq #(7 2 4 5)))
        (n 4))
    (labels ((c1 (i)
               (if (< i (1- n))
                   (labels ((c2 (j)
                              (if (< j (1- n))
                                  (progn
                                    (when (> (aref array j)
                                             (aref array (1+ j)))
                                      (rotatef (aref array j)
                                               (aref array (1+ j))))
                                    (c2 (1+ j)))
                                  (c1 (1+ i)))))
                     (c2 i))
                   array)))
      (c1 0))))

我认为这现在可行，只要数组长度小于您的堆栈限制。

不要在函数内部定义要排序的数组，而是将其作为参数传递是有意义的。这样，您实际上可以使用该函数对任何数组（实际上是任何向量，即一维数组）进行排序。 N 是该向量的长度。

(defun bubble (vector)
  (let ((n (length vector)))
    (labels ((c1 (i)
               (if (< i (1- n))
                   (labels ((c2 (j)
                              (if (< j (1- n))
                                  (progn
                                    (when (> (aref vector j)
                                             (aref vector (1+ j)))
                                      (rotatef (aref vector j)
                                               (aref vector (1+ j))))
                                    (c2 (1+ j)))
                                  (c1 (1+ i)))))
                     (c2 i))
                   vector)))
      (c1 0))))

;;; For example, call with (bubble (copy-seq #(7 2 4 5))). It should return #(2 4 5 7).

为了不修改作为参数传递的向量，请在排序前使用copy-seq 进行复制。让函数修改其参数总是令人惊讶。我们也不会在修改文字数据时遇到潜在的麻烦。

(defun bubble (unsorted-vector)
  (let ((vector (copy-seq unsorted-vector))
        (n (length unsorted-vector)))
    (labels ((c1 (i)
               (if (< i (1- n))
                   (labels ((c2 (j)
                              (if (< j (1- n))
                                  (progn
                                    (when (> (aref vector j)
                                             (aref vector (1+ j)))
                                      (rotatef (aref vector j)
                                               (aref vector (1+ j))))
                                    (c2 (1+ j)))
                                  (c1 (1+ i)))))
                     (c2 i))
                   vector)))
      (c1 0))))

;;; For example, call with (bubble #(7 2 4 5)). It should return #(2 4 5 7).

为了消除堆栈限制，让我们将其转换为循环。

(defun bubble (unsorted-vector)
  (let ((vector (copy-seq unsorted-vector))
        (n (length unsorted-vector)))
    (loop :for i :below (1- n)
      :do (loop :for j :from i :below (1- n)
            :do (when (> (aref vector j)
                         (aref vector (1+ j)))
                  (rotatef (aref vector j)
                           (aref vector (1+ j))))))
    vector))

【讨论】：

【解决方案2】：

你必须在定义函数后调用它。

【讨论】：

@mp 我必须用数组作为参数调用函数吗，比如 bubble(7 2 4 5);???
气泡函数不带参数，要排序的数组在函数体内定义。