数据结构14.自平衡二叉查找树_AVL树

引言

　在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。

　AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis，他们在1962年的论文《An algorithm for the organization of information》中发表了它。

一． AVL树定义

平衡二叉树又称AVL树,它或者是一棵空树,或者是具有下列性质的二叉排序树:

- 它的左子树和右子树都是平衡二叉树,

- 且左子树和右子树高度之差的绝对值不超过1.

图给出了两棵二叉排序树,树中每个节点旁边所标记的数字是以该节点为根的二叉树的左子树和右子树的高度之差,该数字被称为节点的平衡因子.

由平衡二叉树的定义可知, 平衡二叉树中的所有节点的平衡因子只能取1、0或-1中的一个值。平衡因子的绝对值大于1,如带有 -2或2的节点被认为是不平衡的，并需要重新平衡这个树。平衡因子可以直接存储在每个节点中，或从可能存储在节点中的子树高度计算出来。

二叉排序树是一棵完全二叉树或者与折半查找的判定树相似时,其查找性能最好,而当二叉排序树蜕化为单支树时其查找性能最差.因此,二叉排序树最好是一棵平衡二叉树.

保持二叉排序树为平衡二叉树的基本思想是:每当给二叉排序树插入一个新节点时,就检查是否因为这次插入而破坏了平衡;如果破坏了平衡,则找出其中最小的不平衡树,在保持二叉排序树有序的前提下,调整最小不平衡树中节点的关系以达到新的平衡.所谓最小不平衡树即指距插入节点最近且其平衡因子的绝对值大于1的节点做根的这样一棵子树.

我们将平衡二叉树定义为:

typedef struct AVL_node{
    int                data;  //节点数据域
    int              height;  //节点高度
    struct AVL_node  * left;  //左孩子
    struct AVL_node  *right;  //右孩子
}AVL_node;                    //节点

typedef AVL_node *AVL_Tree;   //树

二．AVL树的接口

  • avl_tree.h
#ifndef _AVL_TREE_H_
#define _AVL_TREE_H_

typedef struct AVL_node{
    int                data;  //节点数据域
    int              height;  //节点高度
    struct AVL_node  * left;  //左孩子
    struct AVL_node  *right;  //右孩子
}AVL_node;                    //节点

typedef AVL_node *AVL_Tree;   //树

#define  ONE       (1)
#define  max(a, b) ((a) < (b) ? (b) : (a))

//AVL树的接口
//1.        得到树的高度
int         get_tree_height(AVL_Tree root)             ;
//2.        遍历二叉树
//2.1       前序遍历
void        preorder_avltree(AVL_Tree root)            ;
//2.2       中序遍历
void        inorder_avltree(AVL_Tree root)             ;
//2.3       后序遍历
void        postorder_avltree(AVL_Tree root)           ;

//3.        查找数据域为value的节点
//3.1       递归查找
AVL_node *  find_node(AVL_Tree root, int value)        ;
//3.2       非递归查找
AVL_node *  find_node_(AVL_Tree root, int value)       ;
//3.3       找到值最大的节点
AVL_node *  get_max_node(AVL_Tree root)                ;
//3.4       找到值最小的节点
AVL_node *  get_min_node(AVL_Tree root)                ;

//4.        将节点插入到avl树中
AVL_Tree    avltree_insert(AVL_Tree root, int data)    ;
//5.        从avl树中删除指定数值
AVL_Tree    avltree_delete(AVL_Tree root, int data)    ;
//6.        销毁avl树
void        destroy_avltree(AVL_Tree root)             ;
#endif//_AVL_TREE_H_

三. AVL树的接口实现

查找

可以像普通二叉查找树一样的进行，所以耗费O(log n)时间，因为AVL树总是保持平衡的。不需要特殊的准备，树的结构不会由于查找而改变。（这是与伸展树查找相对立的，它会因为查找而变更树结构。）

插入

AVL树的基本操作一般涉及运作同在不平衡的二叉查找树所运作的同样的算法。但是要进行预先或随后做一次或多次所谓的”AVL旋转”。

