手写平衡二叉树

最新推荐文章于 2025-05-26 15:53:25 发布
最新推荐文章于 2025-05-26 15:53:25 发布
阅读量163 收藏
点赞数
文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chenmi123321/article/details/130877596
版权

构造一个平衡二叉树，AVL Tree

参考代码一：

#include<iostream>

using namespace std;

class AVLTree{
    struct Node{
        int data;
        Node *left;
        Node *right;
        int height;
        Node(int v):data(v),left(NULL),right(NULL),height(1){}
    };
    Node *root;
    int height(Node *node);
    Node* RR(Node *root);
    Node* LL(Node *root);
    Node* LR(Node *root);
    Node* RL(Node *root);
    Node *insert(Node *node,int value);
    void inorder(Node *node);

public:
    AVLTree():root(NULL){}
    void insert(int value);
    void inorder();
};

int AVLTree::height(Node *node){
    if(node==NULL)
        return 0;
    return node->height;
}

AVLTree::Node* AVLTree::RR(Node *root){
    Node *newRoot = root->right;
    root->right = newRoot->left;
    newRoot->left = root;
    root->height = max(height(root->left),height(root->right))+1;
    newRoot->height = max(height(newRoot->left),height(newRoot->right))+1;
    return newRoot;
}

AVLTree::Node* AVLTree::LL(Node *root){
    Node *newRoot = root->left;
    root->left = newRoot->right;
    newRoot->right = root;
    root->height = max(height(root->left),height(root->right))+1;
    newRoot->height = max(height(newRoot->left),height(newRoot->right))+1;
    return newRoot;
}

AVLTree::Node* AVLTree::LR(Node *root){
    root->left = RR(root->left);
    root = LL(root);
    return root;
}

AVLTree::Node* AVLTree::RL(Node *root){
    root->right = LL(root->right);
    root = RR(root);
    return root;
}

AVLTree::Node* AVLTree::insert(Node *node,int value){
    if(node == NULL)
        return new Node(value);
    if(value < node->data)
        node->left = insert(node->left,value);
    else
        node->right = insert(node->right,value);

    int balanceFactor = height(node->left)-height(node->right);

    if(balanceFactor > 1 && value < node->left->data)
        return LL(node);
    if(balanceFactor > 1 && value > node->left->data)
        return LR(node);
    if(balanceFactor < -1 && value > node->right->data)
        return RR(node);
    if(balanceFactor < -1 && value < node->right->data)
        return RL(node);

    node->height = max(height(node->left),height(node->right))+1;
    return node;
}

void AVLTree::insert(int value){
    root = insert(root,value);
}

void AVLTree::inorder(){
    inorder(root);
}

void AVLTree::inorder(Node *node){
    if(node == NULL)
        return;
    inorder(node->left);
    cout<<node->data<<" ";
    inorder(node->right);
}

int main(){
    AVLTree t;
    cout << "二叉树插入节点:" << endl;
    t.insert(10);
    t.insert(20);
    t.insert(30);
    t.insert(40);
    t.insert(50);
    t.insert(25);
    cout << "中序遍历二叉树:" << endl;
    t.inorder();
    return 0;
}
//输出:
二叉树插入节点:
中序遍历二叉树:   
10 20 25 30 40 50

参考代码二：

#include <iostream>

using namespace std;

class Node {
public:
    int key;
    Node* left;
    Node* right;
    int height;
};

int max(int a, int b);

int height(Node* node) {
    if (node == NULL)
        return 0;
    return node->height;
}

int max(int a, int b) {
    return (a > b) ? a : b;
}

Node* newNode(int key) {
    Node* node = new Node();
    node->key = key;
    node->left = NULL;
    node->right = NULL;
    node->height = 1;
    return(node);
}

Node *rightRotate(Node *y) {
    Node *x = y->left;
    Node *T2 = x->right;

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

    y->height = max(height(y->left), height(y->right)) + 1;
    x->height = max(height(x->left), height(x->right)) + 1;

    return x;
}

