数据结构实验之查找二：平衡二叉树

创建平衡二叉树，我们采用依次插入节点的方式进行。而平衡二叉树上插入节点采用递归的方式进行。递归算法如下：

（1）      若该树为一空树，那么插入一个数据元素为e的新节点作为平衡二叉树的根节点，树的高度增加1。

（2）      若待插入的数据元素e和平衡二叉树（BBST）的根节点的关键字相等，那么就不需要进行插入操作。

（3）      若待插入的元素e比平衡二叉树（BBST）的根节点的关键字小，而且在BBST的左子树中也不存在和e有相同关键字的节点，则将e插入在BBST的左子树上，并且当插入之后的左子树深度增加1时，分别就下列情况处理之。

(a)    BBST的根节点的平衡因子为-1（右子树的深度大于左子树的深度）：则将根节点的平衡因子更改为0，BBST的深度不变；

(b)    BBST的根节点的平衡因子为0（左右子树的深度相等）：则将根节点的平衡因子修改为1，BBST的深度增加1；

(c)    BBST的根节点的平衡因子为1（左子树的深度大于右子树的深度）：若BBST的左子树根节点的平衡因子为1，则需要进行单向右旋转平衡处理，并且在右旋处理后，将根节点和其右子树根节点的平衡因子更改为0，树的深度不变；

若BBST的左子树根节点的平衡因子为-1，则需进行先向左，后向右的双向旋转平衡处理，并且在旋转处理之后，修改根节点和其左，右子树根节点的平衡因子，树的深度不变；

（4）      若e的关键字大于BBST的根节点的关键字，而且在BBST的右子树中不存在和e有相同关键字的节点，则将e插入到BBST的右子树上，并且当插入之后的右子树深度加1时，分别就不同的情况处理之。

（a）      BBST的根节点的平衡因子是1（左子树的深度大于右子树的深度）：则将根节点的平衡因子修改为0，BBST的深度不变；

（b）      BBST的根节点的平衡因子是0（左右子树的深度相等）：则将根节点的平衡因子修改为-1，树的深度加1；

（c）      BBST的根节点的平衡因子为-1（右子树的深度大于左子树的深度）：若BBST的右子树根节点的平衡因子为1，则需要进行两次选择，第一次先向右旋转，再向左旋转处理，并且在旋转处理之后，修改根节点和其左，右子树根节点的平衡因子，树的深度不变；

若BBST的右子树根节点的平衡因子为1，则需要进行一次向左的旋转处理，并且在左旋之后，更新根节点和其左，右子树根节点的平衡因子，树的深度不变；

数据结构实验之查找二：平衡二叉树

Time Limit: 400ms   Memory limit: 65536K  有疑问？点这里^_^

题目描述

根据给定的输入序列建立一棵平衡二叉树，求出建立的平衡二叉树的树根。

输入

输入一组测试数据。数据的第1行给出一个正整数N(n <= 20)，N表示输入序列的元素个数；第2行给出N个正整数，按数据给定顺序建立平衡二叉树。

输出

输出平衡二叉树的树根。

示例输入

5
88 70 61 96 120

示例输出

70

提示

 

来源

xam 

示例程序

 

#include<stdio.h>
#include<stdlib.h>
struct node
{
    int data;
    int d;
    struct node *lchild,*rchild;
};
int Max(int x,int y)
{
    return x>y?x:y;
}
int Deep(struct node *head)
{
    if(!head)
        return -1;
    return head->d;
}
struct node *LL(struct node *head)
{
    struct node *p=head->lchild;
    head->lchild=p->rchild;
    p->rchild=head;
    p->d=Max(Deep(p->lchild),Deep(p->rchild))+1;
    head->d=Max(Deep(head->lchild),Deep(head->rchild))+1;
    return p;
};
struct node *RR(struct node *head)
{
    struct node *p=head->rchild;
    head->rchild=p->lchild;
    p->lchild=head;
    p->d=Max(Deep(p->lchild),Deep(p->rchild))+1;
    head->d=Max(Deep(head->lchild),Deep(head->rchild))+1;
    return p;
};
struct node *RL(struct node *head)
{
    head->rchild=LL(head->rchild);
    return RR(head);
};
struct node *LR(struct node *head)
{
    head->lchild=RR(head->lchild);
    return LL(head);
};
struct node *creat(struct node *head,int x)
{
    if(head==NULL)
    {
        head=(struct node *)malloc(sizeof(struct node));
        head->lchild=NULL;
        head->rchild=NULL;
        head->d=1;
        head->data=x;
    }
    else if(x<head->data)
    {
        head->lchild=creat(head->lchild,x);
        if(Deep(head->lchild)-Deep(head->rchild)>1)
            if(x<head->lchild->data)
            head=LL(head);
            else
                head=LR(head);
    }
    else if(x>head->data)
    {
        head->rchild=creat(head->rchild,x);
        if(Deep(head->rchild)-Deep(head->lchild)>1)
            if(x>head->rchild->data)
            head=RR(head);
        else
            head=RL(head);
    }
    head->d=Max(Deep(head->lchild),Deep(head->rchild))+1;
    return head;
};
int main()
{
    int i,j,n,m,k,t;
    struct node *head=NULL;
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
       scanf("%d",&k);
       head=creat(head,k);
    }
    printf("%d\n",head->data);
}