(XD::List:Append)转换表APPEND为CONS

Lispboy

1. ;|
   
2.    转换表APPEND为CONS
   
3.    参数：
   
4.      LST1---表
   
5.      LST2---表
   
6. 
   
7.    返回值：表
   
8. |;
   
9. (defun XD::List:Append (lst1 lst2)
   
10.   (mapcar
    
11.     '(lambda (x)
    
12.        (setq lst2 (cons x lst2))
    
13.      )
    
14.     (reverse lst1)
    
15.   )
    
16.   lst2
    
17. )
    
18. 
    

;|<br />    转换表APPEND为CONS<br />    参数：<br />      LST1---表<br />      LST2---表<br /> <br />    返回值：表<br /> |;<br /> (defun XD::List:Append (lst1 lst2)<br />   (mapcar<br />     '(lambda (x)<br />        (setq lst2 (cons x lst2))<br />      )<br />     (reverse lst1)<br />   )<br />   lst2<br /> )<br /> <br />

ll_j

Lispboy 发表于 2013-6-13 21:24
主要还是APPEND的机制造成的。CONS直接一个时钟周期就执行了，APPEND要遍历所有表节点，找到尾指针，然后 ...

鸟兄在7楼的第一个函数的结论是，自定义的append#比系统提供的append还要快，这就说明了系统的append并不是那么简单，一定有什么特别之处，只是我们没有体会。

牢固

这个函数有点多余了！请看自定义Append函数和Append函数的效率测试结果：
命令: tt
  自定义Append用时  10.235  秒
  Append用时  2.75  秒
命令:

1. (defun c:tt ()
   
2.    (setq i -1 l1 nil l2 nil)
   
3.   (repeat 10000
   
4.     (setq l1 (cons (setq i (1+ i)) l1))
   
5.     )
   
6.   (repeat 10000
   
7.     (setq l2 (cons (setq i (1+ i)) l2))
   
8.     )
   
9.   (setq *StartTime* (car (_VL-TIMES)))
   
10.   (repeat 1000
    
11.     (setq aa (XD::List:Append l1 l2))
    
12.     )
    
13.   (princ (strcat "\n  自定义Append用时  " (rtos (* 0.001 (- (car (_VL-TIMES)) *StartTime*)) 2 4) "  秒 "))
    
14.   (setq *StartTime* (car (_VL-TIMES)))
    
15.   (repeat 1000
    
16.     (setq bb (append l1 l2))
    
17.     )
    
18.   (princ (strcat "\n  Append用时  " (rtos (* 0.001 (- (car (_VL-TIMES)) *StartTime*)) 2 4) "  秒 "))
    
19.   (princ)
    
20.   )

(defun c:tt ()<br />    (setq i -1 l1 nil l2 nil)<br />   (repeat 10000<br />     (setq l1 (cons (setq i (1+ i)) l1))<br />     )<br />   (repeat 10000<br />     (setq l2 (cons (setq i (1+ i)) l2))<br />     )<br />   (setq *StartTime* (car (_VL-TIMES)))<br />   (repeat 1000<br />     (setq aa (XD::List:Append l1 l2))<br />     )<br />   (princ (strcat "\n  自定义Append用时  " (rtos (* 0.001 (- (car (_VL-TIMES)) *StartTime*)) 2 4) "  秒 "))<br />   (setq *StartTime* (car (_VL-TIMES)))<br />   (repeat 1000<br />     (setq bb (append l1 l2))<br />     )<br />   (princ (strcat "\n  Append用时  " (rtos (* 0.001 (- (car (_VL-TIMES)) *StartTime*)) 2 4) "  秒 "))<br />   (princ)<br />   )

牢固

请再看另一组测试结果，目的：将单个元素添加到表最后
命令: tt1

  Append用时  13.485  秒
  reverse+cons 用时  21.546  秒

结论是显而易见的，函数reverse会比较慢，需两次reverse时，还不如直接Append！

1. ;;另一组测试：将单个元素添加到表最后
   
2. (defun c:tt1 ()
   
3.    (setq i -1 l1 nil l2 nil)
   
4.   (repeat 10000
   
5.     (setq l1 (cons (setq i (1+ i)) l1))
   
6.     )
   
7.   (repeat 10000
   
8.     (setq l2 (cons (setq i (1+ i)) l2))
   
9.     )
   
10.   (setq *StartTime* (car (_VL-TIMES)))
    
11.   (repeat 10000
    
12.     (append l1 (list 1) )
    
13.     )
    
14.   (princ (strcat "\n  Append用时  " (rtos (* 0.001 (- (car (_VL-TIMES)) *StartTime*)) 2 4) "  秒 "))
    
15.   (setq *StartTime* (car (_VL-TIMES)))
    
16.   (repeat 10000
    
17.     (reverse (cons 1 (reverse l1)))
    
18.     )
    
19.   (princ (strcat "\n  reverse+cons 用时  " (rtos (* 0.001 (- (car (_VL-TIMES)) *StartTime*)) 2 4) "  秒 "))
    
20.   (princ)
    
21.   )

;;另一组测试：将单个元素添加到表最后<br /> (defun c:tt1 ()<br />    (setq i -1 l1 nil l2 nil)<br />   (repeat 10000<br />     (setq l1 (cons (setq i (1+ i)) l1))<br />     )<br />   (repeat 10000<br />     (setq l2 (cons (setq i (1+ i)) l2))<br />     )<br />   (setq *StartTime* (car (_VL-TIMES)))<br />   (repeat 10000<br />     (append l1 (list 1) )<br />     )<br />   (princ (strcat "\n  Append用时  " (rtos (* 0.001 (- (car (_VL-TIMES)) *StartTime*)) 2 4) "  秒 "))<br />   (setq *StartTime* (car (_VL-TIMES)))<br />   (repeat 10000<br />     (reverse (cons 1 (reverse l1)))<br />     )<br />   (princ (strcat "\n  reverse+cons 用时  " (rtos (* 0.001 (- (car (_VL-TIMES)) *StartTime*)) 2 4) "  秒 "))<br />   (princ)<br />   )

Lispboy

牢固 发表于 2013-6-13 11:31
请再看另一组测试结果，目的：将单个元素添加到表最后
命令: tt1

需要这样的测试啊，以前有讨论说APPEND会导致慢，G版分析下，那是什么情况下？

牢固

Lispboy 发表于 2013-6-13 11:37
需要这样的测试啊，以前有讨论说APPEND会导致慢，G版分析下，那是什么情况下？

楼上我已经给出答案了啊！
append效率肯定cons差太多！cons函数的速度几乎可以忽略不计！但是reverse函数就慢了！通过上面的测试，两次reverse比append慢了近1倍！一次reverse的速度，会比append快一点点！在实际应用中，我们一般都是将单个元素往空表里添加，最后在来一次reverse，得到最终结果！在循环中都是用cons，时间几乎可以忽略不计！所以时间就耗在这一次reverse上了！上述例子，将单个元素添加到表最后，用了两次reverse,自然就比直接Append慢了！cons+一次reverse,还是要比直接Append要快一点的，同样上述测试结果如下：
append和 cons+一次 reverse速度比较:
Append用时  13.594  秒
cons+一次 reverse 用时  10.64  秒
可以快3秒

pengfei2010

牢固 发表于 2013-6-13 11:54
楼上我已经给出答案了啊！
append效率肯定cons差太多！cons函数的速度几乎可以忽略不计！但是reverse函 ...

这样啊，呵呵 完全明白了，请教您一下  据说lisp有7个亲儿子 请问哪几个哦？大概知道 car  mapcar cdr

Highflybird

一个就是用LISP公理定义的APPEND[pcode=lisp,true]

(defun append# (x y)
  (cond
    ( (null x) y)
    ( t
      (cons (car x) (append# (cdr x) y))
    )
  )
)
[/pcode]
还有一种方式是： 就是foreach方法
[pcode=lisp,true]
(defun H:Append (lst1 lst2)
  (foreach n (reverse lst1)
    (setq lst2 (cons n lst2))
  )
  lst2
)

[/pcode]

经过验证，这两种方法，都比append快！特别是编译后。

Lispboy

Highflybird 发表于 2013-6-13 16:47
一个就是用LISP公理定义的APPEND

(defun append# (x y)

wow,你这个下面的不就是我写的那个嘛，我还用了MAPCAR，怎么G版测试比APPEND慢啊。

Lispboy

牢固 发表于 2013-6-13 11:54
楼上我已经给出答案了啊！
append效率肯定cons差太多！cons函数的速度几乎可以忽略不计！但是reverse函 ...

刚看了高飞鸟大师的回帖，才仔细看了下，我这个函数就用了一次REVERSE啊，G版。是怎么回事？ 你再测试下飞鸟兄那个FOREACH的，基本结构和我是一样的。用了一次REVERSE然后都是CONS

Highflybird

不过这样自定义的append函数，需要多次和不同场合的测试。
对于表长很短的，没有append快。

Lispboy

Highflybird 发表于 2013-6-13 17:24
不过这样自定义的append函数，需要多次和不同场合的测试。
对于表长很短的，没有append快。

确实是，提高效率的代码都是在级别到了一定程度才越发明显，建议G版用 三个方法，加上FOREACH的，来个10万级以上的测试，看看。

牢固

Lispboy 发表于 2013-6-13 17:17
刚看了高飞鸟大师的回帖，才仔细看了下，我这个函数就用了一次REVERSE啊，G版。是怎么回事？ 你再测试下 ...

我是开着vlide测试的，你把上面的测试函数编译成vlx来测试看下结果！速度肯定会提高很多！

Lispboy

牢固 发表于 2013-6-13 17:38
我是开着vlide测试的，你把上面的测试函数编译成vlx来测试看下结果！速度肯定会提高很多！

要编译也是都编译啊，相同条件下，看相对结果也能说明问题的。

Free-Lancer

还是根据自己程序处理数据的数量级采用相应的函数，简便为上来自: Android客户端

Lispboy

Free-Lancer 发表于 2013-6-13 18:41
还是根据自己程序处理数据的数量级采用相应的函数，简便为上

:P 其实，有一个函数用就行了。