Node *leftRotate(Node *x) {
    Node *y = x->right;
    Node *T2 = y->left;

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

    x->height = max(height(x->left), height(x->right)) + 1;
    y->height = max(height(y->left), height(y->right)) + 1;

    return y;
}

int getBalance(Node *node) {
    if (node == NULL)
        return 0;
    return height(node->left) - height(node->right);
}

Node* insert(Node* node, int key) {
    if (node == NULL)
        return(newNode(key));

    if (key < node->key)
        node->left = insert(node->left, key);
    else if (key > node->key)
        node->right = insert(node->right, key);
    else
        return node;

    node->height = 1 + max(height(node->left),
                           height(node->right));

    int balance = getBalance(node);

    if (balance > 1 && key < node->left->key)
        return rightRotate(node);

    if (balance < -1 && key > node->right->key)
        return leftRotate(node);

    if (balance > 1 && key > node->left->key) {
        node->left = leftRotate(node->left);
        return rightRotate(node);
    }

    if (balance < -1 && key < node->right->key) {
        node->right = rightRotate(node->right);
        return leftRotate(node);
    }

    return node;
}

void preOrder(Node *root) {
    if(root != NULL) {
        cout << root->key << " ";
        preOrder(root->left);
        preOrder(root->right);
    }
}

int main() {
    Node *root = NULL;
    cout << "二叉树插入节点:" << endl;
    root = insert(root, 10);
    root = insert(root, 20);
    root = insert(root, 30);
    root = insert(root, 40);
    root = insert(root, 50);
    root = insert(root, 25);

    cout << "Preorder traversal of the "
            "constructed AVL tree is \n";
    
    cout << "前序遍历二叉树:" << endl;
    preOrder(root);

    return 0;
}
//输出:
二叉树插入节点:
Preorder traversal of the constructed AVL tree is 
前序遍历二叉树:
30 20 10 25 40 50

在这个实现中，Node 类表示二叉平衡树的节点。每个节点包含一个 key 值，一个指向左子树的指针 left，一个指向右子树的指针 right，以及一个表示该节点的高度 height。

max 函数返回两个数中的最大值，height 函数返回给定节点的高度。newNode 函数创建一个新的具有给定 key 值的节点，并将其左右子树和高度初始化为 NULL。

参考代码三：

#include<iostream>
#include<bits/stdc++.h>
using namespace std;

struct Node {
    int val;
    Node *left, *right;
    int height;
};

Node* newNode(int val) {
    Node* node = new Node();
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    node->height = 1; // 新节点高度为1
    return(node);
}

int height(Node* node) {
    if (node == NULL)
        return 0;
    return node->height;
}

// 右旋操作
Node* rightRotate(Node* y) {
    Node* x = y->left;
    Node* T2 = x->right;
    x->right = y;
    y->left = T2;

    // 更新高度
    y->height = max(height(y->left), height(y->right)) + 1;
    x->height = max(height(x->left), height(x->right)) + 1;

    return x;
}

// 左旋操作
Node* leftRotate(Node* x) {
    Node* y = x->right;
    Node* T2 = y->left;
    y->left = x;
    x->right = T2;

    // 更新高度
    x->height = max(height(x->left), height(x->right)) + 1;
    y->height = max(height(y->left), height(y->right)) + 1;

    return y;
}

// 获取节点的平衡因子
int getBalance(Node* node) {
    if (node == NULL)
        return 0;
    return height(node->left) - height(node->right);
}

// 插入节点
Node* insert(Node* node, int val) {
    if (node == NULL)
        return (newNode(val));

    if (val < node->val)
        node->left = insert(node->left, val);
    else if (val > node->val)
        node->right = insert(node->right, val);
    else // 重复值不插入
        return node;

    // 更新高度
    node->height = max(height(node->left), height(node->right)) + 1;

    int balance = getBalance(node);

    // 平衡维护
    if (balance > 1 && val < node->left->val)
        return rightRotate(node);

    if (balance < -1 && val > node->right->val)
        return leftRotate(node);

    if (balance > 1 && val > node->left->val) {
        node->left = leftRotate(node->left);
        return rightRotate(node);
    }

    if (balance < -1 && val < node->right->val) {
        node->right = rightRotate(node->right);
        return leftRotate(node);
    }

    return node;
}