有四种种情况可能导致二叉查找树不平衡，分别为：

LL：插入一个新节点到根节点的左子树(Left)的左子树(Left),导致根节点的平衡因子由1变为2
RR：插入一个新节点到根节点的右子树(Right)的右子树(Right),导致根节点的平衡因子由-1变为-2
LR：插入一个新节点到根节点的左子树(Left)的右子树(Right),导致根节点的平衡因子由1变为2
RL：插入一个新节点到根节点的右子树(Righ)的左子树(Left),导致根节点的平衡因子由-1变为-2

针对四种种情况可能导致的不平衡，可以通过旋转使之变平衡。有两种基本的旋转：

左旋转：将根节点旋转到（根节点的）右孩子的左孩子位置
右旋转：将根节点旋转到（根节点的）左孩子的右孩子位置

以下图表以四列表示四种情况，每行表示在该种情况下要进行的操作。在左左和右右的情况下，只需要进行一次旋转操作；在左右和右左的情况下，需要进行两次旋转操作。

假设由于在二叉排序树上插入节点而失去平衡的最小子树根节点的指针为a（即a是离插入点最近，且平衡因子绝对值超过1的祖先节点），则失去平衡后进行的规律可归纳为下列四种情况：

单向右旋平衡处理LL：由于在*a的左子树根节点的左子树上插入节点，*a的平衡因子由1增至2，致使以*a为根的子树失去平衡，则需进行一次右旋转操作；

单向左旋平衡处理RR：由于在*a的右子树根节点的右子树上插入节点，*a的平衡因子由-1变为-2，致使以*a为根的子树失去平衡，则需进行一次左旋转操作；

双向旋转（先左后右）平衡处理LR：由于在*a的左子树根节点的右子树上插入节点，*a的平衡因子由1增至2，致使以*a为根的子树失去平衡，则需进行两次旋转（先左旋后右旋）操作。

双向旋转（先右后左）平衡处理RL：由于在*a的右子树根节点的左子树上插入节点，*a的平衡因子由-1变为-2，致使以*a为根的子树失去平衡，则需进行两次旋转（先右旋后左旋）操作。
  • 删除

    从AVL树中删除节点node，可以分三种情况:

    1. node的左右子树其中一个为空,则将node指向node的非空孩子,然后释放掉node;
    2. node在左子树,则在左子树删除掉节点之后,检测不平衡状态,是否右边高于左边,然后根据右子树情况,判断是RR,还是RL,进行旋转.
    3. node在右子树,根据删除节点之后是否不平衡,根据左子树判断是否需要LL右旋,或是LR.

      或者:

      (从AVL树中删除，可以透过把要删除的节点向下旋转成一个葉子節點，接着直接移除这个叶子节点来完成。因为在旋转成葉子節點期间最多有log n个节点被旋转，而每次AVL旋转耗费固定的时间，所以删除处理在整体上耗费O(log n) 时间。)

  • avl_tree.c
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include "tools.h"
#include "avl_tree.h"

//创建一个节点
static AVL_node *create_node(void)
{
    AVL_node *result = (AVL_node *)Malloc(sizeof(AVL_node));
    if(result == NULL)
    {
        fprintf(stderr, "the memory is full!\n");
        exit(1);
    }
    bzero(result, sizeof(AVL_node));
    return result;
}
//获取节点结构中的高度变量
static int node_height(AVL_Tree node)
{
    if(node == NULL)
    {
        return -1;
    }
    return node->height;
}
//计算节点的高度
static int avl_node_height(AVL_node *node)
{
    return max(node_height(node->left), node_height(node->right)) + 1;
}

//1.        得到树的高度
int      get_tree_height(AVL_Tree root)    //得到avl树的高度
{
    return node_height(root);
}

//2.        遍历二叉树
void     preorder_avltree(AVL_Tree root)    //2.1前序遍历avl树
{
    if(root != NULL)
    {
        printf("%d ", root->data);
        preorder_avltree(root->left);
        preorder_avltree(root->right);
    }
}

