Question

在研究AVL Tree实现时，我遇到了旋转中断BST属性的情况。

我很确定自己做错了什么，但我无法弄清楚是什么。

我将41、49、21和47插入到AVL树中。当我再增加49次时，它表示“失衡”，如下所示。

                 (Out of balance !!!)
                 (   at 49 L-R      )
     41                41
    /  \              /  \
   21   49  =>      21    49
       /                 /
      47               47
                         \
                          49

因此，我尝试像下面那样向左旋转47和向右旋转49

          Rotate 47         Rotate 49
           to Left          to Right 
     41               41                 41
    /  \     =>      /  \      =>       /  \  
   21   49         21    49           21    49 
       /                /                  /  \
      47               49                47    49
        \             /
         49          47

树的平衡性更好，但是我认为通过在49的右侧设置49来破坏右下子树的BST属性。

    49
   /  \
  47  49

我认为平衡这棵树的最佳方法是

但我不知道如何使用41-49-21-47-49数字加法顺序到达那里。也许这不是正确的结果，但我在这里迷路了。

最佳结果是什么？我应该如何到达那里？

有人可以告诉我我在做什么错吗？

非常感谢！

Answer 1

您实际上并没有做错任何事情。

在评论中，您说“我认为L边小于或等于当前节点值，R边是较大值。对此我是否错？”

...是的，您对此有误。

对于具有重复值的树，右分支仅包含严格较大的元素的条件与平衡操作不兼容。尝试以下操作：将20个相同值的副本链接到树中。如果只能在左侧链接相等的值，则必须制作一个单链接列表。您的树将深达20层并且完全不平衡。

在树中考虑重复值的方法是，树中实际上没有任何重复值：-) BST定义了 total 排序，以及有效的重新平衡操作，例如旋转< em>保留整个排序。

将第二个final Intent intent = new Intent(); intent.setClass(getApplicationContext(), SettingsActivity.class); intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED | Intent.FLAG_ACTIVITY_CLEAR_TOP); intent.putExtra(SettingsActivity.EXTRA_SHOW_HOME_AS_UP, false); intent.putExtra(SettingsActivity.EXTRA_ENTRY_KEY,false); startActivity(intent);插入树中时，会将其放在第一个49的左侧或右侧。如果将其放在左侧，则根据树的顺序，它会更小，并且在进行任何重新平衡后，它总是会更小。如果将其放在右侧，则它将更大，并根据树的顺序保持更大。

如果考虑到这一点，就必须采用这种方式，因为平衡操作甚至都不看查看节点中的值。它们链接在一起的方式确定顺序，并且顺序不变。

Answer 2

对于您来说，如果键和值一致，则可能如下所示。假设您的Node类如下：

class Node {
    int value;     //Value
    int height;    //Height
    Node left;     //Left child
    Node right;    //Right child
    int count = 1; //keeps track of how many duplicate values were inserted
}

然后，当插入新值时，如果有新值等于当前节点中的值，则可以递增count。以下是我对AVL树插入的实现：

public Node insert(Node root, int value) {
    if (root == null) {
        root = new Node();
        root.value = value;
        return root;
    } else if (root.value > value) {
        root.left = insert(root.left, value);
        root.height = Math.max(root.height, root.left.height + 1);
    } else if (root.value < value) {
        root.right = insert(root.right, value);
        root.height = Math.max(root.height, root.right.height + 1);
    } else {
        // consider duplicates the same node
        root.count++;
    }

    Node a = root;
    //left subtree must be rebalanced
    if (balanceFactor(root) == 2) {
        Node b = a.left;
        //it's a left left case
        if (balanceFactor(b) == 1) {
            Node b2 = b.right;
            b.right = a;
            a.left = b2;
            a.height = getHeight(a);
            b.height = getHeight(b);
            return b;
        } else {//it's a left right case
            Node c = b.right;
            Node c1 = c.left;
            Node c2 = c.right;
            a.left = c2;
            c.right = a;
            c.left = b;
            b.right = c1;
            a.height = getHeight(a);
            b.height = getHeight(b);
            c.height = getHeight(c);
            return c;
        }
    } else if (balanceFactor(root) == -2) {//right subtree must be rebalanced
        Node b = a.right;
        //it's a left left case
        if (balanceFactor(b) == -1) {
            Node b1 = b.left;
            b.left = a;
            a.right = b1;
            a.height = getHeight(a);
            b.height = getHeight(b);
            return b;
        } else {//it's a left right case
            Node c = b.left;
            Node c1 = c.left;
            Node c2 = c.right;
            c.right = b;
            c.left = a;
            b.left = c2;
            a.right = c1;
            a.height = getHeight(a);
            b.height = getHeight(b);
            c.height = getHeight(c);
            return c;
        }
    }

    return root;
}

private static int getHeight(Node node) {
    int l = (node.left == null ? 0 : node.left.height + 1);
    int r = (node.right == null ? 0 : node.right.height + 1);
    return Math.max(l, r);
}

private static int balanceFactor(Node node) {
    int left = node.left == null ? -1 : node.left.height;
    int right = node.right == null ? -1 : node.right.height;

    return left - right;
}

这样，您就不再有重复了：）

AVL树-旋转奇数：破坏BST属性

2 个答案: