树

最新推荐文章于 2024-08-06 21:51:46 发布
最新推荐文章于 2024-08-06 21:51:46 发布
阅读量181 收藏
点赞数 1
分类专栏： # 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43958765/article/details/106953610
版权

《Data Structures and Algorithm Analysis in C》（数据结构与算法分析 C语言描述）

目录

构造表达式树
typedef char element_type;
struct TreeNode
{
    element_type element;
    TreeNode *left;
    TreeNode *right;
    TreeNode(element_type e, TreeNode * l, TreeNode * r){
        element = e;
        left = l;
        right = r;
    }
};
typedef TreeNode *BTree;

void post_trav(BTree node, int depth)
{
    if(node != NULL)
    {
        post_trav(node->left, depth+1);
        post_trav(node->right, depth+1);
        for (size_t i = 0; i < depth; i++)
            cout << "\t" ;
        cout << node->element << endl;
    }
}
void pre_trav(BTree node, int depth)
{
    if(node != NULL)
    {
        for (size_t i = 0; i < depth; i++)
            cout << "\t" ;
        cout << node->element << endl;
        pre_trav(node->left, depth+1);
        pre_trav(node->right, depth+1);
    }
}
bool is_operator(char c)
{
    return c == '+' ||
           c == '-' ||
           c == '*' ||
           c == '/' ;
}
BTree exptrsson_tree(string psot_exp)
{
    stack<BTree> sta;
    for (char c : psot_exp)
    {   
        if(is_operator(c))
        {
            BTree right = sta.top();
            sta.pop();
            BTree left = sta.top();
            sta.pop();
            BTree t = new TreeNode(c, left, right);
            sta.push(t);
        }else
        {
            BTree t = new TreeNode(c, NULL, NULL);
            sta.push(t);
        }
    }
    BTree root = sta.top();
    return root;
}
string infix_to_postfix(string)
{
    //
    return "";
}

int main(int argc, const char** argv) {
    string expression = "ab+cde+**";  // postfix, 中缀可转后缀
    post_trav(exptrsson_tree(expression), 0);
    return 0;
}
二叉查找树

左子树 < 根 < 右子树，中序遍历即为由小到大排序。

typedef int element_type;
struct TreeNode
{
    element_type element;
    TreeNode *left;
    TreeNode *right;
    TreeNode(element_type e, TreeNode * l, TreeNode * r){
        element = e;
        left = l;
        right = r;
    }
};
typedef TreeNode *BTree;
typedef TreeNode *Position;

void in_trav(BTree node)  // 排序
{
    if(node != NULL)
    {
        in_trav(node->left);
        cout << node->element << " ";
        in_trav(node->right);
    }
}

Position find_x(element_type x, BTree T)
{
    if(T == NULL)
        return NULL;
    if(x < T->element)
        return find_x(x, T->left);
    else if (x > T->element)
        return find_x(x, T->right);
    else  
        return T;
}
Position find_min(BTree T)
{
    if(T == NULL)
        return NULL;
    if(T->left == NULL)
        return T;
    return find_min(T->left);
}
Position find_max(BTree T)
{
    if(T == NULL)
        return NULL;
    // BTree t = T;  T本就是参数
    while(T->right != NULL)
        T = T->right;
    return T;
}
// void insert_(element_type x, BTree &T)  // 传引用无需返回值  
BTree insert_(element_type x, BTree T)
{
    if(!T)
        T = new TreeNode(x, NULL, NULL);
    else if(x < T->element)
        T->left = insert_(x, T->left);  
    else if(x > T->element)
        T->right = insert_(x, T->right); 
    return T;
}
BTree delete_min(element_type x, BTree T)
{
    if(T->left == NULL)
    {
        BTree temp = T;
        T = T->right;
        free(temp);
    }
    else
        T->left = delete_min(x, T->left);
    return T;
}
BTree delete_(element_type x, BTree T)
{
    if(T == NULL)
    {
        printf("Not found.\n");
        return T;
    }
    else if (x < T->element)
        T->left = delete_(x, T->left);
    else if (x > T->element)
        T->right = delete_(x, T->right);
    else
    {
        if (T->left == NULL && T->right == NULL)    // case1: 0 child
        {
            // delete T;
            free(T);  // 释放堆中对象内存，此时T是一个悬空指针，仍有其地址
            T = NULL;
        }else if (T->left == NULL)    // case2: 1 child(right)
        {
            BTree temp = T;
            T = T->right;
            free(temp);
            
        }else if (T->right == NULL)   // case2: 1 child(left)
        {
            BTree temp = T;
            T = T->left;
            free(temp);
        }else                         // case3: 2 children 
        {
            BTree right_min = find_min(T->right);        // 找待删节点右子树最小值
            T->element = right_min->element;             // 替换待删节点
            T->right = delete_min(T->element, T->right); // 删除此最小值(最小值必无左孩子 --> case2)
            // T->right = delete_(T->element, T->right);  // 效率不高

            // 找待删节点左子树最大值同理
        }
        
    }
    return T;
}
void test()
{
    BTree root = NULL;
    root = insert_(5, root);         
    root = insert_(6, root);         
    root = insert_(2, root);         
    root = insert_(3, root);         
    root = insert_(1, root);
    pre_trav(root, 0);
    BTree x=NULL, mi=NULL, ma=NULL;
    if(x = find_x(3, root))
        cout << "find x " << x->element << endl;
    if(mi = find_min(root))
        cout << "find min e " << mi->element << endl;
    if(ma = find_max(root))
        cout << "find max e " << ma->element << endl;
    delete_(2, root);
    cout << "Sort: " << endl;
    in_trav(root);

}