void     inorder_avltree(AVL_Tree root)     //2.2中序遍历avl树
{
    if(root != NULL)
    {
        inorder_avltree(root->left);
        printf("%d ", root->data);
        inorder_avltree(root->right);
    }
}

void     postorder_avltree(AVL_Tree root)   //2.3后序列遍历avl树
{
    if(root != NULL)
    {
        postorder_avltree(root->left);
        postorder_avltree(root->right);
        printf("%d ", root->data);
    }
}
//3.查找数据域为value的节点
//3.1.递归方式查找
AVL_node *find_node(AVL_Tree root, int value)
{
    if(root == NULL || root->data == value)
    {
        return root;
    }
    if(value < root->data)//小于,去左子树
    {
        return find_node(root->left, value);
    }
    else
    {
        return find_node(root->right, value);
    }
}
//3.2.非递归方式查找
AVL_node *find_node_(AVL_Tree root, int value)
{
    AVL_node *p_node = root;

    while(p_node != NULL)
    {
        if(p_node->data > value)//如果当前节点的值大于被查找的值，则继续比较当前节点的左孩子
        {
            p_node = p_node->left;
        }
        else if(p_node->data < value)//如果当前节点的值小于被查找的值，则继续比较当前节点的右孩子
        {
            p_node = p_node->right;
        }
        else//当前节点的值符合要求
        {
            return p_node;
        }
    }
    return NULL;
}
//3.3       找到值最大的节点
AVL_node *get_max_node(AVL_Tree root)    //找到值最大的节点
{
    AVL_node *p_node = root;

    while(p_node->right != NULL)//最右节点
    {
        p_node = p_node->right;
    }

    return p_node;
}

//3.4       找到值最小的节点
AVL_node *get_min_node(AVL_Tree root)    //找到值最小的节点
{
    AVL_node *p_node = root;

    while(p_node->left != NULL)//最左节点
    {
        p_node = p_node->left;
    }

    return p_node;
}

//[单旋]-(左旋)
//              3 node
//             / \
//            A   5 new_root    5
//               / \           / \
//              B   7         3   7
//                 / \       /\   /\
//                C   D     A B  C  D
//左旋转：将根节点旋转到（根节点的）右孩子的左孩子位置
//1.new_root 指向根节点(3)的右孩子(5),作为新的根节点;
//2.new_root 的左孩子(B)要作为原根节点node(3)的右孩子(node->right = new_root->left);
//3.new_root 的左孩子指向原node(3);
//4.修改节点高度
static AVL_node *avl_rotate_left(AVL_node *node)
{
    AVL_node *new_root = NULL;
    if(NULL == node)
    {
        return NULL;
    }
    //1.2.3.以此,将根节点旋转到右孩子的左孩子位置,
    new_root = node->right;
    node->right = new_root->left;
    new_root->left = node;

    //4.旋转完后修改当前节点的高度(有顺序要求)
    node->height = avl_node_height(node);
    new_root->height = avl_node_height(new_root);

    return new_root;
}
//[单旋]-(右旋)
//                 5
//                / \
//               3   A          3
//              / \            / \
//             2   B          2   5
//            / \            /\   /\
//           D   C          D  C B  A
//右旋转：将根节点旋转到（根节点的）左孩子的右孩子位置
//1.new_root 指向根节点(5)的左孩子(3),作为新的根节点;
//2.new_root 的右孩子(B)要作为原根节点node(5)的左孩子;
//3.new_root 的右孩子指向原node(5);
//4.修改节点高度
static AVL_node *avl_rotate_right(AVL_node *node)
{
    AVL_node *new_root = NULL;
    if(NULL == node)
    {
        return NULL;
    }
    //1.2.3.以此,将根节点旋转到左孩子的右孩子位置;
    new_root = node->left;
    node->left = new_root->right;
    new_root->right = node;

    //4.旋转完后修改当前节点的高度（右顺序要求）
    node->height = avl_node_height(node);
    new_root->height = avl_node_height(new_root);

    return new_root;
}
//[双旋]-左右旋转(先左后右)
//
//        5                5
//       / \              / \
//      3   A            4   A         4
//     / \              / \           / \
//    B   4            3   D         3   5
//       / \          / \           /\   /\
//      C   D        B   C         B  C D  A
//1.先对node的左孩子进行左旋;
//2.再对node进行右旋;
static AVL_node *avl_rotate_left_right(AVL_node *node)
{
    node->left = avl_rotate_left(node->left);
    return avl_rotate_right(node);
}
//[双旋]-右左旋转(先右后左)
//
//     3           3
//    / \         / \
//   A   5       A   4                4
//      / \         / \              / \
//     4   B       D   5            3   5
//    / \             / \          / \ / \
//   D   C           C   B        A  D C  B
//1.先对node的右孩子进行左旋;
//2.再对node进行左旋;
static AVL_node * avl_rotate_right_left(AVL_node *node)
{
    node->right = avl_rotate_right(node->right);
    return avl_rotate_left(node);
}

