ikan Uploader :
Directory : /usr/share/emacs/25.2/lisp/emacs-lisp/
Upload File : |
| Current File : //usr/share/emacs/25.2/lisp/emacs-lisp/avl-tree.elc |
;ELC
;;; Compiled
;;; in Emacs version 25.2.1
;;; with all optimizations.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defalias 'avl-tree-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree-p (declare (side-effect-free error-free)) (and (vectorp cl-x) (>= (length cl-x) 3) (memq (aref cl-x 0) cl-struct-avl-tree--tags) t)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'avl-tree-p 'compiler-macro 'avl-tree-p--cmacro)
(defalias 'avl-tree-p #[257 "\301!\205 \211G\302Y\205 \211\303H>\205 \304\207" [cl-struct-avl-tree--tags vectorp 3 0 t] 3 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\305\306\301#\207" [function-put avl-tree-p side-effect-free error-free put avl-tree- cl-deftype-satisfies] 4)
(defalias 'avl-tree--dummyroot--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--dummyroot (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-avl-tree--tags)) (signal 'wrong-type-argument (list 'avl-tree- cl-x))) (aref cl-x 1)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'avl-tree--dummyroot 'compiler-macro 'avl-tree--dummyroot--cmacro)
(defalias 'avl-tree--dummyroot #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-avl-tree--tags 0 signal wrong-type-argument avl-tree- 1] 5 "\n\n(fn CL-X)"])
(function-put 'avl-tree--dummyroot 'side-effect-free t)
(defalias 'avl-tree--cmpfun--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--cmpfun (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-avl-tree--tags)) (signal 'wrong-type-argument (list 'avl-tree- cl-x))) (aref cl-x 2)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'avl-tree--cmpfun 'compiler-macro 'avl-tree--cmpfun--cmacro)
(defalias 'avl-tree--cmpfun #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-avl-tree--tags 0 signal wrong-type-argument avl-tree- 2] 5 "\n\n(fn CL-X)"])
(function-put 'avl-tree--cmpfun 'side-effect-free t)
(defalias 'avl-tree--create--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cmpfun) (cl-block avl-tree--create "Constructor for objects of type `avl-tree-'." (vector 'cl-struct-avl-tree- (avl-tree--node-create nil nil nil 0) cmpfun)) nil] 9 "\n\n(fn CL-WHOLE-ARG CMPFUN)"])
(put 'avl-tree--create 'compiler-macro 'avl-tree--create--cmacro)
#@59 Constructor for objects of type `avl-tree-'.
(fn CMPFUN)
(defalias 'avl-tree--create #[257 "\300\301\302\303\211\211\304$#\207" [vector cl-struct-avl-tree- avl-tree--node-create nil 0] 8 (#$ . 2667)])
(byte-code "\300\301\302\303\302\211\304\305\306\307& \207" [cl-struct-define avl-tree- nil cl-structure-object ((cl-tag-slot) (dummyroot (avl-tree--node-create nil nil nil 0)) (cmpfun)) cl-struct-avl-tree--tags cl-struct-avl-tree- t] 10)
(defalias 'avl-tree--root '(macro . #[257 "\300\301DD\207" [avl-tree--node-left avl-tree--dummyroot] 4 "\n\n(fn TREE)"]))
(defalias 'avl-tree--node-left--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--node-left (declare (side-effect-free t)) (aref cl-x 0)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'avl-tree--node-left 'compiler-macro 'avl-tree--node-left--cmacro)
(defalias 'avl-tree--node-left #[257 "\211\300H\207" [0] 3 "\n\n(fn CL-X)"])
(function-put 'avl-tree--node-left 'side-effect-free t)
(defalias 'avl-tree--node-right--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--node-right (declare (side-effect-free t)) (aref cl-x 1)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'avl-tree--node-right 'compiler-macro 'avl-tree--node-right--cmacro)
(defalias 'avl-tree--node-right #[257 "\211\300H\207" [1] 3 "\n\n(fn CL-X)"])
(function-put 'avl-tree--node-right 'side-effect-free t)
(defalias 'avl-tree--node-data--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--node-data (declare (side-effect-free t)) (aref cl-x 2)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'avl-tree--node-data 'compiler-macro 'avl-tree--node-data--cmacro)
(defalias 'avl-tree--node-data #[257 "\211\300H\207" [2] 3 "\n\n(fn CL-X)"])
(function-put 'avl-tree--node-data 'side-effect-free t)
(defalias 'avl-tree--node-balance--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--node-balance (declare (side-effect-free t)) (aref cl-x 3)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'avl-tree--node-balance 'compiler-macro 'avl-tree--node-balance--cmacro)
(defalias 'avl-tree--node-balance #[257 "\211\300H\207" [3] 3 "\n\n(fn CL-X)"])
(function-put 'avl-tree--node-balance 'side-effect-free t)
(defalias 'avl-tree--node-create--cmacro #[1285 "\300\301\302\303\211\211 & \207" [cl--defsubst-expand (left right data balance) (cl-block avl-tree--node-create "Constructor for objects of type `avl-tree--node'." (declare (side-effect-free t)) (vector left right data balance)) nil] 15 "\n\n(fn CL-WHOLE-ARG LEFT RIGHT DATA BALANCE)"])
(put 'avl-tree--node-create 'compiler-macro 'avl-tree--node-create--cmacro)
#@81 Constructor for objects of type `avl-tree--node'.
(fn LEFT RIGHT DATA BALANCE)
(defalias 'avl-tree--node-create #[1028 "\300$\207" [vector] 9 (#$ . 5389)])
(byte-code "\300\301\302\303#\210\304\305\306\211\307\306\310\311\312\306& \210\313\314\315\316#\210\317\314\320\321#\207" [function-put avl-tree--node-create side-effect-free t cl-struct-define avl-tree--node nil vector ((left) (right) (data) (balance)) cl-struct-avl-tree--node-tags cl-struct-avl-tree--node defalias avl-tree--node-branch aref "Get value of a branch of a node.\nNODE is the node, and BRANCH is the branch.\n0 for left pointer, 1 for right pointer and 2 for the data." put gv-expander #[385 "\300\301\302$\207" [gv--defsetter avl-tree--node-branch #[385 "\300\301C\"B\207" [aset append] 6 "\n\n(fn VAL &rest ARGS)"]] 7 "\n\n(fn DO &rest ARGS)"]] 10)
#@67 Return opposite direction to DIR (0 = left, 1 = right).
(fn DIR)
(defalias 'avl-tree--switch-dir '(macro . #[257 "\300\301E\207" [- 1] 4 (#$ . 6228)]))
#@59 Convert direction (0,1) to sign factor (-1,+1).
(fn DIR)
(defalias 'avl-tree--dir-to-sign '(macro . #[257 "\300\301\302ED\207" [1- * 2] 5 (#$ . 6388)]))
#@59 Convert sign factor (-x,+x) to direction (0,1).
(fn DIR)
(defalias 'avl-tree--sign-to-dir '(macro . #[257 "\300\301\302BB\303BB\207" [if < (0) (0 1)] 5 (#$ . 6549)]))
#@238 Rebalance a tree after deleting a node.
The deletion was done from the left (DIR=0) or right (DIR=1) sub-tree of the
left (BRANCH=0) or right (BRANCH=1) child of NODE.
Return t if the height of the tree has shrunk.
(fn NODE BRANCH DIR)
(defalias 'avl-tree--del-balance #[771 "\300\"\301Z\302_S\303\211\211\211\304H_\305V\203& \211\304\305I\266\306\202 \304H\305U\203= \211\304[I\266\303\202 \300\"\262\304H\262_\305X\203\245 \300
\"I\266\nI\266 I\266\305U\203\222 \211\304[I\266\211\304I\266\303\202 \211\304\305I\266\211\304\305I\266\306\202 \300 \"\262\304H\262\300 \"I\266I\266\300
\"I\266\nI\266\211\304_\305W\203\364 \202\365 \305I\266\211\304_\305V\203\n[\202 \305I\266 I\266\211\304\305I\266\306\207" [avl-tree--node-branch 1 2 nil 3 0 t] 17 (#$ . 6725)])
(defalias 'avl-tree--do-del-internal #[771 "\300\"\211\301H\203 \302\301#\205. \303\301#\202. \211\304\304HI\266\305HI\266\306\207" [avl-tree--node-branch 1 avl-tree--do-del-internal avl-tree--del-balance 2 0 t] 10 "\n\n(fn NODE BRANCH Q)"])
#@267 Delete DATA from BRANCH of node ROOT.
(See `avl-tree-delete' for TEST and NILFLAG).
Return cons cell (SHRUNK . DATA), where SHRUNK is t if the
height of the tree has shrunk and nil otherwise, and DATA is
the related data.
(fn CMPFUN ROOT BRANCH DATA TEST NILFLAG)
(defalias 'avl-tree--do-delete #[1542 "\300\"\211\204 \301B\202\301 \302H\"\2039 \303\304&\211@\2051 \305\304#AB\262\202\301 \302H\"\203d \303\306&\211@\205\\ \305\306#AB\262\202\301 \203v \302H!\204v \301B\202\301 \211\306H\204\216 \304HI\266\307\302HB\202\301 \211\304H\204\246 \306HI\266\307\302HB\202\301 \310\304#\203\274 \305\304#\302HB\202\301 \301\302HB\207" [avl-tree--node-branch nil 2 avl-tree--do-delete 0 avl-tree--del-balance 1 t avl-tree--do-del-internal] 14 (#$ . 7889)])
#@209 Rebalance tree after an insertion
into the left (DIR=0) or right (DIR=1) sub-tree of the
left (BRANCH=0) or right (BRANCH=1) child of NODE.
Return t if the height of the tree has grown.
(fn NODE BRANCH DIR)
(defalias 'avl-tree--enter-balance #[771 "\300\"\301Z\302_S\303\211\211\304H_\305W\203$ \211\304\305I\266\303\202\363 \304H\305U\2038 \211\304I\266\306\202\363 \300\"\262\304H_\305V\203v \300\n\"I\266 I\266\211\304\305I\266I\266\202\345 \300\"\262\304H\262\300\f\"I\266I\266\300\n\"I\266 I\266\211\304_\305V\203\302 [\202\303 \305I\266\211\304_\305W\203\327 \202\330 \305I\266I\266\300 \"\211\211\304\305I\266\303\207" [avl-tree--node-branch 1 2 nil 3 0 t] 16 (#$ . 8720)])
#@256 Enter DATA in BRANCH of ROOT node.
(See `avl-tree-enter' for UPDATEFUN).
Return cons cell (GREW . DATA), where GREW is t if height
of tree ROOT has grown and nil otherwise, and DATA is the
inserted data.
(fn CMPFUN ROOT BRANCH DATA &optional UPDATEFUN)
(defalias 'avl-tree--do-enter #[1284 "\300\"\211\204 \301\302\211 \303$I\266\304B\202\230 \305H\"\203C \306\303%\211@\205; \307\303#AB\262\202\230 \305H\"\203j \306\310%\211@\205b \307\310#AB\262\202\230 \203w \305H\"\202x \"\204\210 \"\203\214 \311\312!\210\211\305I\266\302B\262\207" [avl-tree--node-branch vector nil 0 t 2 avl-tree--do-enter avl-tree--enter-balance 1 error "avl-tree-enter: updated data does not match existing data"] 15 (#$ . 9519)])
#@38 Check the tree's balance.
(fn TREE)
(defalias 'avl-tree--check #[257 "\301\302H>\204 \303\304\305D\"\210\306H\211\302H\262!\207" [cl-struct-avl-tree--tags avl-tree--check-node 0 signal wrong-type-argument avl-tree- 1] 6 (#$ . 10295)])
(defalias 'avl-tree--check-node #[257 "\211\204 \300\207\301\300H!\301\302H!\211Z\303HU\204 \304\305!\210]T\207" [0 avl-tree--check-node 1 3 cl--assertion-failed (= (- dr dl) (avl-tree--node-balance node))] 6 "\n\n(fn NODE)"])
#@246 Apply MAP-FUNCTION to all nodes in the tree starting with ROOT.
The function is applied in-order, either ascending (DIR=0) or
descending (DIR=1).
Note: MAP-FUNCTION is applied to the node and not to the data
itself.
(fn MAP-FUNCTION ROOT DIR)
(defalias 'avl-tree--mapc #[771 "\300\301\300B\262\205K \211\203% \302\"\203% B\262\302\"\262\202 !\210\302\303Z\"\211\262\203@ \302\303Z\"\202F \211A\262\242\262\202 \207" [nil t avl-tree--node-branch 1] 10 (#$ . 10779)])
#@68 Copy the AVL tree with ROOT as root. Highly recursive.
(fn ROOT)
(defalias 'avl-tree--do-copy #[257 "\211\205 \300\301H!\300\302H!\303H\304H\305$\266\204\207" [avl-tree--do-copy 0 1 2 3 vector] 10 (#$ . 11279)])
(defalias 'avl-tree--stack-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--stack-p (declare (side-effect-free error-free)) (and (vectorp cl-x) (>= (length cl-x) 3) (memq (aref cl-x 0) cl-struct-avl-tree--stack-tags) t)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'avl-tree--stack-p 'compiler-macro 'avl-tree--stack-p--cmacro)
(defalias 'avl-tree--stack-p #[257 "\301!\205 \211G\302Y\205 \211\303H>\205 \304\207" [cl-struct-avl-tree--stack-tags vectorp 3 0 t] 3 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\305\306\301#\207" [function-put avl-tree--stack-p side-effect-free error-free put avl-tree--stack cl-deftype-satisfies] 4)
(defalias 'avl-tree--stack-reverse--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--stack-reverse (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-avl-tree--stack-tags)) (signal 'wrong-type-argument (list 'avl-tree--stack cl-x))) (aref cl-x 1)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'avl-tree--stack-reverse 'compiler-macro 'avl-tree--stack-reverse--cmacro)
(defalias 'avl-tree--stack-reverse #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-avl-tree--stack-tags 0 signal wrong-type-argument avl-tree--stack 1] 5 "\n\n(fn CL-X)"])
(function-put 'avl-tree--stack-reverse 'side-effect-free t)
(defalias 'avl-tree--stack-store--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--stack-store (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-avl-tree--stack-tags)) (signal 'wrong-type-argument (list 'avl-tree--stack cl-x))) (aref cl-x 2)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'avl-tree--stack-store 'compiler-macro 'avl-tree--stack-store--cmacro)
(defalias 'avl-tree--stack-store #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-avl-tree--stack-tags 0 signal wrong-type-argument avl-tree--stack 2] 5 "\n\n(fn CL-X)"])
(function-put 'avl-tree--stack-store 'side-effect-free t)
#@81 Constructor for objects of type `avl-tree--stack'.
(fn TREE &optional REVERSE)
(defalias 'avl-tree--stack-create #[641 "\301!?\205 \302H>\204 \303\304\305D\"\210\306H\211\302H\262C\203- \303\307\310\311G\\D\"\210\312\313#\207" [cl-struct-avl-tree--tags avl-tree-empty 0 signal wrong-type-argument avl-tree- 1 wrong-number-of-arguments avl-tree--stack-create 2 vector cl-struct-avl-tree--stack] 9 (#$ . 13564)])
(byte-code "\300\301\302\303#\210\304\305\306\307\306\211\310\311\312\303& \210\313\314\315\316#\207" [function-put avl-tree--stack-create side-effect-free t cl-struct-define avl-tree--stack nil cl-structure-object ((cl-tag-slot) (reverse) (store)) cl-struct-avl-tree--stack-tags cl-struct-avl-tree--stack defalias avl-tree-stack-p avl-tree--stack-p "Return t if argument is an avl-tree-stack, nil otherwise."] 10)
(defalias 'avl-tree--stack-repopulate #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H@\301H>\204\" \302\303\304D\"\210\306H\203, \306\202- \301\205X \307\"\211\262\205X \301H>\204J \302\303\304D\"\210\211\305\305HBI\266\2021 \207" [cl-struct-avl-tree--stack-tags 0 signal wrong-type-argument avl-tree--stack 2 1 avl-tree--node-branch] 9 "\n\n(fn STACK)"])
(byte-code "\300\301\302\303#\210\300\304\305\306#\207" [defalias avl-tree-create avl-tree--create "Create an empty AVL tree.\nCOMPARE-FUNCTION is a function which takes two arguments, A and B,\nand returns non-nil if A is less than B, and nil otherwise." avl-tree-compare-function avl-tree--cmpfun "Return the comparison function for the AVL tree TREE.\n\n(fn TREE)"] 4)
#@70 Return t if AVL tree TREE is empty, otherwise return nil.
(fn TREE)
(defalias 'avl-tree-empty #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\211\301H\262?\207" [cl-struct-avl-tree--tags 0 signal wrong-type-argument avl-tree- 1] 5 (#$ . 15158)])
#@558 Insert DATA into the AVL tree TREE.
If an element that matches DATA (according to the tree's
comparison function, see `avl-tree-create') already exists in
TREE, it will be replaced by DATA by default.
If UPDATEFUN is supplied and an element matching DATA already
exists in TREE, UPDATEFUN is called with two arguments: DATA, and
the matching element. Its return value replaces the existing
element. This value *must* itself match DATA (and hence the
pre-existing data), or an error will occur.
Returns the new data.
(fn TREE DATA &optional UPDATEFUN)
(defalias 'avl-tree-enter #[770 "\301\302H>\204 \303\304\305D\"\210\306H\302H>\204$ \303\304\305D\"\210\307H\302%A\207" [cl-struct-avl-tree--tags avl-tree--do-enter 0 signal wrong-type-argument avl-tree- 2 1] 9 (#$ . 15419)])
#@672 Delete the element matching DATA from the AVL tree TREE.
Matching uses the comparison function previously specified in
`avl-tree-create' when TREE was created.
Returns the deleted element, or nil if no matching element was
found.
Optional argument NILFLAG specifies a value to return instead of
nil if nothing was deleted, so that this case can be
distinguished from the case of a successfully deleted null
element.
If supplied, TEST specifies a test that a matching element must
pass before it is deleted. If a matching element is found, it is
passed as an argument to TEST, and is deleted only if the return
value is non-nil.
(fn TREE DATA &optional TEST NILFLAG)
(defalias 'avl-tree-delete #[1026 "\301\302H>\204 \303\304\305D\"\210\306H\302H>\204$ \303\304\305D\"\210\307H\302&A\207" [cl-struct-avl-tree--tags avl-tree--do-delete 0 signal wrong-type-argument avl-tree- 2 1] 11 (#$ . 16222)])
#@475 Return the element in the AVL tree TREE which matches DATA.
Matching uses the comparison function previously specified in
`avl-tree-create' when TREE was created.
If there is no such element in the tree, nil is
returned. Optional argument NILFLAG specifies a value to return
instead of nil in this case. This allows non-existent elements to
be distinguished from a null element. (See also
`avl-tree-member-p', which does this for you.)
(fn TREE DATA &optional NILFLAG)
(defalias 'avl-tree-member #[770 "\301H>\204 \302\303\304D\"\210\305H\211\301H\262\301H>\204' \302\303\304D\"\210\306H\3072` \203^ \211\306H\"\203C \301H\262\202. \211\306H\"\203T \305H\262\202. \310\307\306H\"\210\202. 0\207" [cl-struct-avl-tree--tags 0 signal wrong-type-argument avl-tree- 1 2 found throw] 9 (#$ . 17148)])
#@209 Return t if an element matching DATA exists in the AVL tree TREE.
Otherwise return nil. Matching uses the comparison function
previously specified in `avl-tree-create' when TREE was created.
(fn TREE DATA)
(defalias 'avl-tree-member-p #[514 "\300\301#=?\207" [(nil) avl-tree-member] 7 (#$ . 17977)])
#@280 Modify all elements in the AVL tree TREE by applying FUNCTION.
Each element is replaced by the return value of FUNCTION applied
to that element.
FUNCTION is applied to the elements in ascending order, or
descending order if REVERSE is non-nil.
(fn FUN TREE &optional REVERSE)
(defalias 'avl-tree-map #[770 "\301\302\303\304\305\306!\307\"\310\311%\312H>\204 \313\314\315D\"\210\316H\211\312H\262\203. \316\202/ \312#\207" [cl-struct-avl-tree--tags avl-tree--mapc make-byte-code 257 "\211\211\301\300\301H!I\207" vconcat vector [2] 7 "\n\n(fn NODE)" 0 signal wrong-type-argument avl-tree- 1] 10 (#$ . 18290)])
#@205 Apply FUNCTION to all elements in AVL tree TREE,
for side-effect only.
FUNCTION is applied to the elements in ascending order, or
descending order if REVERSE is non-nil.
(fn FUN TREE &optional REVERSE)
(defalias 'avl-tree-mapc #[770 "\301\302\303\304\305\306!\307\"\310\311%\312H>\204 \313\314\315D\"\210\316H\211\312H\262\203. \316\202/ \312#\207" [cl-struct-avl-tree--tags avl-tree--mapc make-byte-code 257 "\300\301H!\207" vconcat vector [2] 4 "\n\n(fn NODE)" 0 signal wrong-type-argument avl-tree- 1] 10 (#$ . 18920)])
#@253 Apply FUNCTION to all elements in AVL tree TREE,
and combine the results using COMBINATOR.
The FUNCTION is applied and the results are combined in ascending
order, or descending order if REVERSE is non-nil.
(fn FUN COMBINATOR TREE &optional REVERSE)
(defalias 'avl-tree-mapf #[1027 "\301C\302\303\304\305\306\307\n\n#\310\"\311\312%\313H>\204$ \314\315\316D\"\210\317H\211\313H\262\2034 \313\2025 \317#\210\211\242\237\207" [cl-struct-avl-tree--tags nil avl-tree--mapc make-byte-code 257 "\302\301\300\303H!\302\242\"\240\207" vconcat vector [2] 6 "\n\n(fn NODE)" 0 signal wrong-type-argument avl-tree- 1] 14 (#$ . 19463)])
#@437 Apply FUNCTION to all elements in AVL tree TREE,
and make a list of the results.
The FUNCTION is applied and the list constructed in ascending
order, or descending order if REVERSE is non-nil.
Note that if you don't care about the order in which FUNCTION is
applied, just that the resulting list is in the correct order,
then
(avl-tree-mapf function \='cons tree (not reverse))
is more efficient.
(fn FUN TREE &optional REVERSE)
(defalias 'avl-tree-mapcar #[770 "\300\301$\237\207" [avl-tree-mapf cons] 8 (#$ . 20108)])
#@71 Return the first element in TREE, or nil if TREE is empty.
(fn TREE)
(defalias 'avl-tree-first #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\211\301H\262\211\205, \211\301H\203) \211\301H\262\202 \211\306H\207" [cl-struct-avl-tree--tags 0 signal wrong-type-argument avl-tree- 1 2] 5 (#$ . 20644)])
#@70 Return the last element in TREE, or nil if TREE is empty.
(fn TREE)
(defalias 'avl-tree-last #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\211\301H\262\211\205, \211\305H\203) \211\305H\262\202 \211\306H\207" [cl-struct-avl-tree--tags 0 signal wrong-type-argument avl-tree- 1 2] 5 (#$ . 20960)])
#@48 Return a copy of the AVL tree TREE.
(fn TREE)
(defalias 'avl-tree-copy #[257 "\301\302H>\204 \303\304\305D\"\210\306H!\211\302H>\204# \303\304\305D\"\210\211\307H\211\211\302\310\302H>\204; \303\304\305 D\"\210\307H\211\302H\262!I\266\211\207" [cl-struct-avl-tree--tags avl-tree-create 0 signal wrong-type-argument avl-tree- 2 1 avl-tree--do-copy] 11 (#$ . 21274)])
#@66 Return a sorted list containing all elements of TREE.
(fn TREE)
(defalias 'avl-tree-flatten #[257 "\301C\302\303\304\305\306\307!\310\"\311\312%\313H>\204 \314\315\316D\"\210\317H\211\313H\262\317#\210\211\242\207" [cl-struct-avl-tree--tags nil avl-tree--mapc make-byte-code 257 "\300\301H\300\242B\240\207" vconcat vector [2] 4 "\n\n(fn NODE)" 0 signal wrong-type-argument avl-tree- 1] 9 (#$ . 21662)])
#@51 Return the number of elements in TREE.
(fn TREE)
(defalias 'avl-tree-size #[257 "\301C\302\303\304\305\306\307!\310\"\311\312%\301H>\204 \313\314\315D\"\210\316H\211\301H\262\301#\210\211\242\207" [cl-struct-avl-tree--tags 0 avl-tree--mapc make-byte-code 257 "\300\211\242T\240\207" vconcat vector [] 3 "\n\n(fn _)" signal wrong-type-argument avl-tree- 1] 9 (#$ . 22083)])
#@37 Clear the AVL tree TREE.
(fn TREE)
(defalias 'avl-tree-clear #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H\211\211\301\306I\262\207" [cl-struct-avl-tree--tags 0 signal wrong-type-argument avl-tree- 1 nil] 6 (#$ . 22472)])
#@786 Return an object that behaves like a sorted stack
of all elements of TREE.
If REVERSE is non-nil, the stack is sorted in reverse order.
(See also `avl-tree-stack-pop').
Note that any modification to TREE *immediately* invalidates all
avl-tree-stacks created before the modification (in particular,
calling `avl-tree-stack-pop' will give unpredictable results).
Operations on these objects are significantly more efficient than
constructing a real stack with `avl-tree-flatten' and using
standard stack functions. As such, they can be useful in
implementing efficient algorithms of AVL trees. However, in cases
where mapping functions `avl-tree-mapc', `avl-tree-mapcar' or
`avl-tree-mapf' would be sufficient, it is better to use one of
those instead.
(fn TREE &optional REVERSE)
(defalias 'avl-tree-stack #[513 "\300\"\301!\210\211\207" [avl-tree--stack-create avl-tree--stack-repopulate] 5 (#$ . 22711)])
#@272 Pop the first element from AVL-TREE-STACK.
(See also `avl-tree-stack').
Returns nil if the stack is empty, or NILFLAG if specified.
(The latter allows an empty stack to be distinguished from
a null element stored in the AVL tree.)
(fn AVL-TREE-STACK &optional NILFLAG)
(defalias 'avl-tree-stack-pop #[513 "\301\211\302H>\204 \303\304\305D\"\210\211\306H\211\306AI\210\266\202\242\211\262\204* \202p \307\302H>\204< \303\304\305D\"\210\310H\203F \302\202G \310\"\211\262\203m \302H>\204^ \303\304\305D\"\210\211\306\306HBI\266\311!\210\306H\207" [cl-struct-avl-tree--stack-tags nil 0 signal wrong-type-argument avl-tree--stack 2 avl-tree--node-branch 1 avl-tree--stack-repopulate] 10 (#$ . 23633)])
#@280 Return the first element of AVL-TREE-STACK, without removing it
from the stack.
Returns nil if the stack is empty, or NILFLAG if specified.
(The latter allows an empty stack to be distinguished from
a null element stored in the AVL tree.)
(fn AVL-TREE-STACK &optional NILFLAG)
(defalias 'avl-tree-stack-first #[513 "\301H>\204 \302\303\304D\"\210\305H@\206 \211\207" [cl-struct-avl-tree--stack-tags 0 signal wrong-type-argument avl-tree--stack 2] 6 (#$ . 24367)])
#@74 Return t if AVL-TREE-STACK is empty, nil otherwise.
(fn AVL-TREE-STACK)
(defalias 'avl-tree-stack-empty-p #[257 "\211\301H>\204 \302\303\304D\"\210\211\305H?\207" [cl-struct-avl-tree--stack-tags 0 signal wrong-type-argument avl-tree--stack 2] 5 (#$ . 24845)])
(provide 'avl-tree)
Kontol Shell Bypass