javascript实现数据结构：线索二叉树

  1 var LINK = 0;
  2 var THREAD = 1;
  3 
  4 function BinaryThreadTree_inOrder(data, leftChild, rightChild) {
  5     this.data = data;
  6     this.leftChild = leftChild || null;
  7     this.rightChild = rightChild || null;
  8     // 左右标记
  9     this.leftTag = this.rightTag = undefined;
 10 }
 11 BinaryThreadTree_inOrder.prototype = {
 12     constructor: BinaryThreadTree_inOrder,
 13     // 中序线索二叉树的遍历
 14     inOrderTraverse_thread: function (visit) {
 15         var p = this.leftChild;
 16 
 17         while (p != this) {
 18             while (p.leftTag === LINK) p = p.leftChild;
 19 
 20             if (visit(p.data) === false) return;
 21 
 22             while (p.rightTag == THREAD && p.rightChild != this) {
 23                 p = p.rightChild;
 24                 visit(p.data);
 25             }
 26             p = p.rightChild;
 27         }
 28     },
 29     // 中序线索化
 30     inOrderThreading: function () {
 31         return inOrderThreading(this);
 32     },
 33     // 在当前结点插入子树x，p代表当前结点
 34     insertSubTree: function (xTree) {
 35         var s, q;
 36         // x作为p的左子树
 37         if (this.leftTag === THREAD) {
 38             s = this.leftChild; // s为p的前驱
 39             this.leftTag = LINK;
 40             this.leftChild = xTree;
 41             q = xTree;
 42 
 43             while (q.leftChild && q.leftTag === LINK) q = q.leftChild;
 44             // 找到子树中的最左结点，并修改其前驱指向s
 45             q.leftChild = s;
 46             xTree.rightTag = THREAD;
 47             // x的后继指向p
 48             xTree.rightChild = this;
 49         }
 50         // x作为p的右子树
 51         else if (this.rightTag === THREAD) {
 52             // s为p的后继
 53             s = this.rightChild;
 54             this.rightTag = LINK;
 55             this.rightChild = xTree;
 56             q = xTree;
 57 
 58             while (q.leftChild && q.leftTag === LINK) q = q.leftChild;
 59             // 找到子树中的最左结点，并修改其前驱指向p
 60             q.leftChild = this;
 61             xTree.rightTag = THREAD;
 62             // x的后继指向p的后继
 63             xTree.rightChild = s;
 64         }
 65         // x作为p的左子树，p的左子树作为x的右子树
 66         else {
 67             s = this.leftChild;
 68             var t = s;
 69 
 70             while (t.leftChild && t.leftTag === LINK) t = t.leftChild;
 71             // 找到p的左子树的最左结点t和前驱u
 72             var u = t.leftChild;
 73             this.leftChild = xTree;
 74             xTree.rightTag = LINK;
 75             // x作为p的左子树，p的左子树作为x的右子树
 76             xTree.rightChild = s;
 77             t.leftChild = xTree;
 78             q = xTree;
 79 
 80             while (q.leftChild && q.leftTag === LINK) q = q.leftChild;
 81             // 找到子树中的最左结点，并修改其前驱指向u
 82             q.leftChild = u;
 83         }
 84     }
 85 };
 86 
 87 // 二叉树中序线索化
 88 function inOrderThreading(tree) {
 89     var threadTree = new BinaryThreadTree();
 90     threadTree.leftTag = LINK;
 91     threadTree.rightTag = THREAD;
 92     // 右指针回指
 93     threadTree.rightChild = threadTree;
 94 
 95     var pre;
 96     // 若二叉树为空，左指针回指
 97     if (!tree) threadTree.leftChild = threadTree;
 98     else {
 99         threadTree.leftChild = tree;
100         pre = threadTree;
101         inThreading(tree);  // 中序遍历进行中序线索化
102         // 最后一个结点线索化
103         pre.rightChild = threadTree;
104         pre.rightTag = THREAD;
105         threadTree.rightChild = pre;
106     }
107 
108     return threadTree;
109 
110     function inThreading(p) {
111         if (!p) return;
112 
113         inThreading(p.leftChild);   // 左子树线索化
114         // 前驱线索
115         if (!p.leftChild) {
116             p.leftTag = THREAD;
117             p.leftChild = pre;
118         }
119         // 后继线索
120         if (!pre.rightChild) {
121             pre.rightTag = THREAD;
122             pre.rightChild = p;
123         }
124         pre = p;
125         inThreading(p.rightChild);  // 右子树线索化
126     }
127 }