2004/01/12 06:38:31

[org.ibex.core.git] / src / org / xwt / util / BalancedTree.java

diff --git a/src/org/xwt/util/BalancedTree.java b/src/org/xwt/util/BalancedTree.java
index 0775ebe..5e15b3e 100644 (file)
--- a/src/org/xwt/util/BalancedTree.java
+++ b/src/org/xwt/util/BalancedTree.java
@@ -66,7 +66,7 @@ public class BalancedTree {
         int index = 0;
         while(true) {
             // everything to the left is before us so add that to the index
-            index += size(left[slot]);
+            index += sizeof(left[slot]);
             // we are before anything on the right
             while(left[parent[slot]] == slot) slot = parent[slot];
             // we end of the first node who isn't on the left, go to the node that has as its child
@@ -202,7 +202,7 @@ public class BalancedTree {
     private final int rightmost(int slot) { return right[slot] <= 0 ? slot : rightmost(right[slot]); }
     private final int next(int slot) { return right[slot] <= 0 ? -1 * right[slot] : leftmost(right[slot]); }
     private final int prev(int slot) { return left[slot] <= 0 ? -1 * left[slot] : rightmost(left[slot]); }
-    private final int size(int slot) { return slot <= 0 ? 0 : size[slot]; }
+    private final int sizeof(int slot) { return slot <= 0 ? 0 : size[slot]; }
     private final int root(int slot) { return parent[slot] == 0 ? slot : root(parent[slot]); }
 
 
@@ -234,15 +234,15 @@ public class BalancedTree {
         else if (left[p] == b)   left[p] = d;
         else if (right[p] == b)  right[p] = d;
         else throw new Error("rotate called with invalid parent");
-        size[b] = 1 + size(left[b]) + size(right[b]);
-        size[d] = 1 + size(left[d]) + size(right[d]);
+        size[b] = 1 + sizeof(left[b]) + sizeof(right[b]);
+        size[d] = 1 + sizeof(left[d]) + sizeof(right[d]);
     }
 
     private void balance(int slot, int p) {
         if (slot <= 0) return;
-        size[slot] = 1 + size(left[slot]) + size(right[slot]);
-        if (size(left[slot]) - 1 > 2 * size(right[slot])) rotate(false, slot, p);
-        else if (size(left[slot]) * 2 < size(right[slot]) - 1) rotate(true, slot, p);
+        size[slot] = 1 + sizeof(left[slot]) + sizeof(right[slot]);
+        if (sizeof(left[slot]) - 1 > 2 * sizeof(right[slot])) rotate(false, slot, p);
+        else if (sizeof(left[slot]) * 2 < sizeof(right[slot]) - 1) rotate(true, slot, p);
     }
 
 
@@ -250,10 +250,10 @@ public class BalancedTree {
     // Insert /////////////////////////////////////////////////////////////////////////
 
     private void insert(int index, int arg, int slot, int p, boolean replace, boolean wentLeft) {
-        int diff = slot <= 0 ? 0 : index - size(left[slot]);
+        int diff = slot <= 0 ? 0 : index - sizeof(left[slot]);
         if (slot > 0 && diff != 0) {
             if (diff < 0) insert(index, arg, left[slot], slot, replace, true);
-            else insert(index - size(left[slot]) - 1, arg, right[slot], slot, replace, false);
+            else insert(index - sizeof(left[slot]) - 1, arg, right[slot], slot, replace, false);
             balance(slot, p);
             return;
         }
@@ -310,7 +310,7 @@ public class BalancedTree {
     // Retrieval //////////////////////////////////////////////////////////////////////
 
     private int get(int index, int slot) {
-        int diff = index - size(left[slot]);
+        int diff = index - sizeof(left[slot]);
         if (diff > 0) return get(diff - 1, right[slot]);
         else if (diff < 0) return get(index, left[slot]);
         else return slot;
@@ -320,7 +320,7 @@ public class BalancedTree {
     // Deletion //////////////////////////////////////////////////////////////////////
 
     private int delete(int index, int slot, int p) {
-        int diff = index - size(left[slot]);
+        int diff = index - sizeof(left[slot]);
         if (diff < 0) {
             int ret = delete(index, left[slot], slot);
             balance(slot, p);
@@ -360,7 +360,7 @@ public class BalancedTree {
 
             // node to be deleted has two children, so we replace it with its left child's rightmost descendant
             } else {
-                int left_childs_rightmost = delete(size(left[slot]) - 1, left[slot], slot);
+                int left_childs_rightmost = delete(sizeof(left[slot]) - 1, left[slot], slot);
                 left[left_childs_rightmost] = left[slot];
                 right[left_childs_rightmost] = right[slot];
                 if(left[slot] > 0) parent[left[slot]] = left_childs_rightmost;