树形结构——二叉树类型

过客人间2023-08-04 20:05

本文主要介绍树形结构中的二叉树类型，包括二叉树、平衡二叉树、二叉查找树和完全二叉树；

1.二叉树

二叉树是一种树形结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树具有以下特点：

  1. 每个节点最多有两个子节点，分别为左子节点和右子节点。
  2. 左子节点的值小于或等于当前节点的值，而右子节点的值大于当前节点的值。这个特性使得二叉树在查找和排序方面有很大的应用价值。
  3. 二叉树可以为空树，此时没有节点。

二叉树可以用递归或迭代方式来遍历。常见的二叉树遍历方法包括：

  • 前序遍历（Preorder Traversal）：先访问根节点，再依次访问左子树和右子树。
  • 中序遍历（Inorder Traversal）：先访问左子树，再访问根节点，最后访问右子树。中序遍历的结果是有序的。
  • 后序遍历（Postorder Traversal）：先访问左子树，再访问右子树，最后访问根节点。
  • 层序遍历（Level Order Traversal）：按层级顺序从上到下逐层遍历，即先访问根节点，然后访问第二层的所有节点，接着访问第三层的所有节点，以此类推。

1.1 二叉树的创建

创建一个二叉树的类型

cpp 复制代码 
class TreeNode 
{
public:
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

class BinaryTree 
{
public:
    BinaryTree() : root(nullptr) {}

    ~BinaryTree(){}

    // 创建二叉树
    void createTree(int val) 
    {        
        root = createNode(val);     
    }

    // 创建新节点
    TreeNode* createNode(int val) 
    {
        if (val == -1) {
            return nullptr;
        } else {
            return new TreeNode(val);
        }
    }    
private:
    TreeNode* root;
};

1.2 二叉树元素的插入

通过递归插入新的元素，这里需要区分根节点是否空；

cpp 复制代码 
	// 插入节点
    void insert(int val) 
    {
        if (root == nullptr) {
            root = new TreeNode(val);
            return;
        }
        insertNode(root, val);
    }

    // 递归插入节点
    void insertNode(TreeNode* node, int val) 
    {
        if (val <= node->data) {
            if (node->left == nullptr) {
                node->left = new TreeNode(val);
            } else {
                insertNode(node->left, val);
            }
        } else {
            if (node->right == nullptr) {
                node->right = new TreeNode(val);
            } else {
                insertNode(node->right, val);
            }
        }
    }

1.3 二叉树的删除

二叉树的删除使用递归的思想

cpp 复制代码 
// 删除二叉树
    void deleteTree(TreeNode* node) 
    {
        if (node == nullptr) {
            return;
        }

        deleteTree(node->left);
        deleteTree(node->right);
        delete node;
    }

1.4 二叉树的遍历

二叉树的遍历分为前序遍历，中序遍历和后序遍历

cpp 复制代码 
	//二叉树的遍历------先序（先访问根节点）
    void preorderTraversal(TreeNode* root) 
    {
        if (root == nullptr) 
        {
            return;
        }

        // 访问根节点
        std::cout << root->data << " ";
        
        // 先序遍历左子树
        preorderTraversal(root->left);
        
        // 先序遍历右子树
        preorderTraversal(root->right);
    }

    //二叉树的遍历------中序（先访问左子树）
    void inorderTraversal(TreeNode* root) 
    {
        if (root == nullptr) 
        {
            return;
        }

        // 中序遍历左子树
        inorderTraversal(root->left);
        
        // 访问根节点
        std::cout << root->data << " ";
        
        // 中序遍历右子树
        inorderTraversal(root->right);
    }

    //二叉树的遍历------后序（先访问右子树）
    void postorderTraversal(TreeNode* root) 
    {
        if (root == nullptr) 
        {
            return;
        }

        // 后序遍历左子树
        postorderTraversal(root->left);
        
        // 后序遍历右子树
        postorderTraversal(root->right);
        
        // 访问根节点
        std::cout << root->data << " ";
    }

1.5 二叉树的判空

cpp 复制代码 
	 // 判断二叉树是否为空
    bool isEmpty() 
    {
        return root == nullptr;
    }

1.6 二叉树的大小计算和深度计算

二叉树的大小计算指的是树形结构中有多少个元素；

二叉树的深度计算指的是树形结构中有多少层；

cpp 复制代码 
	// 获取二叉树的深度
    int getTreeDepth(TreeNode* root) 
    {
        if (root == nullptr) 
        {
            return 0;
        }

        int leftDepth = getTreeDepth(root->left);
        int rightDepth = getTreeDepth(root->right);

        return std::max(leftDepth, rightDepth) + 1;
    }