//4. 将节点插入到avl树中
AVL_Tree avltree_insert(AVL_Tree root, int data)
{
    int height_diff = 0;

    if(NULL == root) //为空,则创建一个节点作为树
    {
        root = create_node();
        root->data = data;
    }
    else if(data < root->data) //需要插入的值比当前根节点小,向左子树插入
    {
        root->left = avltree_insert(root->left, data);
        height_diff = node_height(root->left) - node_height(root->right);
        //height_different = 左子树-右子树(因为向左插入,左边有可能变高)
        if(height_diff > ONE)//左子树高了
        {
            if(data < root->left->data)//左孩子的左子树,LL
            {
                root = avl_rotate_right(root);
            }
            else//左孩子的右子树,LR
            {
                root = avl_rotate_left_right(root);
            }
        }
    }
    else if(data > root->data) //需要插入的值比当前根节点大,向右子树插入
    {
        root->right = avltree_insert(root->right, data);
        height_diff = node_height(root->right) - node_height(root->left);
        //右高左低
        if(height_diff > ONE)
        {
            if(data > root->right->data)//右孩子的右子树,左旋,RR
            {
                root = avl_rotate_left(root);
            }
            else//右孩子的左子树,RL
            {
                root = avl_rotate_right_left(root);
            }
        }
    }
    else
    {
        //data == root->data,已经存在不进行插入;
        fprintf(stderr, "the tree_node has been exist.\n\n");
    }

    root->height = avl_node_height(root);
    return root;
}