// 中序遍历
void inOrder(Node* root) {
    if (root != NULL) {
        inOrder(root->left);
        cout << root->val << " ";
        inOrder(root->right);
    }
}

int main() {
    Node* root = NULL;

    /* 示例如下：
         10
        / \
       20  30
      / \
     40 50
    */
    root = insert(root, 10);
    root = insert(root, 20);
    root = insert(root, 30);
    root = insert(root, 40);
    root = insert(root, 50);

    cout << "中序遍历结果：";
    inOrder(root);

    return 0;
}
//输出:
中序遍历结果：10 20 30 40 50

参考代码四：

#include <iostream>
using namespace std;

struct Node {
    int data;
    Node* left;
    Node* right;
    int height; // 节点高度
};

class AVLTree {
public:
    Node* root;

    AVLTree() {
        root = NULL;
    }

    // 计算节点高度
    int height(Node* node) {
        if (node == NULL) return 0;
        return node->height;
    }

    // 计算节点平衡因子
    int balanceFactor(Node* node) {
        if (node == NULL) return 0;
        return height(node->left) - height(node->right);
    }

    // 左旋转
    Node* leftRotate(Node* node) {
        Node* newRoot = node->right;
        node->right = newRoot->left;
        newRoot->left = node;
        // 更新节点高度
        node->height = max(height(node->left), height(node->right)) + 1;
        newRoot->height = max(height(newRoot->left), height(newRoot->right)) + 1;
        return newRoot;
    }

    // 右旋转
    Node* rightRotate(Node* node) {
        Node* newRoot = node->left;
        node->left = newRoot->right;
        newRoot->right = node;
        // 更新节点高度
        node->height = max(height(node->left), height(node->right)) + 1;
        newRoot->height = max(height(newRoot->left), height(newRoot->right)) + 1;
        return newRoot;
    }

    // 插入节点
    Node* insertNode(Node* node, int data) {
        if (node == NULL) {
            node = new Node;
            node->data = data;
            node->left = NULL;
            node->right = NULL;
            node->height = 1;
        } else if (data < node->data) {
            node->left = insertNode(node->left, data);
        } else if (data > node->data) {
            node->right = insertNode(node->right, data);
        }
        // 更新节点高度
        node->height = max(height(node->left), height(node->right)) + 1;
        // 计算平衡因子
        int balance = balanceFactor(node);
        // 左旋转
        if (balance > 1 && data < node->left->data) {
            return rightRotate(node);
        }
        // 右旋转
        if (balance < -1 && data > node->right->data) {
            return leftRotate(node);
        }
        // 左右双旋转
        if (balance > 1 && data > node->left->data) {
            node->left = leftRotate(node->left);
            return rightRotate(node);
        }
        // 右左双旋转
        if (balance < -1 && data < node->right->data) {
            node->right = rightRotate(node->right);
            return leftRotate(node);
        }
        return node;
    }

    // 中序遍历
    void inorderTraversal(Node* node) {
        if (node == NULL) return;
        inorderTraversal(node->left);
        cout << node->data << " ";
        inorderTraversal(node->right);
    }
};

int main() {
    AVLTree tree;
    tree.root = tree.insertNode(tree.root, 10);
    tree.root = tree.insertNode(tree.root, 20);
    tree.root = tree.insertNode(tree.root, 30);
    tree.root = tree.insertNode(tree.root, 40);
    tree.root = tree.insertNode(tree.root, 50);
    tree.root = tree.insertNode(tree.root, 25);

    cout << "AVL树中序遍历结果：" << endl;
    tree.inorderTraversal(tree.root);
    cout << endl;

    return 0;
}
//输出:
AVL树中序遍历结果：
10 20 25 30 40 50