    int getTreeSize(TreeNode* root)
    {
        int re= 0;
        //tree为空的时候
        if(root == nullptr){
            return re;
        }

        int left_size = getTreeSize(root->left);
        int right_size = getTreeSize(root->right);

        re = left_size + right_size + 1;
        return re;
    }

1.7 二叉树的查找

查找某一个元素是否在二叉树中，如果存在则返回true，不存在则返回false

cpp 复制代码 
	// 查询节点值是否存在于二叉树中
    bool search(int val) 
    {
        return searchNode(root, val);
    }

    // 递归查询节点值是否存在于二叉树中
    bool searchNode(TreeNode* node, int val) 
    {
        if (node == nullptr) {
            return false;
        }

        if (node->data == val) {
            return true;
        }

        return searchNode(node->left, val) || searchNode(node->right, val);
    }

	TreeNode* getRootValue()
    {
        return root;
    }

二叉树的使用

2.平衡二叉树（AVL树）

平衡二叉树是一种特殊的二叉树，它的左子树和右子树的高度差不超过1，并且左子树和右子树也都是平衡二叉树。平衡二叉树的设计目的是为了保持树的平衡，提高查找、插入和删除操作的效率，避免出现退化成链表的情况。实现一个平衡二叉树可以使用各种方法，最常用的是AVL树和红黑树。这些方法都通过旋转、重新平衡等操作来保持树的平衡性。在插入或删除节点时，需要根据树的平衡性进行相应调整，以保证树仍然是平衡的。平衡二叉树的平衡性可以确保树上的操作的时间复杂度为O(log n)，提供了高效的数据访问和操作能力。

平衡二叉树与二叉树相比，在元素插入的时候需要根据平衡因子，进行左旋操作或者右旋操作；

2.1 平衡二叉树的结构

cpp 复制代码 
class TreeNode 
{
public:
    int val;
    int height;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int x) : val(x), height(1), left(nullptr), right(nullptr) {}
};

2.3 获取平衡因子

这里的平衡因子指的是左子树和右子树的高度差值

cpp 复制代码 
    // 获取节点的平衡因子
    int getBalanceFactor(TreeNode* node) 
    {
        if (node == nullptr) 
        {
            return 0;
        }
        return getHeight(node->left) - getHeight(node->right);
    }

	// 获取节点的高度
    int getHeight(TreeNode* node) 
    {
        if (node == nullptr) 
        {
            return 0;
        }
        return node->height;
    }

    // 更新节点的高度
    void updateHeight(TreeNode* node) 
    {
        node->height = std::max(getHeight(node->left), getHeight(node->right)) + 1;
    }

2.2 左旋操作和右旋操作

左旋操作和右旋操作是为了调整树形结构的高度；

cpp 复制代码 
	// 右旋操作，根节点
    TreeNode* rotateRight(TreeNode* y) 
    {
        TreeNode* x = y->left;
        TreeNode* T2 = x->right;

        x->right = y;
        y->left = T2;
        
        updateHeight(y);
        updateHeight(x);

        return x;
    }

    // 左旋操作，根节点
    TreeNode* rotateLeft(TreeNode* x) 
    {
        TreeNode* y = x->right;
        TreeNode* T2 = y->left;

        y->left = x;
        x->right = T2;

        updateHeight(x);
        updateHeight(y);

        return y;
    }

2.3 元素的插入

在每一个元素插入的时候，都需要根据平衡因子来判断是否需要进行左旋和右旋的操作；