int main(int argc, const char** argv) {
    test();
    return 0;
}
平衡查找数：AVL树

在BST基础上，AVL树要求左右子树高度差小于等于1，以使N节点树高度的界约为lgN。
同BST插入（删除），然后调整位置保持平衡，类似链表的插入等操作。
旋转（wiki图）：
旋转

struct TreeNode
{
    element_type element;
    TreeNode *left;
    TreeNode *right;
    int height;
    int bf;    // balance factor (方便)
    TreeNode(element_type e, TreeNode * l, TreeNode * r){
        element = e;
        left = l;
        right = r;
        height = bf = 0;
    }
};
typedef TreeNode *AVLTree;
typedef TreeNode *Position;

// update tree height and balance factor
void update_(AVLTree &T_ref)
{
    int left_h  = T_ref->left == NULL ? -1 : T_ref->left->height;    // 空树height = -1
    int right_h = T_ref->right == NULL ? -1 : T_ref->right->height;
    T_ref->height = max(left_h, right_h) + 1;
    T_ref->bf = left_h - right_h;  
}
AVLTree right_rotation(AVLTree root)
{
    AVLTree new_parent = root->left;    // pivote为新的父节点
    root->left = new_parent->right;     // B成为root的左孩子
    new_parent->right = root;           // root成为新父节点的右孩子

    update_(root);
    update_(new_parent);
    return new_parent;
}
AVLTree left_rotation(AVLTree root)
{                                        // 与右旋相反(左右互调)
    AVLTree new_parent = root->right;    // pivote为新的父节点
    root->right = new_parent->left;      // B成为root的右孩子
    new_parent->left = root;             // root成为新父节点的左孩子

    update_(root);
    update_(new_parent);
    return new_parent;
}
AVLTree left_left_case(AVLTree T)
{
    return right_rotation(T);
}
AVLTree left_right_case(AVLTree T)
{
    T->left = left_rotation(T->left);
    return left_left_case(T);
}
AVLTree right_right_case(AVLTree T)
{
    return left_rotation(T);
}
AVLTree right_left_case(AVLTree T)
{
    T->right = right_rotation(T->right);
    return right_right_case(T);
}
AVLTree balance(AVLTree T)
{
    if(T->bf == 2)     // left heavy 
    {
        if(T->left->bf >= 0)
            return left_left_case(T);
        else
            return left_right_case(T);
    }
    else if(T->bf == -2)  // right heavy 
    {
        if(T->right->bf <= 0)
            return right_right_case(T);
        else
            return right_left_case(T);
    }
    return T;
}
AVLTree insert_(element_type x, AVLTree T)
{
    if(!T)
        return new TreeNode(x, NULL, NULL);
    if(x < T->element)
        T->left = insert_(x, T->left);  
    else if(x > T->element)
        T->right = insert_(x, T->right); 
    else    // 处理重复
        return T;
    
    update_(T);

    return balance(T);
}