参考代码五：

#include <iostream>

using namespace std;

// 节点结构体
struct Node {
    int val;
    int height;
    Node* left;
    Node* right;
    Node(int v):val(v), height(1), left(nullptr), right(nullptr) {}
};

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

// 获取节点平衡因子
int getBalanceFactor(Node* node) {
    if (node == nullptr) return 0;
    return getHeight(node->left) - getHeight(node->right);
}

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

// 左旋操作
Node* leftRotate(Node* node) {
    Node* newRoot = node->right;
    node->right = newRoot->left;
    newRoot->left = node;

    updateHeight(node);
    updateHeight(newRoot);

    return newRoot;
}

// 右旋操作
Node* rightRotate(Node* node) {
    Node* newRoot = node->left;
    node->left = newRoot->right;
    newRoot->right = node;

    updateHeight(node);
    updateHeight(newRoot);

    return newRoot;
}

// 插入操作
Node* insert(Node* root, int v) {
    if (root == nullptr) {
        return new Node(v);
    }

    if (v < root->val) {
        root->left = insert(root->left, v);
    } else {
        root->right = insert(root->right, v);
    }

    updateHeight(root);

    int bf = getBalanceFactor(root);
    if (bf > 1 && getBalanceFactor(root->left) >= 0) {
        return rightRotate(root);
    }
    if (bf > 1 && getBalanceFactor(root->left) < 0) {
        root->left = leftRotate(root->left);
        return rightRotate(root);
    }
    if (bf < -1 && getBalanceFactor(root->right) <= 0) {
        return leftRotate(root);
    }
    if (bf < -1 && getBalanceFactor(root->right) > 0) {
        root->right = rightRotate(root->right);
        return leftRotate(root);
    }

    return root;
}

// 中序遍历
void inorderTraversal(Node* root) {
    if (root == nullptr) return;
    inorderTraversal(root->left);
    cout << root->val << " ";
    inorderTraversal(root->right);
}

int main() {
    Node* root = nullptr;

    // 插入操作
    root = insert(root, 10);
    root = insert(root, 20);
    root = insert(root, 30);
    root = insert(root, 40);
    root = insert(root, 50);
    root = insert(root, 25);

    // 中序遍历
    cout << "中序遍历结果: " << endl;
    inorderTraversal(root);
    
    return 0;
}

//输出:
中序遍历结果: 
10 20 25 30 40 50

该程序实现了二叉平衡树的插入和中序遍历操作。在每次插入节点时，都会检查当前子树是否平衡，并进行相应的旋转操作以维持平衡

