lisp - 冒泡排序不返回排序数组-6ren

lisp - 冒泡排序不返回排序数组

转载作者：太空宇宙更新时间：2023-11-03 18:56:39

这是一个仅由 if 组成的冒泡排序。这是我在 Lisp 中的第一个代码，这就是为什么我没有使用函数“loop”或“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 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可以创建多个绑定(bind)，因此您需要将绑定(bind)包装在一个列表中。 let form 也不是有效的运算符。它的主体需要在表单内部。绑定(bind)只有主体的范围。

(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
          ()))))

你的 if表格 c1有四个参数，但是 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))))

不要试图嵌套defun秒。这不像你想象的那样有效。它仍然会定义全局函数定义，只是在不同的时间。对于局部函数定义，使用 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 为它们创建绑定(bind).此外，您不需要 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))))))

而不是使用 <= 进行测试针对小于整数的 1，使用 < 进行测试针对整数本身:

(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))

关于lisp - 冒泡排序不返回排序数组，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/26836528/

文章推荐： css - jQuery UI - 使用不同的图标 css 和 .button()

文章推荐： python - Zed 的 Learn Python the Hard way 练习 25 中的 'import' key

文章推荐： html - 网站的简单读入文件

javascript - 如何停止自定义事件中的事件传播/冒泡
我在 Angular 项目中使用了来自 Github 的模块项目，它可以让我调整 DOM 元素的大小，这些元素绘制在 div 之上，充当绘图板。为了塑造我的第一个元素(它们是简单的矩形)，顺便说一句
C#冒泡/传递事件
如何在类之间传递事件？我知道这听起来很荒谬(确实如此)，但在过去的一段时间里我一直被这个问题难倒了。搜索没有出现类似的问题，所以我想我会提出这个问题。这里是涉及的对象: WinForm -> Sp
C# 事件传递/冒泡
我在 class 中订阅了一个 Event。比如 MainStation mainStation = StationFactory.GetMainStation(); mainStation.Fre
javascript - 鼠标悬停多次时 mouseenter 冒泡
当用户多次悬停(mouseenter)时如何防止冒泡或“失控”。当用户悬停时，我使用slideDown和slideUp作为mouseleave，并将延迟设置为250。只有当延迟设置为1毫秒时，我才能解
Javascript - onclick - 冒泡 - 原始元素
背景:我目前正在编写一个greasemonkey 脚本，用于嵌入/修改特定页面的html。该页面设置有 3 个嵌套 div。在这 3 个 div 中，我只能将事件监听器添加到最外面的 div(这是由于
javascript - 在服务器发送事件的情况下面对 Javascript 冒泡
想想 HTML5 服务器发送的事件(我在服务器端使用 php)。为了获取服务器发送的数据，我有以下代码: if(typeof(EventSource) !== "undefined") { v
Javascript 事件委托(delegate)/冒泡
我想禁用 SPA 路由器正文部分中所有具有“nolink”类的链接。为了实现这一点，我使用了事件委托(delegate)，它不能很好地处理嵌套元素。 (下面是简化的代码)。 HTML:
javascript - 浏览器键事件是否只触发(冒泡)到焦点元素？
实验证据使我相信键(向上、向下、按下)事件只会触发(在气泡阶段)处于焦点的元素。这种行为可能是直观的、明显的和/或可取的，但还没有在任何地方看到这种记录，所以我希望社区能够证实我的“理论”。否则，
c# - 冒泡 INotifyPropertyChanged 和嵌套属性
如果我有以下布局: public class A : INotifyPropertyChanged { public event PropertyChangedEventHandler Pro
javascript - 如何逐渐设置正在(冒泡)排序的元素的样式？
我有几个带有随机数的 div，我后来使用一些简单的冒泡排序代码按升序排列，我想逐渐排列并为它们添加样式，而不是对它们进行样式设置并立即安排。这感觉很简单，但我无法找到 sleep for 循环或正
java - 冒泡、选择、插入和快速排序中的交换和比较次数
我已经用 Java 实现了所有四种排序算法。只是为了它，我决定查看每种算法中的交换次数和比较次数。对于大小为 20 的随机数组，这是我的结果冒泡排序:87 次交换，87 次比较插入排序:87 次交
events - 冒泡 CSS 动画事件
所以根据MDN (这是有道理的)AnimationEvent 有 bubble 参数，但是如何将它设置为 true？考虑到该事件是从 CSS 动画触发的。最佳答案好吧，原来CSS是做冒泡事件的，例
c# - 保持鼠标事件从 WindowsFormsHost 冒泡
我在 WPF WindowsFormsHost 中有 Winforms 控件。Winforms 控件是被动的，不能处理任何鼠标事件。鼠标事件应该像往常一样从 WPF 可视化树中最内部的 WPF 控件引
javascript - 警报不从 iframe 冒泡
我有一个 iframe，它具有警报功能和 console.log 功能。我能够看到 console.log 的输出，但是警报功能没有冒泡(永远不会以可见的方式触发)。我尝试在 chromium 上
Javascript 鼠标悬停从 child 冒泡
我有以下 html 设置: blaat blaat2 它的样式使您不能悬停 div1 而不悬停其他 2 个 div 之一。现在我在 div1 上有一个 mouseout。问题是当我从 conte
Python 冒泡，选择，插入排序使用实例
最近学习了python基础，写一下3大排序练练手：复制代码代码如下: ''' Created on 2013-8-23 @author: codegeek
javascript - 事件捕获与使用 contentEditable div 冒泡
我正在处理一个内容可编辑的 div，我需要在将字符添加到 div 之前和之后捕获击键。我对捕获与冒泡的理解是，事件首先在 dom 树的最高层捕获，然后向下传递，而对于冒泡，它从最低层开始，然后在树上
javascript - jQuery 冒泡 - MouseOut 问题
Demo Here 我想要实现的目标: 鼠标悬停时 - 将显示共享图标。单击共享图标时，将显示新 Div 问题当鼠标移出共享图标时“新 Div 不应关闭，必须显示”。当大图像的 MouseOut
jquery - 冒泡 Jquery 的 Dom
我知道我的问题是在 DOM 内冒泡，因为我的分页中有多个页面，当我多次单击编辑类链接时，它会冒泡并连续加载相同的文件，我想知道更好的解决这个问题的方法。 $('.edit').live('click'
javascript - 使用 javascript 冒泡/捕获检测中间节点
我需要使用事件委托(delegate)捕获内部带有图像的 anchor 节点。 document.addEventListener( 'click', function(event) {

太空宇宙

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

lisp - 冒泡排序不返回排序数组