数据结构 PTA 7-1 上机作业6 7-1 查找上机作业：二叉排序树和平衡二叉树

7-1 查找上机作业：二叉排序树和平衡二叉树

分数 100

全屏浏览题目

切换布局

作者 upcdsa

单位 中国石油大学（华东）

二叉排序树（BST树）的任何结点均满足：“若左子树存在，根结点大于其左子树上的所有结点；若右子树存，根结点小于其右子树上的所有结点。给定一个数据序列（所有数据互不相等），可以构造二叉排序树。例如：按照下面的数据序列及其先后顺序{ 10,30,20,7,5,6,2,9,28 }可构造出如下的二叉排序树。

平衡二叉树（AVL树）是一种二叉排序树，同时要求每个结点左右子树的高度最多相差为１。对上述数据序列，同样按照数据序列及其先后顺序构造平衡二叉树，可构造出如下的平衡二叉树。

对序列中的数据元素进行查找，对于单个数据而言，平衡二叉树查找成功的比较次数不一定比二叉排序树小，但是，在每个数据元素查找的等概率下，平衡二叉树查找成功的平均查找长度要小于二叉排序树的平均查找长度。使用C或C++编写算法完成：
（1）按给定数据序列及其顺序构建二叉排序树；
（2）按给定数据序列及其顺序构建平衡二叉树；
（3）计算并输出二叉排序树中所有数据元素在查找等概率下的平均查找长度；
（4）计算并输出平衡二叉树中所有数据元素在查找等概率下的平均查找长度。

输入格式:

输入分为2行，第1行为数据元素个数，第2行为数据元素，其中个数据元素为整数。

输出格式:

输出分为2行，第1行为二叉排序树的平均查找长度，第2行为平衡二叉树的平均查找长度。平均查找长度位置输出所有数据元素查找成功的比较次数之和即可。这样输出就是一个整数了。

输入样例:

对于上面的数据序列，输入格式为：

9
10,30,20,7,5,6,2,9,28

输出样例:

对于上面的数据序列，输出格式为:

BST-ASL:26
AVL-ASL:25

其中“BST-ASL:”和“AVL-ASL:”为二叉排序树和平衡二叉树的平均查找长度提示，其后为各自树中所有数据查找成功的比较次数之和。

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

#include <iostream>

using namespace std;

typedef struct TreeNode
{
    int num;
    int deep;
    int bf;
    TreeNode *left;
    TreeNode *right;
} * Tree;

Tree bulid_bst(Tree p, Tree t)
{
    Tree n;
    n = t;
    int i = 1;
    if (t->num == -1)
    {
        t->num = p->num;
        t->deep = i;
    }
    else
    {
        while (true)
        {
            i++;
            if (p->num < n->num)
            {
                if (n->left == NULL)
                {
                    p->deep = i;
                    n->left = p;
                    break;
                }
                else
                {
                    n = n->left;
                }
            }
            else
            {
                if (n->right == NULL)
                {
                    p->deep = i;
                    n->right = p;
                    break;
                }
                else
                {
                    n = n->right;
                }
            }
        }
    }
    return t;
}

int getdeep(TreeNode *t)
{
    if (t == NULL)
        return -1;
    else
        return t->deep;
}

bool isBalanced(TreeNode *left, TreeNode *right)
{
    return abs(getdeep(left) - getdeep(right)) < 2;
}

//左左
TreeNode *SingleRotateLeft(TreeNode *t2)
{
    TreeNode *t1;
    t1 = t2->left;
    t2->left = t1->right;
    t1->right = t2;

    t2->deep = max(getdeep(t2->left), getdeep(t2->right)) + 1;
    t1->deep = max(getdeep(t1->left), getdeep(t1->right)) + 1;
    return t1;
}

//右右
TreeNode* SingleRotateRight(TreeNode* t2)
{
    TreeNode *t1;
    t1 = t2->right;
    t2->right = t1->left;
    t1->left = t2;

    t2->deep = max(getdeep(t2->left), getdeep(t2->right)) + 1;
    t1->deep = max(getdeep(t1->left), getdeep(t1->right)) + 1;
    return t1;
}

//左右
TreeNode *DoubleRotateLR(TreeNode *t3)
{
    t3->left = SingleRotateRight(t3->left);
    return SingleRotateLeft(t3);
}

//右左
TreeNode *DoubleRotateRL(TreeNode *t3)
{
    t3->right = SingleRotateLeft(t3->right);
    return SingleRotateRight(t3);
}



TreeNode *insert(int v, TreeNode *root)
{
    if (root == NULL)
    {
        root = (Tree)malloc(sizeof(TreeNode));
        root->num = v;
        root->left = NULL;
        root->right = NULL;
        root->deep = 0;
        return root;
    }
    if (v > root->num) //节点插入在右子树中
    {
        
        root->right = insert(v, root->right);
        if (!isBalanced(root->left, root->right))
        {
            if (v > root->right->num)
                root = SingleRotateRight(root);
            else
                root = DoubleRotateRL(root);
        }
    }
    else
    {
        root->left = insert(v, root->left);
        if (!isBalanced(root->left, root->right))
        {
            if (v < root->left->num)
                root = SingleRotateLeft(root);
            else
                root = DoubleRotateLR(root);
        }
    }
    root->deep = max(getdeep(root->left), getdeep(root->right)) + 1;
    return root;
}

int bst_avl(Tree t)
{
    if (t->left == NULL && t->right == NULL)
    {
        return t->deep;
    }
    else
    {
        if (t->left == NULL)
        {
            return bst_avl(t->right) + t->deep;
        }
        if (t->right == NULL)
        {
            return bst_avl(t->left) + t->deep;
        }
    }
    return t->deep + bst_avl(t->left) + bst_avl(t->right);
}

void fun(Tree t)
{
    if(t->left != NULL)
    {
        t->left->deep = t->deep +1;
        fun(t->left);
    }
    if(t->right != NULL)
    {
        t->right->deep = t->deep +1;
        fun(t->right);
    }
}

int main()
{
    int n;
    char s;
    Tree t;
    Tree root;
    root = NULL;
    t = (Tree)malloc(sizeof(TreeNode));
    t->num = -1;
    t->left = NULL;
    t->right = NULL;
    cin >> n;
    int a[n + 5];
    for (int i = 0; i < n; i++)
    {
        Tree p, q;
        p = (Tree)malloc(sizeof(TreeNode));
        p->left = NULL;
        p->right = NULL;
        q = (Tree)malloc(sizeof(TreeNode));
        q->left = NULL;
        q->right = NULL;
        q->bf = 0;
        if (i != 0)
        {
            cin >> s;
        }
        cin >> p->num;
        t = bulid_bst(p, t);
        root = insert(p->num,root);
    }
    cout << "BST-ASL:" <<bst_avl(t) << endl;
    root->deep = 1;
    fun(root);
    cout << "AVL-ASL:"<<bst_avl(root);
    return 0;
}

 

简介

👨‍💻个人主页：@云边牧风
👨‍🎓小编介绍：欢迎来到云边牧风破烂的小星球🌝
📋专栏：UPC 数据结构与算法 课程 PTA平台
🔑本章内容：输入输出流
记得 评论📝 +点赞👍 +收藏😽 +关注💞哦~