//5.0 删除节点操作
static AVL_Tree delete_node(AVL_Tree root, AVL_node *node)
{
    int        height_diff   = 0   ;
    AVL_node * temp          = NULL;
    AVL_node * p_node        = NULL;
    AVL_node * left_max      = NULL;
    AVL_node * right_min     = NULL;

    if(NULL == root || NULL == node)
    {
        return NULL;
    }

    if(node->data < root->data)//待删除节点在左子树
    {
        root->left = delete_node(root->left, node);//删除操作
        //高度差(需要判断是否大于1即破坏平衡)
        height_diff = node_height(root->right) - node_height(root->left);
        //height_diff > 1则进行相应旋转
        if(height_diff > ONE)
        {
            p_node = root->right;
            if(node_height(p_node->left) > node_height(p_node->right))//RL情况,
            {
                root = avl_rotate_right_left(root);
            }
            else//RR,左旋
            {
                root = avl_rotate_left(root);
            }
        }
    }
    else if(node->data > root->data)//待删除节点在右子树
    {
        root->right = delete_node(root->right, node);
        height_diff = node_height(root->left) - node_height(root->right);
        //破坏了平衡,则进行旋转
        if(height_diff > ONE)
        {
            p_node = root->left;
            //删除了右子树的一个节点,
            //若此时,这棵树不平衡,即看其左子树,
            //若左子树的右子树高于左子树,即,在其左子树上的右子树多出来,即LR
            //否则,左子树的右子树低于左子树,LL,左左,即右旋
            if(node_height(root->right) > node_height(root->left))
            {
                root = avl_rotate_left_right(root);
            }
            else
            {
                root = avl_rotate_right(root);
            }
        }
    }
    else//此root即为需要删除的节点
    {
        //root左右子树都不为空
        //if((root->left != NULL) && (root->right != NULL))
        if(root->left && root->right)
        {
            //左子树高于右子树
            //1.找出root左子树中最大值节点
            //2.将该节点点的值赋值给root
            //3.删除该左子树中的那个最大节点
            if(node_height(root->left) > node_height(root->right))
            {
                left_max = get_max_node(root->left);           //1.找最大
                root->data = left_max->data;                   //2.赋值给root
                root->left = delete_node(root->left, left_max);//3.删除最大
            }
            else//左子树低于右子树
            {
                //1.找出该root右子树中最小节点
                //2.此将最小值赋值给root
                //3.删除该最小节点
                right_min = get_min_node(root->right);           //1.找最小
                root->data = right_min->data;                    //2.赋值给root
                root->right = delete_node(root->right,right_min);//3.删除最小
            }
        }
        else//被删除的节点左右孩子至少一个为空
        {
            temp = root;
            if(root->left != NULL)//左孩子不为空,则指向其左孩子
            {
                root = root->left;
            }
            else              //右孩子不为空,则向下指向其右孩子
            {
                root = root->right;
            }
            free(temp);
        }
    }
    return root;
}
//5.1 调整整个树节点的高度
static int adjust_node_height(AVL_Tree root)
{
    int left_height = 0;
    int right_height = 0;

    if(NULL == root)//为空,返回-1
    {
        return -1;
    }
    else if((NULL == root->left) && (NULL == root->right))//叶子节点,高度为0
    {
        return 0;
    }
    else
    {
        //非叶子节点高度 = 左右子树中最大值 + 1
        left_height = adjust_node_height(root->left);
        right_height = adjust_node_height(root->right);
        return max(left_height, right_height) + 1;
    }
}
//5. AVL树中删除指定数据
AVL_Tree avltree_delete(AVL_Tree root, int data)
{
    AVL_node *node = NULL;

    if((node = find_node(root, data)) != NULL)//找到相应节点
    {
        root = delete_node(root, node);//调用删节点函数
        adjust_node_height(root);
    }
    return root;
}
//6 销毁AVL树
void destroy_avltree(AVL_Tree root)
{
    if(NULL == root)
    {
        return ;
    }

    destroy_avltree(root->left);
    destroy_avltree(root->right);
    free(root);
}

四. 函数功能检测

  • main.c
#include <stdio.h>
#include <stdlib.h>
#include "avl_tree.h"

#define COUNT (10)

int main(int argc, char **argv)
{
    int          i = 0   ;
    int      value = 0   ;
    AVL_Tree  root = NULL;
    AVL_node *find = NULL;

    for(i = 0; i < COUNT; ++i)
    {
        value = rand() % (COUNT*COUNT);
        root = avltree_insert(root, value);
        inorder_avltree(root);
        printf("\n");
        if(i == COUNT/2)
        {
            printf("the tree height is: %d\n", get_tree_height(root));
            printf("the max value in tree: %d,\n", get_max_node(root)->data);
            printf("the min value in tree: %d .\n", get_min_node(root)->data);
        }
    }
    printf("then insert %d in avl_tree :\n", COUNT);
    avltree_insert(root, COUNT);
    inorder_avltree(root);
    printf("\n");
    printf("then the max value in avltree: %d,\n", get_max_node(root)->data);
    printf("then the min value in avltree: %d .\n", get_min_node(root)->data);
    printf("\n");
    if((find = find_node(root, COUNT)))
    {
        printf("we find the %d\n", find->data);
    }
    printf("then we delete %d node:\n", COUNT);
    avltree_delete(root, COUNT);
    inorder_avltree(root);
    printf("\n");
    printf("and then the tree height is:%d\n", get_tree_height(root));
    printf("inorder:");
    inorder_avltree(root);
    printf("\n");
    printf("preorder: ");
    preorder_avltree(root);
    printf("\n");
    printf("postorder: ");
    postorder_avltree(root);
    printf("\n");

    printf("destroy\nthis\ntree\n");
    destroy_avltree(root);
}
  • 运行结果