cpp 复制代码 
void insert(int val)
    {
        if (root == nullptr) {
            root =  new TreeNode(val);
            return;
        }
        root = insertNode(root, val);        
    }

    // 插入节点
    TreeNode* insertNode(TreeNode* node, int val) 
    {        
        if (val < node->val) {
            if(node->left == nullptr ) {
                node->left = new TreeNode(val);
            }
            else{
                node->left = insertNode(node->left, val);
            }            
        } else if (val > node->val) {
            if(node->right == nullptr){
                node->right = new TreeNode(val);
            }
            else{
                node->right = insertNode(node->right, val);
            }
            
        } else {
            std::cout<<"same data!"<<std::endl;            
            return node;
        }

        updateHeight(node);
        
        int balanceFactor = getBalanceFactor(node);        
        
        if(node->left != nullptr)
        {
            // Left-Left case
            if (balanceFactor > 1 && val < node->left->val) {
               return rotateRight(node);
            }

            // Left-Right case
            if (balanceFactor > 1 && val > node->left->val) {
                node->left = rotateLeft(node->left);
                return rotateRight(node);
            }            
        }

        
        if(node->right != nullptr){        
            // Right-Right case
            if (balanceFactor < -1 && val > node->right->val) {
                return rotateLeft(node);
            }
            
            // Right-Left case
            if (balanceFactor < -1 && val < node->right->val) {
                node->right = rotateRight(node->right);
                return rotateLeft(node);
            }        
        }

        return node;
        
    }

3.二叉查找树（BST）

二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树，它满足以下条件：

  1. 对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值。
  2. 对于树中的每个节点，其右子树中的所有节点的值都大于该节点的值。
  3. 对于树中的每个节点，其左子树和右子树都是二叉查找树。

因此，二叉查找树具有以下特点：

  1. 左子节点的值小于父节点的值，右子节点的值大于父节点的值。
  2. 中序遍历二叉查找树得到的值序列是递增有序的。
  3. 可以快速插入、删除和查找节点。

4.完全二叉树

完全二叉树（Complete Binary Tree）是一种特殊类型的二叉树，在完全二叉树中，除了最后一层，其他层的节点都是满的，且最后一层的节点尽可能地靠左排列。

具体来说，完全二叉树的定义如下：

  1. 如果一个二叉树的高度为h（h >= 0），并且它的节点从第 1 层到第 h-1 层都是满的，第 h 层的节点都连续地排列在最左边若干位置上，那么这棵二叉树就是完全二叉树。
  2. 如果一个完全二叉树的最后一层有缺失节点，则缺失节点只能集中在层末尾的若干位置上，并且缺失的节点都是从左到右依次缺失的（即不会出现在中间位置缺失）。

完全二叉树主要涉及到元素的插入

cpp 复制代码 
void insert(int value) {
    Node* newNode = new Node(value);

	// root是根节点
    if (root == nullptr) {
        root = newNode;
        return;
    }

    std::queue<Node*> q;
    q.push(root);

    while (!q.empty()) {
        Node* front = q.front();
        q.pop();   //删除队首元素

        if (front->left == nullptr) {
            front->left = newNode;
            return;
        } else if (front->right == nullptr) {
            front->right = newNode;
            return;
        }

        q.push(front->left);   
        q.push(front->right);
    }
}
相关推荐
唐诺4 小时前
几种广泛使用的 C++ 编译器
c++·编译器
XH华4 小时前
初识C语言之二维数组(下)
c语言·算法
南宫生4 小时前
力扣-图论-17【算法学习day.67】
java·学习·算法·leetcode·图论
不想当程序猿_5 小时前
【蓝桥杯每日一题】求和——前缀和
算法·前缀和·蓝桥杯
落魄君子5 小时前
GA-BP分类-遗传算法（Genetic Algorithm）和反向传播算法（Backpropagation）
算法·分类·数据挖掘
冷眼看人间恩怨5 小时前
【Qt笔记】QDockWidget控件详解
c++·笔记·qt·qdockwidget
菜鸡中的奋斗鸡→挣扎鸡5 小时前
滑动窗口 + 算法复习
数据结构·算法
红龙创客5 小时前
某狐畅游24校招-C++开发岗笔试（单选题）
开发语言·c++
Lenyiin5 小时前
第146场双周赛：统计符合条件长度为3的子数组数目、统计异或值为给定值的路径数目、判断网格图能否被切割成块、唯一中间众数子序列 Ⅰ
c++·算法·leetcode·周赛·lenyiin
郭wes代码5 小时前
Cmd命令大全（万字详细版）
python·算法·小程序
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程