java进阶篇--红黑树和平衡二叉树有什么区别？
爱分享的淘金达人
06-22 3871
数据结构属于理解一些源码和技术所必备的知识，比如要读懂 Java 语言中 TreeMap 和 TreeSet 的源码就要懂红黑树的数据结构，不然是无法理解源码中关于红黑树数据的操作代码的，比如左旋、右旋、添加和删除操作等。因此本课时我们就来学习一下数据结构的基础知识，方便看懂源码或者是防止面试中被问到。 我们本课时的面试题是，红黑树和二叉树有什么区别？ 回答： 要回答这个问题之前，我们先要弄清什么是二叉树？什么是红黑树？ 二叉树（Binary Tree）是指每个节点最多只有两个分支的树结构，即不存在
c语言平衡二叉树,c语言手写平衡二叉树（一）
weixin_35126480的博客
05-19 165
点击蓝字之后，我们就是好朋友了啦 定义结构体struct Person{//父节点struct Person* parent;//左子节点struct Person* lchild;//右子节点struct Person* rchild;int m;};struct ABLtree{//保存根节点信息struct Person* root;};初始化根节点struct ABLtree...
手写平衡二叉树（二）
z912662880的博客
04-21 328
删除数据 struct Person* removes(struct Person* p,struct Person*data,int(*compare)(struct Person* p1,struct Person* p2)) { //判断参数是否为空，为空返回传入的参数 if (NULL == p) { return p; } if (NULL == data) { ret...
手写平衡二叉树 (AVL树)
chenmi123321的博客
02-11 212
下面是一个完整的C++实现手写平衡二叉树（AVL树）的代码。AVL树是一种自平衡二叉搜索树，其中每个节点的左右子树高度差不超过1。
C语言平衡二叉树csdn,c语言 手写平衡二叉树（一）
weixin_36384501的博客
05-20 103
定义结构体struct Person{//父节点struct Person* parent;//左子节点struct Person* lchild;//右子节点struct Person* rchild;int m;};struct ABLtree{//保存根节点信息struct Person* root;};初始化根节点struct ABLtree* init_tree(){//在堆区开辟一个A...
c语言手写平衡二叉树非递归实现
z912662880的博客
04-22 314
有了递归实现为啥还要用非递归呢？你会不会有疑惑？如果有，请接着看。 函数的调用需要用到栈，一个应用分配到的栈空间一般为1M大小，在数据很大的情况会造成栈溢出，所以要少用递归。 不用递归实现的原理是模拟栈的运行机制------先进后出，如果这个不会的话，可以看我写的数组模拟栈（现在还没写）。 头文件 #ifdef __cplusplus extern "C" { #endif #define _C...
c语言手写平衡二叉树（一）
z912662880的博客
04-21 323
定义结构体 struct Person { //父节点 struct Person* parent; //左子节点 struct Person* lchild; //右子节点 struct Person* rchild; int m; }; struct ABLtree {//保存根节点信息 struct Person* root; }; 初始化根节点 struct ABLtre...
平衡二叉树(java)
一起coding，一起嗨。
12-25 1574
平衡二叉树也叫平衡二叉搜索树 (Self-balancingbinarysearch tree) 又被称为AVL树，可以保证查询效率较高。具有以下特点:它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1.并且左右两个子树都是一棵平衡二叉树。
平衡二叉树（附自己写的源码）
多方通行8的博客
12-16 237
如果不平衡 用旋转（不平衡变平衡） 设置高度。就好像担当子，要左右平衡才好担，二叉树同样如此，要左右平滑才好查找。第三种：（左右旋）先以当前节点（10）左旋，然后以当前节点的父节点（11）为轴右旋。第四种：（右左旋）先以当前节点（10）左旋，然后以当前节点的父节点（11）为轴右旋。树中每一个节点左右孩子的高度差不超过1的有序二叉树（左右孩子的高度差）看如图：我们要查找最下方的1，左边和右边各要查找的次数是多少？（查找数据的高度）如：根为1，根孩子：2，根孩子的孩子：3。为什么学习平衡二叉树？
平衡二叉树 java_面试官让我手写一个平衡二叉树，我当时就笑了（java代码实现）...
weixin_34732602的博客
02-12 308
平衡二叉树对于初学者一直是一个比较复杂的知识点，因为其里面涉及到了大量的旋转操作。把大量的同学都给转晕了。这篇文章最主要的特点就是通过动画的形式演示。确保大家都能看懂。最后是手写一个平衡二叉树。一、概念平衡二叉树是外国的两个大爷发明的。一开始发明的是二叉查找树。后来觉得不给力演化成了平衡二叉树。那什么是二叉查找树呢？我们给出一张图来看看：看到这张图我们就会发现如下的特征。从每个节点出发，左边的节点...
平衡二叉树-精简.cpp
04-09
个人手写的平衡二叉树。仅供参考，可以直接运行。
数据结构与算法（三） 03-平衡二叉树及二叉树的经典题型
一只蒻蒻的博客
01-08 902
平衡二叉树、二叉树的经典题 1 平衡二叉树 题目 输入一棵二叉树，判断该二叉树是否是平衡二叉树。 平衡二叉树：每个子树的深度之差不超过1 思路 后续遍历二叉树，在遍历二叉树每个节点前都会遍历其左右子树 比较左右子树的深度，若差值>1则返回一个标记-1表示当前子树不平衡 若左右子树存在一个不平衡或左右子树差值大于1，则整棵树不平衡 若左右子树平衡，则返回当前树深：左右子树最大深度+1 代码 function IsBalanced_Solution(pRoot) { retur
剑指 offer代码解析——面试题39判断平衡二叉树(高效方法)
大闲人柴毛毛
04-02 2596
题目：输入一颗二叉树的根结点，判断该树是不是平衡二叉树。 如果某二叉树中任意结点的左右子树的高度相差不超过1，那么它就是一棵平衡二叉树。 分析：所谓平衡二叉树就是要确保每个结点的左子树与右子树的高度差在－1到1之间。 由于之前一题已经给出了二叉树高度的计算方法，因此本题最直观的思路就是分别计算每个结点的左子树高和右子树高，从而判断一棵树的所有结点是否均为平衡二
Redis7 新增数据结构深度解析：ListPack 的革新与优化
希望我的博客，能帮上你解决学习中工作中所遇到的问题,也期待与您一起探讨技术问题，共同成长。
05-23 830
Redis 7.0引入了ListPack作为新一代序列化格式，替代了传统的ZipList，成为字符串、哈希、有序集合等数据类型的底层存储引擎。ListPack通过扁平化内存布局、高效的增删操作、优化的遍历机制和兼容性设计，显著提升了内存效率和访问速度。
【数据结构 -- AVL树】用golang实现AVL树
2401_87046050的博客
05-20 1120
什么是AVL树，AVL树的思想，以及如何用go语言实现AVL树
探索数据结构之顺序表：从入门到精通
PythonHTML8的博客
05-26 1133
通过本文的深入浅出的讲解，我们一同探索了顺序表的定义、结构、各种操作的实现及其背后的时间复杂度，还细致剖析了它的优缺点。从高效便捷的随机访问，到在特定场景下略显繁琐的插入删除，顺序表的特性如同一把双刃剑，在不同的应用场景中发挥着独特的作用。接着，从插入位置开始，将之后的所有元素向后移动一位，然后将新元素插入到指定位置，并更新顺序表的大小。顺序表的物理结构采用数组来实现，数组的每个位置对应一个元素。在最坏情况下，插入位置为顺序表的开头，需要移动所有元素，时间复杂度为 O(n)，其中 n 为顺序表的大小。
数据结构第1章编程基础 （竟成）
丰锋的博客
05-23 1155
因为数据结构的代码大多采用 C 语言进行描述。而且，408 考试每年都有一道分值为 13 - 15 的编程题，要求使用 C/C++ 语言编写代码。所以，本书专门用一章来介绍 408 考试所需的 C/C++ 基础知识。有基础的考生可以快速浏览或者跳过本章。想要深入了解 C/C++ 语言的考生，可以参考其他专业书籍。指针变量简称指针。指针变量与 int、float 等变量略有不同。指针变量存储的不是变量的值，而是变量对应的地址，即指针变量是用来存放地址的变量。
数据结构第4章 栈、队列和数组 （竟成）
最新发布
丰锋的博客
05-26 785
初始时 top 为 - 1，则第一个元素入栈后，top 为 0，即指向栈顶元素，故入栈是应先将指针 top 加 1，再将元素入栈，所以 C 正确。【解析】 栈1从V[1]往上增长，栈2从V[m]往下增长，则栈满时栈顶指针会在中间相遇，有些考生会误选D，对于D这种情况，若栈顶指针指向栈顶元素，则在top[1]==top[2]时，两个栈顶元素的位置重合了，若栈顶指针指向栈顶元素的后一个元素，则在top[1]==top[2]时，空了一个位置没有元素，因此D错误。如图4.9所示，元素在队尾入队，在队头出队。
手写二叉树源代码详解
二叉树的形态可以是完全二叉树、满二叉树、平衡二叉树、二叉搜索树等多种，它们各自具有不同的性质和应用场景。 在编程领域，二叉树是一种重要的数据结构，广泛用于实现查找表、排序、表达式解析等算法。例如，二叉...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值