[email protected]:~/AVL_Tree# cc.sh *.c
Compiling ...
-e CC      avl_tree.c main.c tools.c -g -lpthread -lm
-e         Completed .
-e         Fri Aug 26 10:41:04 CST 2016

[email protected]:~/AVL_Tree# ./avl_tree
83
83 86
77 83 86
15 77 83 86
15 77 83 86 93
15 35 77 83 86 93
the tree height is: 2
the max value in tree: 93,
the min value in tree: 15 .
the tree_node has been exist.

15 35 77 83 86 93
15 35 77 83 86 92 93
15 35 49 77 83 86 92 93
15 21 35 49 77 83 86 92 93
then insert 10 in avl_tree :
10 15 21 35 49 77 83 86 92 93
then the max value in avltree: 93,
then the min value in avltree: 10 .

we find the 10
then we delete 10 node:
15 21 35 49 77 83 86 92 93
and then the tree height is:3
inorder:15 21 35 49 77 83 86 92 93
preorder: 83 35 15 21 77 49 92 86 93
postorder: 21 15 49 77 35 86 93 92 83
destroy
this
tree

五. 总结

高度为h的AVL树，节点数N最多2h?1;最少为Φh+25√?1;(其中 Φ = 1+5√2=1.618)

最少为( 其中 )

最少节点数 n 如以斐波那契数列可以用数学归纳法证明：

Nh=Fh+2?1(Fh+2是Fibonaccipolynomial)

即:

N0=0(表示AVL Tree高度為0的节点总数)

N1=1 (表示AVL Tree高度為1的节点总数)

N2=2(表示AVL Tree高度為2的节点总数)

Nh=Nh?1+Nh?2+1 (表示AVL Tree高度為h的节点总数)

换句话说，当节点数为N时，高度h最多为logΦ(5√?(N+1))?2。

AVL树,是最早提出的自平衡二叉树,对我们而言,了解及实现关于二叉树节点的左旋右旋,不仅是对AVL树的操作更加深刻,也是为了了解前人智慧结晶的方法.

就算前人实现过,我们有了巨人的肩膀,还是要一步步走上去.

加油.

时间： 2025-01-22 10:08:56

数据结构14.自平衡二叉查找树_AVL树的相关文章

[重温数据结构]一种自平衡二叉查找树avl树的实现方法

最近重温<数据结构>,发现其中的东西我上学的时候几乎都没写过... 惭愧啊.于是打算一一写点.算是对我逝去青春的纪念... avl树的代码网上有很多, 这个在平衡二叉树里面算是比较简单的. 需要注意的就是树的平衡因子和其子树的平衡因子符号相反的旋转情况.这个在函数avl_rotate_right等中有处理. 目前只做了插入,删除等哪天想做了再做吧. avl.h 1 #define INSERT_ERROR -1 2 #define INSERT_OK 1 3 4 #define LEFT_LE

平衡二叉查找树——AVL树

二叉查找树在最坏情况下高度可能为N-1,即插入元素时后插入的元素总比以前插入的元素大或者小.为了解决这种不平衡的情况,引入了平衡条件来限制树中节点的深度不能过深,其中最老的一种平衡树称为AVL树.这种树限制树中每个节点的左右子树的高度相差不能超过一.(另一种更严格的树限制节点的左右子树高度必须相等,但这样的树要求树中的节点数目为2的k次幂减1,是一种理想平衡树,但是要求太严格,无法实际使用.) AVL树平衡条件分析 AVL树是一棵特殊的二叉查找树,对AVL树的操作中,除了插入操作与普通二叉查找树

