home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 4 / AACD04.ISO / AACD / Programming / lsEstuff / old_lists / xli.e < prev    next >
Encoding:
Text File  |  1999-10-10  |  5.1 KB  |  249 lines
  1. OPT MODULE
  2.  
  3. MODULE '*xl'
  4.  
  5. EXPORT OBJECT xni OF xn
  6.    id:LONG
  7. ENDOBJECT
  8.  
  9. EXPORT OBJECT xli OF xl
  10. ENDOBJECT
  11. ->/*
  12. PROC find(id, startnode=NIL) OF xli
  13.    DEF xni:REG PTR TO xni
  14.    xni := IF startnode = NIL THEN self.first() ELSE startnode
  15.    WHILE xni
  16.       IF xni.id=id THEN RETURN xni
  17.       xni:=xni.next
  18.    ENDWHILE
  19. ENDPROC NIL
  20.  
  21. PROC findRev(id, startnode=NIL) OF xli
  22.    DEF xni:REG PTR TO xni
  23.    xni := IF startnode = NIL THEN self.last() ELSE startnode
  24.    WHILE xni
  25.       IF xni.id=id THEN RETURN xni
  26.       xni:=xni.prev
  27.    ENDWHILE
  28. ENDPROC NIL
  29.  
  30. PROC ordFind(id) OF xli
  31.    DEF first:PTR TO xni
  32.    DEF last:PTR TO xni
  33.    DEF beg
  34.    DEF end
  35.    first := self.first()
  36.    last := self.last()
  37.    beg := id - first.id
  38.    end := last.id - id
  39.    IF (end < 0) OR (beg < 0)THEN RETURN NIL
  40.    IF end <= beg THEN RETURN self.findRev(id)
  41. ENDPROC self.find(id)
  42.  
  43.  
  44. ->*/
  45. /*
  46. PROC find(_id) OF xli
  47.    DEF xni:REG
  48.    DEF id:REG
  49.    id := _id
  50.    xni := self.first()
  51.    MOVE.L #0, D2
  52. loop:            ->WHILE xni
  53.    CMP.L  D2, xni ->.........
  54.    BEQ.L  null    ->.........
  55.  
  56.    MOVE.L xni, A0 -> lägg xni i A0
  57.    MOVE.L 8(A0), D1
  58.  
  59.    CMP.L  id, D1
  60.    BEQ.L  end
  61.  
  62.    MOVE.L (A0), xni -> xni := xni.next
  63.    BRA.L  loop
  64.  
  65. null:
  66.    RETURN NIL
  67. end:
  68. ENDPROC xni
  69. */
  70.  
  71.  
  72.  
  73. PROC getMaxID() OF xli
  74.    DEF n:REG PTR TO xni, id:REG
  75.    id := -2000000000
  76.    n := self.first()
  77.    WHILE n
  78.       id := IF n.id > id THEN n.id ELSE id
  79.       n := n.next
  80.    ENDWHILE
  81. ENDPROC id
  82.  
  83. PROC getMinID() OF xli
  84.    DEF n:REG PTR TO xni, id:REG
  85.    id := 2000000000
  86.    n := self.first()
  87.    WHILE n
  88.       id := IF n.id < id THEN n.id ELSE id
  89.       n := n.next
  90.    ENDWHILE
  91. ENDPROC id
  92.  
  93. PROC getSumID() OF xli
  94.    DEF n:REG PTR TO xni, id:REG
  95.    id:=NIL
  96.    n := self.first()
  97.    WHILE n
  98.       id := id + n.id
  99.       n := n.next
  100.    ENDWHILE
  101. ENDPROC id
  102.  
  103.  
  104. PROC sort() OF xli
  105.    ->DEF xli2:PTR TO xli
  106.    ->NEW xli2
  107.    ->presplit(self, xli2 , 50)
  108.    bubble(self)
  109.    ->bubble(xli2)
  110.    ->self.listAddLast(xli2)
  111.    ->END xli2
  112. ENDPROC
  113.  
  114. PROC bubble(xli:PTR TO xli)
  115.    DEF n:PTR TO xni
  116.    DEF nnext:PTR TO xni
  117.    DEF useful
  118.    REPEAT
  119.       n := xli.first()
  120.       useful := FALSE
  121.       WHILE n
  122.          nnext := n.next
  123.          IF nnext
  124.             IF n.id > nnext.id
  125.                xli.remove(n)
  126.                xli.insert(n, nnext)
  127.                useful := TRUE
  128.             ENDIF
  129.             n := n.next
  130.          ELSE
  131.             n := NIL
  132.          ENDIF
  133.       ENDWHILE
  134.    UNTIL useful = FALSE
  135. ENDPROC
  136.  
  137. /* something goes wrong here..! */
  138. /* well it experimental anyway..
  139. PROC presplit(xli:PTR TO xli, xli2:PTR TO xli, splitval)
  140.    DEF n:PTR TO xni
  141.    n := xli.first()
  142.    WHILE n
  143.       IF n.id > splitval
  144.          xli.remove(n)
  145.          xli2.addFirst(n)
  146.       ENDIF
  147.       n := n.next
  148.    ENDWHILE
  149. ENDPROC
  150. */
  151.  
  152.  
  153. /* these doesnt wprk! */
  154. /*
  155. PROC quickSort() OF xli
  156.    quicksort(self, self.first(), self.last())
  157. ENDPROC
  158.  
  159. PROC quicksort(list:PTR TO xli, first:PTR TO xni, last:PTR TO xni)
  160.   DEF curr:PTR TO xni, left=NIL, fNum
  161.  
  162.   IF FreeStack() < 100 THEN Raise(TRUE)
  163.   fNum:=first.id
  164.   IF (curr:=first.next)=last
  165.     IF fNum>(last.id)
  166.       list.remove(first); list.insert(first,last)
  167.     ENDIF
  168.   ELSE
  169.     REPEAT
  170.       IF (curr.id)<fNum
  171.         IF curr=last THEN last:=last.prev
  172.         IF left=NIL THEN left:=curr
  173.         list.remove(curr); list.insert(curr,first.prev)
  174.       ENDIF
  175.     UNTIL (curr:=curr.next)=(last.next)
  176.     IF left AND (left<>(first.prev)) THEN quicksort(list, left, first.prev)
  177.     IF (first<>last) AND ((first.next)<>last) THEN quicksort(list, first.next, last)
  178.   ENDIF
  179. ENDPROC
  180. */
  181.  
  182. EXPORT OBJECT xli_CPObj OF xl_CPObj
  183. ENDOBJECT
  184.  
  185. PROC ordInsert(xni:PTR TO xni) OF xli
  186.    DEF n:PTR TO xni
  187.    n := self.first()
  188.    IF n = NIL THEN RETURN self.addFirst(xni)
  189.    IF n.id > xni.id THEN RETURN self.addFirst(xni)
  190.    WHILE n.id < xni.id
  191.       n := n.next
  192.       IF n = NIL THEN RETURN self.addLast(xni)
  193.    ENDWHILE
  194.    self.insert(xni, n.prev)
  195. ENDPROC xni
  196.  
  197. PROC cmpMap(xli:PTR TO xli) OF xli
  198.    DEF thisnode:PTR TO xni
  199.    DEF thatnode:PTR TO xni
  200.    thisnode := self.first()
  201.    thatnode := xli.first()
  202.    WHILE (thisnode OR thatnode)
  203.       IF thisnode.id <> thatnode.id THEN RETURN FALSE
  204.       thisnode := thisnode.next
  205.       thatnode := thatnode.next
  206.    ENDWHILE
  207. ENDPROC TRUE
  208.  
  209. PROC scroll(_amount) OF xli
  210.    DEF n:REG PTR TO xni
  211.    DEF amount:REG
  212.    amount := _amount
  213.    n := self.first()
  214.    WHILE n
  215.       n.id := n.id + amount
  216.       n := n.next
  217.    ENDWHILE
  218. ENDPROC
  219.  
  220. /* merge two sorted lists into one */
  221. PROC ordListMerge(listToInsert:PTR TO xli) OF xli
  222.    DEF thisnode:PTR TO xni
  223.    DEF thatnode:PTR TO xni
  224.    thisnode := self.first()
  225.    thatnode := listToInsert.first()
  226.    WHILE thatnode
  227.       IF thisnode
  228.          IF thisnode.id > thatnode.id
  229.             IF thisnode.prev
  230.                self.insert(thatnode, thisnode.prev)
  231.             ELSE
  232.                self.addFirst(thatnode)
  233.             ENDIF
  234.             thatnode := thatnode.next
  235.          ELSEIF thisnode.id = thatnode.id
  236.             self.insert(thatnode, thisnode)
  237.             thisnode := thisnode.next
  238.             thatnode := thatnode.next
  239.          ELSE -> thisnode.id < thatnode.id
  240.             thisnode := thisnode.next
  241.          ENDIF
  242.       ELSE
  243.          self.addLast(thatnode)
  244.          thatnode := thatnode.next
  245.       ENDIF
  246.    ENDWHILE
  247. ENDPROC
  248.  
  249.