AVLTree delete_max(element_type x, AVLTree T)
{
    if(T->right == NULL)
    {
        AVLTree temp = T;
        T = T->left;
        free(temp);
    }
    else
        T->right = delete_max(x, T->right);
    return T;
}
AVLTree delete_(element_type x, AVLTree T)
{
    if(T == NULL)
    {
        printf("Not found.\n");
        return T;
    }
    else if (x < T->element)
        T->left = delete_(x, T->left);
    else if (x > T->element)
        T->right = delete_(x, T->right);
    else
    {
        if (T->left == NULL && T->right == NULL)    // case1: 0 child
        {
            free(T);
            // T = NULL;
            return NULL;    // 空指针不能到下面update / balance
        }else if (T->left == NULL)    // case2: 1 child(right)
        {
            AVLTree temp = T;
            T = T->right;
            free(temp);
        }else if (T->right == NULL)   // case2: 1 child(left)
        {
            AVLTree temp = T;
            T = T->left;
            free(temp);
        }else                         // case3: 2 children 
        {
            // 改进: x子树更高则在x子树替换、删除，以维持更平衡状态
            if(T->left->height < T->right->height)  
            {
                AVLTree right_min = find_min(T->right);      
                T->element = right_min->element;             
                T->right = delete_min(T->element, T->right); 
            }
            else
            {
                AVLTree left_max = find_max(T->left);      
                T->element = left_max->element;             
                T->left = delete_max(T->element, T->left); 
            }
            
        }
    }

    update_(T);

    return balance(T);
}
void test()
{
    srand((int)time(NULL));
    AVLTree root = NULL;
    int a[20];
    for (int i = 0; i < 20; i++)
    {
        a[i] = rand() % 100;
        root = insert_(a[i], root);   
    }
    pre_trav(root, 0);
    for (int i = 0; i < 5; i++)
    {
        printf("Delete %d\n", a[i]);
        delete_(a[i], root);
        pre_trav(root, 0);
    }
    
}