java数据结构与算法之平衡二叉树(AVL树)的设计与实现

[版权申明]未经博主同意,不允许转载!(请尊重原创,博主保留追究权) http://blog.csdn.net/javazejian/article/details/53892797 出自[zejian的博客] 关联文章: java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现 java数据结构与算法之改良顺序表与双链表类似ArrayList和LinkedList(带Iterator迭代器与fast-fail机制) java数据结构与算法之栈(Stack)设

图解数据结构（7）——二叉查找树及平衡二叉查找树（一共14篇）

这篇将是最有难度和挑战性的一篇,做好心理准备!十.二叉查找树(BST)前一篇介绍了树,却未介绍树有什么用.但就算我不说,你也能想得到,看我们Windows的目录结构,其实就是树形的,一个典型的分类应用.当然除了分类,树还有别的作用,我们可以利用树建立一个非常便于查找取值又非常便于插入删除的数据结构,这就是马上要提到的二叉查找树(Binary Search Tree),这种二叉树有个特点:对任意节点而言,左子(当然了,存在的话)的值总是小于本身,而右子(存在的话)的值总是大于本身. 这种特性使得我

AVL树（平衡二叉查找树）

首先要说AVL树,我们就必须先说二叉查找树,先介绍二叉查找树的一些特性,然后我们再来说平衡树的一些特性,结合这些特性,然后来介绍AVL树. 一.二叉查找树 1.二叉树查找树的相关特征定义 二叉树查找树,又叫二叉搜索树,是一种有顺序有规律的树结构.它可以有以下几个特征来定义它: (1)首先它是一个二叉树,具备二叉树的所有特性,他可以有左右子节点(左右孩子),可以进行插入,删除,遍历等操作: (2)如果根节点有左子树,则左子树上的所有节点的值均小于根节点上的值,如果根节点有右子树,则有字数上的所有节

算法学习 - 平衡二叉查找树实现(AVL树)

平衡二叉查找树 平衡二叉查找树是很早出现的平衡树,因为所有子树的高度差不超过1,所以操作平均为O(logN). 平衡二叉查找树和BS树很像,插入和删除操作也基本一样,但是每个节点多了一个高度的信息,在每次插入之后都要更新树的每个节点的高度,发现不平衡之后就要进行旋转. 单旋转 单旋转是碰到左左或者右右的情况下所使用的方法. 例如: 3 2 1 这种情况就需要旋转,因为3是根节点,它的左子树高度为0,右子树高度为2,相差超过1了,所以要进行旋转,而这是右右的情况,所以是单旋转. 2 / 1 3 这

AVL树-自平衡二叉查找树(Java实现)

在计算机科学中,AVL树是最先发明的自平衡二叉查找树.AVL树得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis,他们在 1962 年的论文 "An algorithm for the organization of information" 中发表了它. 一.AVL树的旋转规律 AVL树的基本操作一般涉及运做同在不平衡的二叉查找树所运做的同样的算法.但是要进行预先或随后做一次或多次所谓的"AVL旋转". 假设由于在二叉排序树上插入

Java数据结构-二叉查找树续以及平衡二叉查找树

??前面一篇文章讲到了二叉查找树的实现,其中的插入操作是使用非递归方法实现的,这里再增加一种递归实现插入的操作,Java代码如下,建议增加到前一篇文章对应的FOBinarySearchTree.java中: /** * @TODO 二叉排序树插入元素(递归方法) * @param e 需要插入的元素 * @return true or false */ public boolean insert(E e){ insert(root,e); return true; } /** * @TODO 二

数据结构-自平衡二叉查找树（AVL）详解

介绍: 在计算机科学中,AVL树是最先发明的自平衡二叉查找树. 在AVL树中任何节点的两个子树的高度最大差别为一,所以它也被称为高度平衡树. 查找.插入和删除在平均和最坏情况下都是O(log n).增加和删除可能需要通过一次或多次树旋转来重新平衡这个树.AVL树得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis,他们在 1962 年的论文 "An algorithm for the organization of information" 中发表了它.