平衡二叉树

 

创建平衡二叉树

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N=110;
int a[N];
struct node
{
    int data;
    struct node *l,*r;
}*root;
struct node *creat(node *root,int data)  //建树
{
    if (!root)
    {
        root=(struct node *)malloc(sizeof (node));
        root->l=root->r=NULL;
        root->data=data;
    }
    else
    {
        if (root->data>data)
        {
            root->l=creat(root->l,data);
        }
        else
        {
            root->r=creat(root->r,data);
        }
    }
    return root;  //返回根节点
}
void postorder(node *root)     //后序遍历
{
    if (root)
    {
        postorder(root->l);
        postorder(root->r);
        cout<<root->data<<' ';
    }
}
int main()
{
    int n;
    while (cin>>n)
    {
        root=(struct node *)malloc (sizeof (struct node ));   //创建根节点
        root=NULL;
        for (int i=1;i<=n;i++)
        {
            cin>>a[i];
            root=creat(root,a[i]);
        }
        postorder(root);
        puts("");
    }
    return 0;
}

 

 

 

#include <iostream>
#include <bits/stdc++.h>
using namespace std;
struct node
{
    int data;
    node *l,*r;
    int deep;
}*root;
int deept(node *p)
{
    if (!p)return -1;
    return p->deep;
}
void LL (node *&p)
{
    node *q=p->l;
    p->l=q->r;
    q->r=p;
    p->deep=max(deept(p->r),deept(p->l))+1;
    q->deep=max(p->deep,deept(q->l))+1;
    p=q;
}
void RR(node *&p)
{
    node *q=p->r;
    p->r=q->l;
    q->l=p;
    p->deep=max(deept(p->l),deept(p->r))+1;
    q->deep=max(deept(q->r),p->deep)+1;
    p=q;
}
void LR (node *&p)
{
    RR(p->l);
    LL (p);
}
void RL (node *&p)
{
    LL(p->r);
    RR(p);
}
void Insert(node *&p,int k)
{
    if (!p)
    {
        p=(struct node *)malloc(sizeof (node));
        p->data=k;
        p->l=p->r=NULL;
        p->deep=1;
    }
    else if (k<p->data)
    {
        Insert(p->l,k);
        if (deept(p->l)-deept(p->r)>1)
        {
            if (k<p->l->data)
                LL(p);
            else
                LR(p);
        }
    }
    else if (k>p->data)
    {
        Insert(p->r,k);
        if (deept(p->r)-deept(p->l)>1)
        {
            if (k>p->r->data)
                RR(p);
            else
                RL(p);
        }
    }
    p->deep=max(deept(p->l),deept(p->r))+1;
}
signed main()
{
    int n;
    cin>>n;
    root=NULL;
    while (n--)
    {
        int x;
        cin>>x;
        Insert(root,x);
    }
    cout<<root->data<<endl;
    return 0;
}