int main(int argc, const char** argv) {
    test();
    return 0;
}
eyedeng
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python决策树代码
10-12
决策树(Decision Tree）是在已知各种情况发生概率的基础上，通过构成决策树来求取净现值的期望值大于等于零的概率，评价项目风险，判断其可行性的决策分析方法，是直观运用概率分析的一种图解法。由于这种决策分支画...
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 170万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
小七的博客
01-18 19万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
Python樱花树
兔子王
04-24 6万+
Python樱花树以及樱花林代码。
数据结构：树(Tree)【详解】
UniqueUnit的博客
02-26 16万+
树 一、知识框架 二、考纲内容 树的基本概念 二叉树 二叉树的定义及其主要特征；二叉树的顺序存储结构和链式存储结构；二叉树的遍历；线索二叉树的基本概念和构造 树、森林 树的存储结构；森林与二叉树的转换；树和森林的遍历 树与二叉树的应用 二叉排序树；平衡二叉树；哈夫曼树和哈弗编码 三、树的基本概念 1、树的定义 树是n（n>=0）个结点的有限集。当n = 0时，称为空树。在任意一棵非空树中应满足： 有且仅有一个特定的称为根的结点。 当n>1时，其余节点可分为m（m>
【机器学习实战】3、决策树
呆呆的猫的博客
03-13 36万+
(声明：本文内容来自机器学习实战和统计学习方法，是两者的整合，并非来自单个书籍）决策树（decision tree）：是一种基本的分类与回归方法，此处主要讨论分类的决策树。在分类问题中，表示基于特征对实例进行分类的过程，可以认为是if-then的集合，也可以认为是定义在特征空间与类空间上的条件概率分布。决策树通常有三个步骤：特征选择、决策树的生成、决策树的修剪。用决策树分类：从根节点开始，对实例的某一特征进行测试，根据测试结果将实例分配到其子节点，此时每个子节点对应着该特征的一个取值，如此递归的对实例进行测
哈夫曼树（C语言实现）
2021dragon的博客
06-18 9万+
文章目录哈夫曼树的基本概念哈夫曼树的构建构建思路代码实现哈夫曼编码的生成编码生成思路代码实现完整代码展示以及代码测试 哈夫曼树的基本概念 在认识哈夫曼树之前，你必须知道以下几个基本术语： 1、什么是路径？  给定N个权值作为N个结点，构造一棵二叉树，若该树的带权路径长度达到最小，则称该二叉树为哈夫曼树，也被称为最优二叉树。 哈夫曼树的构建 构建思路 代码实现 哈夫曼编码的生成 编码生成思路 代码实现 完整代码展示以及代码测试 ...
哈夫曼树原理解析，构造方法，意义和作用。
Anakki的博客
08-05 29万+
哈夫曼树（最优二叉树） 百度百科：https://baike.baidu.com/item/%E5%93%88%E5%A4%AB%E6%9B%BC%E6%A0%91/2305769?fr=aladdin 一. 目的： 找出存放一串字符所需的最少的二进制编码 二. 构造方法： 首先统计出每种字符出现的频率！（也可以是概率）//权值 ----------------------------...
红黑树详解
lucyLee的博客
09-12 10万+
1. 概述 1.1 红黑树的引入 有了二叉搜索树，为什么还需要平衡二叉树？ 在学习二叉搜索树、平衡二叉树时，我们不止一次提到，二叉搜索树容易退化成一条链 这时，查找的时间复杂度从O(log2N)O(log_2N)O(log2​N)也将退化成O(N)O(N)O(N) 引入对左右子树高度差有限制的平衡二叉树，保证查找操作的最坏时间复杂度也为O(log2N)O(log_2N)O(log2​N) 有了平衡二叉树，为什么还需要红黑树？ AVL的左右子树高度差不能超过1，每次进行插入/删除操作时，几乎都需要通过旋
LSM树
艾斯-李的博客
06-26 3万+
关于LSM树 LSM树，即日志结构合并树(Log-Structured Merge-Tree)。其实它并不属于一个具体的数据结构，它更多是一种数据结构的设计思想。大多NoSQL数据库核心思想都是基于LSM来做的，只是具体的实现不同。所以本来不打算列入该系列，但是有朋友留言了好几次让我讲LSM树，那么就说一下LSM树。 LSM树诞生背景 传统关系型数据库使用btree或一些变体作为存储结构，能...
b+树详解
qq_45814695的博客
05-22 5万+
B树 与 B+树 我们今天要介绍的是工作开发中最常接触到的 InnoDB 存储引擎中的 B+ 树索引。要介绍 B+ 树索引，就不得不提二叉查找树，平衡二叉树和 B 树这三种数据结构。B+ 树就是从他们仨演化来的。 二叉查找树 首先，让我们先看一张图： 从图中可以看到，我们为 user 表（用户信息表）建立了一个二叉查找树的索引。 图中的圆为二叉查找树的节点，节点中存储了键（key）和数据（data）。键对应 user 表中的 id，数据对应 user 表中的行数据。 二叉查找树的特点就是任何节点的左子节点
B树和B+树
12-14
所有的值都是按照顺序存储，没有重复的元素，并且每个叶子节点到根节点的距离相同，B树的中间节点会存储数据指针信息，B树索引能够加快访问速度，是因为存储引擎不再需要全表扫描来获取数据。 B+树 B+树有重复的...
LabVIEW的树形
01-19
树形控件用于向用户提供一个可供选择的层次化列表。用户将输入树形控件的项组织为若干组项或若干组节点，单击节点旁边的展开符号可展开节点，显示该节点中的所有项。单击节点旁的符号还可折叠节点。树形控件为目录状...
多叉树的树形显示
04-09
多叉树，作为数据结构的一种，是树形结构的扩展，它允许每个节点有超过两个子节点，与二叉树（每个节点最多两个子节点）形成对比。本文将深入探讨多叉树的定义、特性、应用以及如何实现其树形显示。 首先，理解多叉...
探索哈希表：C++中的实现与操作详解【Map、Set、数据结构】
qq_22841387的博客
08-03 759
哈希表（Hash Table）是一种常见的数据结构，它提供了一种高效的键值对存储方式，能够快速进行插入、删除和查找操作。在这篇博客中，我们将详细介绍哈希表的概念、在C++中的实现方式以及常见操作的示例。哈希表是一种通过哈希函数将键映射到存储桶（Bucket）或槽（Slot）中的数据结构。其核心思想是使用哈希函数将键转换为数组的索引，从而能够在常数时间内（平均情况下）进行查找、插入和删除操作。哈希表是一种高效的数据结构，广泛应用于需要快速查找、插入和删除操作的场景中。在C++中，提供了便捷的哈希表实现。
数据结构系列文章目录
qq_31804097的博客
08-06 407
按章节顺序更新 望三连。
数据结构第九讲：二叉树
2301_79761834的博客
08-03 749
数据结构第九讲：二叉树
数据结构（邓俊辉）学习笔记】词典 03—— 排解冲突(1)
最新发布
weixin_44399845的博客
08-06 476
学习下词条的排解冲突方法
平衡搜索树详解：从二叉搜索树到红黑树
"这篇文档由小组成员张晓丹、徐兵兵、马喜刚和张稳龙共同讨论，主要介绍了平衡搜索树的概念，包括平衡二叉搜索树（AVL树）和红黑树，旨在解决二叉搜索树查找效率低下的问题。" 平衡搜索树是一种特殊的二叉树数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值