四、高级数据结构和算法：二叉搜索树（BST树）、平衡二叉树（AVL树）

已于 2022-06-20 09:53:28 修改
阅读量348 收藏 1
点赞数
分类专栏： 高级数据结构和算法 文章标签： 数据结构 算法 c++ linux
于 2022-06-18 09:24:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42488216/article/details/125329199
版权

4 二叉查找树（BST树）、平衡二叉树（AVL树）

4.1 二叉查找树（BST树）

二叉查找树(Binary Search Tree, BST)，又被称为二叉搜索树
在这里插入图片描述

4.1.1 特点

（1）若节点的左子树不空, 则左子树上所有节点的key均小于它的根节点的key
（2）若节点的右子树不空, 则右子树上所有节点的key均大于它的根节点的key
（3）任意节点的左,右子树也分别为二叉查找树
（4）没有key相等的节点

二叉查找树进行中序遍历，可以得到一个递增的有序序列
在这里插入图片描述

  • 实例
#include <iostream>
using namespace std;
class Node{
public:
    char val;
    Node* left;
    Node* right;
    Node(char val):val(val),left(nullptr),right(nullptr){}
    Node(char val,Node* left,Node* right):val(val),left(left),right(right){}
};
class BSTtree{
private:
    Node* m_root = nullptr;
    void inorder(Node* root){
    	if(nullptr == root) return;
		inorder(root->left);
		cout << root->val << " ";
		inorder(root->right);
    }
    Node* Insert(Node* root,char val){
    	if(nullptr ==  root) return new Node(val);
		if(root->val > val){
	    	root->left = Insert(root->left,val);
		}else{
	   		root->right = Insert(root->right,val);
		}
		return root;
    }
public:
    void Insert(char val){
		m_root = Insert(m_root,val);
    }
    void Print(){
    	inorder(m_root);//二叉查找树进行中序遍历，可以得到一个递增的有序序列
		cout << endl;
    }
};
int main(){
    BSTtree root;
    root.Insert('T');
    root.Insert('E');
    root.Insert('B');
    root.Insert('F');
    root.Insert('Y');
    root.Insert('X');
    root.Insert('Z');
    
    root.Print();
}

树的结构：
在这里插入图片描述

结果：B E F T X Y Z
分析：递增序列

4.1.2 结构

二叉搜索树通常使用链式存储孩子表示法。

class Node{
public:
    char val;
    Node* left;
    Node* right;
    Node(char val):val(val),left(nullptr),right(nullptr){}
    Node(char val,Node* left,Node* right):val(val),left(left),right(right){}
};

4.1.3 操作（插入、查找和删除）

4.1.3.1 插入
  • 步骤
    （1）如果二叉查找树为空，则直接插入。
    （2）如果插入节点key小于根结点key，则插入到左子树中；大于根结点key，则插入到右子树中。
    （3）依次类推，直到找到插入位置。
    在这里插入图片描述
  • 实例
#include <iostream>
using namespace std;
template <typename T> 
class _Node{
public:
    T val;
    _Node* left;
    _Node* right;
    _Node(T val):val(val),left(nullptr),right(nullptr){}
    _Node(T val,_Node* left,_Node* right):val(val),left(left),right(right){}
};
template <typename T>
class BSTtree{
private:
    typedef _Node<T> Node;
    Node* m_root = nullptr;
    void inorder(Node* root){
    	if(nullptr == root) return;
		inorder(root->left);
		cout << root->val << " ";
		inorder(root->right);
    }
    void preorder(const Node* root){
    	if(nullptr == root) return;
    	if(root->left) cout << root->val << "--" << root->left->val << endl;
    	if(root->right) cout << root->val << "--" << root->right->val << endl;
    	preorder(root->left);
    	preorder(root->right);
    }
    Node* Insert(Node* root,T val){
    	if(nullptr ==  root) return new Node(val);
		if(root->val > val){
	    	root->left = Insert(root->left,val);
		}else{
	    	root->right = Insert(root->right,val);
		}
		return root;
    }
public:
    void Insert(T val){
   		if(Search(val)) return;
		m_root = Insert(m_root,val);
    }
    void Print(){
    	inorder(m_root);//二叉查找树进行中序遍历，可以得到一个递增的有序序列
		cout << endl;
    	preorder(m_root);
    }
};
int main(){
    BSTtree<int> root;
    root.Insert(15);
    root.Insert(4);
    root.Insert(20);
    root.Insert(17);
    root.Insert(19);
    
    root.Print();
}

树的结构：
在这里插入图片描述

结果：

4 15 17 19 20 
15--4
15--20
20--17
17--19
4.1.3.2 查找

  • 查找指定key的节点
    （1）从根结点开始，若二叉树非空，将给定值与根结点的关键字比较，若相等，则查找成功；
    （2）若不等，则当给定值小于根结点关键字时，在根结点的左子树中查找，否则在根结点的右子树中查找。

  • 实例

#include <iostream>
using namespace std;
template <typename T> 
class _Node{
public:
    T val;
    _Node* left;
    _Node* right;
    _Node(T val):val(val),left(nullptr),right(nullptr){}
    _Node(T val,_Node* left,_Node* right):val(val),left(left),right(right){}
};
template <typename T>
class BSTtree{
private:
    typedef _Node<T> Node;
    Node* m_root = nullptr;
    bool Search(Node* root,T val){
    	if(nullptr == root) return false;
		if(root->val == val) return true;
		if(root->val < val){
	    	Search(root->right,val);
		}else{
	    	Search(root->left,val);
		}
    }
    void inorder(Node* root){
    	if(nullptr == root) return;
		inorder(root->left);
		cout << root->val << " ";
		inorder(root->right);
    }
    void preorder(const Node* root){
    	if(nullptr == root) return;
    	if(root->left) cout << root->val << "--" << root->left->val << endl;
    	if(root->right) cout << root->val << "--" << root->right->val << endl;
    	preorder(root->left);
    	preorder(root->right);
    }
    Node* Insert(Node* root,T val){
    	if(nullptr ==  root) return new Node(val);
		if(root->val > val){
	    	root->left = Insert(root->left,val);
		}else{
		    root->right = Insert(root->right,val);
		}
		return root;
    }
public:
    bool Search(T val){
    	return Search(m_root,val);
    }
    void Insert(T val){
   		if(Search(val)) return;
		m_root = Insert(m_root,val);
    }
    void Print(){
    	inorder(m_root);//二叉查找树进行中序遍历，可以得到一个递增的有序序列
		cout << endl;
    	preorder(m_root);
    }
};
int main(){
    BSTtree<int> root;
    root.Insert(15);
    root.Insert(4);
    root.Insert(20);
    root.Insert(17);
    root.Insert(19);
    
    root.Print();

    cout << root.Search(1) << " " << root.Search(19) << endl;
}
4.1.3.3 删除

二叉查找树的删除操作是相对复杂一点，它要按 3 种情况来处理：

（1）被删除结点是叶子结点，直接删除。
在这里插入图片描述

（2）结点只有左子树或只有右子树，则让子树替代；
在这里插入图片描述
（3）结点既有左子树，又有右子树，有两种处理方式
a）合并删除，右子树合并到左子树的最大值的右子树上；或者左子树合并到右子树最小值的左子树上。
b）替代删除，后继代替删除节点，然后删除后继；或者前驱代替删除节点，然后删除前驱。（常用）
在这里插入图片描述

  • 实例
#include <iostream>
using namespace std;
template <typename T>
class _Node {
public:
    T val;
    _Node* left;
    _Node* right;
    _Node(T val):val(val),left(nullptr),right(nullptr) {}
    _Node(T val,_Node* left,_Node* right):val(val),left(left),right(right) {}
};
template <typename T>
class BSTtree {
private:
    typedef _Node<T> Node;
    Node* m_root = nullptr;
    bool Search(Node* root,T val) {
        if(nullptr == root) return false;
        if(root->val == val) return true;
        if(root->val < val) {
            return Search(root->right,val);
        } else {
            return Search(root->left,val);
        }
    }
    void inorder(Node* root) {
        if(nullptr == root) return;
        inorder(root->left);
        cout << root->val << " ";
        inorder(root->right);
    }
    void preorder(const Node* root) {
        if(nullptr == root) return;
        if(root->left) cout << root->val << "--" << root->left->val << endl;
        if(root->right) cout << root->val << "--" << root->right->val << endl;
        preorder(root->left);
        preorder(root->right);
    }
    Node* Insert(Node* root,T val) {
        if(nullptr ==  root) return new Node(val);
        if(root->val > val) {
            root->left = Insert(root->left,val);
        } else {
            root->right = Insert(root->right,val);
        }
        return root;
    }
    Node* Remove(Node* root,T val) {
        if(nullptr == root) return nullptr;
        if(root->val < val) {
            root->right = Remove(root->right,val);
        } else if(root->val > val) {
            root->left = Remove(root->left,val);
        } else {
            //删除结点为叶子节点，直接删除
            //左右子树都为空
            if(nullptr == root->right && nullptr == root->left) {
                delete root;
                return nullptr;
            }
            //结点只有左子树或只有右子树，则让子树替代
            //右子树为空，左子树作为根结点
            if(nullptr == root->right) {
                Node* left = root->left;
                delete root;
                return left;
            }
            //左子树为空，右子树作为根结点
            if(nullptr == root->left) {
                Node* right = root->right;
                delete root;
                return right;
            }
            //左右子树都不为空，右子树中找到最小值，替换掉根结点
            T minval = Minimum(root->right);
            root->val = minval;
            //root->right = Remove(root->right,minval);
            root->right = DeleteMin(root->right);
        }
        return root;
    }
    int Minimum(Node* root) {
        if(nullptr == root) throw runtime_error("root is null");
        while(nullptr != root->left) {
            root = root->left;
        }
        return root->val;
    }
    Node* DeleteMin(Node* root) {
        if(nullptr == root) throw runtime_error("root is null");
        Node* prev = nullptr;
        Node* cur = root;
        while(nullptr != cur->left) {
            prev = cur;
            cur = cur->left;
        }
		prev->left = nullptr;
        delete cur;
		return root;
    }
public:
    bool Search(T val) {
        return Search(m_root,val);
    }
    void Insert(T val) {
        if(Search(val)) return;
        m_root = Insert(m_root,val);
    }
    void Print() {
        inorder(m_root);//二叉查找树进行中序遍历，可以得到一个递增的有序序列
        cout << endl;
        preorder(m_root);
    }
    void Remove(T val) {
        m_root = Remove(m_root,val);
    }
};
int main() {
    BSTtree<int> root;
    root.Insert(15);
    root.Insert(10);
    root.Insert(30);
    root.Insert(5);
    root.Insert(11);
    root.Insert(12);
    root.Insert(20);
    root.Insert(40);

    root.Remove(15);
    root.Print();

}

树的可视化工具：GraphvizOnline

删除前
在这里插入图片描述
删除结点15后

在这里插入图片描述
删除结点5后
在这里插入图片描述
删除结点11后
在这里插入图片描述

4.1.4 优缺点

  • 优点
操作时间复杂度
插入O(log n)
查找O(log n)
插入O(log n)
  • 缺点
    二叉搜索树构造顺序影响操作的时间复杂度。

4.2 平衡二叉树（AVL树）

解决BST树的缺点：不平衡

如果数据连续，则BST树退化成链表的形式，导致查找效率低。
此时，采用AVL树可解决BST树的缺点。
在这里插入图片描述
平衡二叉树/自平衡二叉查找树(Balanced Binary Tree)： 也称为AVL树。
它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

  • 特点
    （1）左右子树深度之差的绝对值不超过1(任意节点的两子树的高度最大差别为1).
    （2）左右子树仍然为平衡二叉树.

4.2.1 判断平衡

平衡因子BF(Balance Factor)：左树深度减去右树深度的值。平衡因子BF = 左子树深度－右子树深度。
平衡二叉树每个结点的平衡因子只能是1，0，-1。若其绝对值超过1，则该二叉排序树就是不平衡的。当BF为-1、0、1时，二叉树平衡；反之，不平衡。
在这里插入图片描述
（1）（3）不是
（2）（4）是

4.2.2 操作

AVL树的操作基本和二叉查找树一样，这里我们关注的是两个变化很大的操作：插入和删除！

4.2.3 旋转

旋转条件：当最小不平衡子树根节点BF>1,右旋；BF<-1,左旋。
在这里插入图片描述
当P的A、B节点插入新结点，导致Q点不平衡，左重右轻，右旋。
当Q的B、C节点插入新结点，导致P点不平衡，右重左轻，左旋。
旋转点上升，不平衡点向轻的一侧旋转。

  • 旋转步骤：
    （1）获取旋转节点
    （2）旋转节点的子节点替换父节点的旋转节点
    （3）旋转节点父节点做旋转节点子节点
    （4）返回旋转节点

例:

（1）依次插入1,2,3在这里插入图片描述
（2）依次插入3,2,1
在这里插入图片描述
（3）依次插入2,1,3或2,3,1
在这里插入图片描述

（4）依次插入1,3,2
在这里插入图片描述
（5）依次插入3,1,2
在这里插入图片描述

（6）依次插入4,5在这里插入图片描述
（7）依次插入6,7在这里插入图片描述

4.2.4 插入

插入时的不平衡的四种情况：
LL：插入一个新节点到不平衡节点的左子树（Left）的左子树（Left），导致不平衡节点的平衡因子由1变为2

在这里插入图片描述
RR：插入一个新节点到不平衡节点的右子树（Right）的右子树（Right），导致不平衡节点的平衡因子由-1变为-2

在这里插入图片描述

LR：插入一个新节点到不平衡节点的左子树（Left）的右子树（Right），导致不平衡节点的平衡因子由1变为2
在这里插入图片描述

RL：插入一个新节点到不平衡节点的右子树（Right）的左子树（Left），导致不平衡节点的平衡因子由-1变为-2

在这里插入图片描述

  • 不平衡处理方法
    （1）单向右旋平衡处理LL
    （2）单向左旋平衡处理RR
    （3）双向旋转（先左后右）平衡处理LR
    （4）双向旋转（先右后左）平衡处理RL

在这里插入图片描述

  • 实例
#include <iostream>
#include <stack>
#include <queue>
using namespace std;
template <typename T>
class _Node{
public:
    T val;
    _Node* left;
    _Node* right;
    _Node(const T& val):val(val),left(nullptr),right(nullptr){}
    _Node(const T& val,_Node* left,_Node* right):val(val),left(left),right(right){}
};
//    P         Q
//   / \       / \
//  Q   C     A   P
// / \           / \
//A   B         B   C
typedef _Node<int> Node;
Node* RotateRight(Node* root){
    Node* p = root;
    Node* q = root->left;
    Node* b = q->right;
    q->right = p;
    p->left = b;
    return q;
}
//    P         Q
//   / \       / \
//  A   Q     P   C
//     / \   / \       
//    B   C A   B
Node* RotateLeft(Node* root){
    Node* p = root;
    Node* q = root->right;
    Node* b = q->left;
    q->left = p;
    p->right = b;
    return q;
}
void Preorder(Node* root){
     if(nullptr == root) return;
     if(root->left) cout << root->val << "--" << root->left->val << endl;
     if(root->right) cout << root->val << "--" << root->right->val << endl;
     Preorder(root->left);
     Preorder(root->right);
} 
int main(){
    cout << "左旋:" << endl;
{
    Node a(1);
    Node b(2);
    Node c(3);
	
    a.right = &b;
    b.right = &c;

    Preorder(&a);
    Node* root = RotateLeft(&a); //左旋
    Preorder(root);
}
cout << "右旋:" << endl;
{
    Node a(1);
    Node b(2);
    Node c(3);
	
    c.left = &b;
    b.left = &a;

    Preorder(&c);
    Node* root = RotateRight(&c); //左旋
    Preorder(root);

}
cout << "右旋左旋:" << endl;
{
    Node a(1);
    Node b(2);
    Node c(3);
	
    a.right = &c;
    c.left = &b;
    Node* root = &a;

    Preorder(root);
    root->right = RotateRight(root->right);
    Preorder(root);
    root = RotateLeft(root); //左旋
    Preorder(root);

}
cout << "左旋右旋:" << endl;
{
    Node a(1);
    Node b(2);
    Node c(3);
	
    c.left = &a;
    a.right = &b;

    Node* root = &c;
    Preorder(root);
    root->left = RotateLeft(root->left);
    Preorder(root);
    root = RotateRight(root); //左旋
    Preorder(root);
}
}

结果：

左旋:
1--2
2--3
2--1
2--3
右旋:
3--2
2--1
2--1
2--3
右旋左旋:
1--3`在这里插入代码片`
3--2
1--2
2--3
2--1
2--3
左旋右旋:
3--1
1--2
3--2
2--1
2--1
2--3

4.2.5 删除

  • 删除节点有三种情况
    （1）删除叶子节点。
    （2）删除只有一棵子树的节点。
    （3）删除有两棵子树的节点。

AVL删除与BST删除方式一致，在BST删除结点的基础上增加平衡操作即可。

  • 实例
#include <iostream>
#include <stack>
#include <vector>
#include <queue>
using namespace std;

template <typename T>
class _Node {
public:
    T val;
    _Node* left;
    _Node* right;
    _Node(const T& val):val(val),left(nullptr),right(nullptr) {}
    _Node(const T& val,_Node* left,_Node* right):val(val),left(left),right(right) {}
};

template <typename T>
class AVLTree {
    typedef _Node<T> Node;
    Node* m_root = nullptr;
public:
    bool Search(const T& val) {
        return Search(m_root,val);
    }
    void Insert(const T& val) {
        if(Search(val)) return;
        m_root = Insert(m_root,val);
    }
    void Remove(const T& val) {
        m_root = Remove(m_root,val);
    }
    void Print() {
        preorder(m_root);
    }
private:
    bool Search(Node* root,const T& val) {
        if(nullptr == root) return false;
        if(root->val == val) return true;
        if(root->val < val) {
            return Search(root->right,val);
        } else {
            return Search(root->left,val);
        }
        // return Search(root->val<val?root->right:root->left,val);
    }
    Node* Remove(Node* root,const T& val) {
        if(nullptr == root) return nullptr;
        if(root->val < val) root->right = Remove(root->right,val);
        else if(root->val > val) root->left = Remove(root->left,val);
        else {
            if(nullptr == root->right && nullptr == root->left) {
                delete root;
                return nullptr;
            }
            if(nullptr == root->right) {
                Node* left = root->left;
                delete root;
                return left;
            }
            if(nullptr == root->left) {
                Node* right = root->right;
                delete root;
                return right;
            }
            T minval = Minimun(root->right);
            root->val = minval;
            root->right = Remove(root->right,minval);
            // root->right = DeleteMin(root->right);
        }
        return Balance(root);
    }
    Node* DeleteMin(Node* root) {
        if(nullptr == root) throw runtime_error("root is null");
        Node* prev = nullptr;
        Node* cur = root;
        while(nullptr != cur->left) {
            prev = cur;
            cur = cur->left;
        }
        delete cur;
        return root;
    }
    T Minimun(Node* root) {
        if(nullptr == root) throw runtime_error("root is null");
        while(nullptr != root->left) root = root->left;
        return root->val;
    }
    T Maximun(Node* root) {
        if(nullptr == root) throw runtime_error("root is null");
        while(nullptr != root->right) root = root->right;
        return root->val;
    }
    Node* Insert(Node* root,const T& val) {
        if(nullptr == root) return new Node(val);
        if(root->val>val) {
            root->left = Insert(root->left,val);
        } else {
            root->right = Insert(root->right,val);
        }
        return Balance(root);
    }
    void preorder(const Node* root) {
        if(nullptr == root) return;
        if(root->left) cout << root->val << "--" << root->left->val << endl;
        if(root->right) cout << root->val << "--" << root->right->val<< endl;
        preorder(root->left);
        preorder(root->right);
    }
//     P          Q
//    / \        / \
//   Q   C      A   P
//  / \            / \
// A   B          B   C
    Node* RotateRight(Node* root) {
        Node* p = root;
        Node* q = p->left;
        Node* b = q->right;
        q->right = p;
        p->left = b;
        return q;
    }
//   P            Q
//  / \          / \
// A   Q        P   C
//    / \      / \
//   B   C    A   B
    Node* RotateLeft(Node* root) {
        Node* p = root;
        Node* q = p->right;
        Node* b = q->left;
        q->left = p;
        p->right = b;
        return q;
    }
    int Balancefactory(Node* root) {
        return Depth(root->left)-Depth(root->right);
    }

    Node* Balance(Node* root) {
        int bf = Balancefactory(root);
        if(bf == -2) {
            if(Balancefactory(root->right)>0) {
                root->right = RotateRight(root->right);
            }
            root = RotateLeft(root);
        } else if(bf == 2) {
            if(Balancefactory(root->left)<0) {
                root->left = RotateLeft(root->left);
            }
            root = RotateRight(root);
        }
        return root;
    }

    int Depth(Node* root){
        if(nullptr == root) return 0;
		return max(Depth(root->left),Depth(root->right))+1;
    }
};
int main() {
    AVLTree<int> intbst;
    int n;
    while(cin >> n) {
        intbst.Insert(n);
    }
    intbst.Print();
}

输入1 2 3 4 5，结果为：

[root@localhost avl]# ./a.out 
1
2
3
4
5
2--1
2--4
4--3
4--5

画出树的结构，可以看出，插入数据后，树会自动保持平衡
在这里插入图片描述
移除结点1，仍然保持平衡
在这里插入图片描述

4.3 BST vs. AVL

在这里插入图片描述
区别：AVL的插入和删除操作在BST的基础上加入平衡操作。

_深蓝.
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法-BST(二叉搜索树)、AVL树(平衡二叉树)
weixin_45639955的博客
02-12 331
1二叉查找树 1.1特点 任意节点的左子树不空, 则左子树上所有节点的key均小于它的根节点的key 任意节点的右子树不空, 则右子树上所有节点的key均大于它的根节点的key 任意节点的左,右子树也分别为二叉查找树 没有key相等的节点 二叉查找树进行中序遍历，可以得到一个递增的有序序列 1.2结构 struct Node { int key; struct Node* l...
【数据结构】树（二）：二叉树&二叉搜索树&平衡二叉树（C++实现）
快去创造奇迹
04-21 748
二叉树/二叉搜索树/平衡二叉树
BST有缺陷--红黑树(RBT)应运而生
m0_62600503的博客
06-24 366
这种情况通常发生在红黑树的平衡调整操作中，如果节点的父节点为黑色，则改为红色后不会影响红黑树的平衡性质，而更改后的颜色有助于平衡调整中旋转操作的实现。红黑树是一种平衡的二叉搜索树，它的节点在存储了普通二叉搜索树节点的值和指向左右子节点的指针外，还增加了表示节点颜色的标记，标记可能是红色或者黑色。由于父节点22是红色节点，因此这种情况打破了红黑树的规则4（每个红色节点的两个子节点都是黑色），必须进行调整，使之重新符合红黑树的规则。（1）不存在两个相邻的红色节点，也就是红色节点的父节点和子节点都是黑色。
【数据结构】二叉排序树；平衡二叉树的知识点学习总结
小人物，大梦想！
09-24 336
二叉排序树：定义、基本操作和C语言实现基本操作。 平衡二叉树：定义、基本操作和调整不平衡。
【数据结构与算法】Size Balanced Tree（SBT）平衡二叉树
小哲的博客
11-02 1475
尺寸平衡树（SBT）平衡二叉树 原文链接大小平衡树（SBT）平衡二叉树 定义数据结构 struct SBT { int key,left,right,size; } tree[N]; 关键：存储值，左，右：左右子树，大小：保持平衡最终要的数据，表示子树的大小 SBT树的性质 定义一个节点X，同时满足下面两个条件 (a)、x.left.size &gt;= max(x.r...
7.5 二叉查找树(BST)及平衡二叉树(AVL)的概念及基本运算
xutiantian1412的博客
08-01 707
经历二叉树的重重拷问，终于来到二叉查找树，又称二叉搜索树（BinarySearchTrees）。在第6章查找算法的介绍中，我们提到了树表查找/动态表查找，BST因为关键字有序，在查找时同样高效，并且易于对关键字的插入及删除操作。 二叉搜索树的基本概念 二叉搜索树是一棵二叉树。这样一棵树可以使用一个链表结构表示，其中每个结点就是一个对象。除了结点中的关键字外，每个结点还包含属性left、righ...
BST(二叉搜索树),AVL(平衡二叉树)、RBT(红黑树)的区别
森明帮大于黑虎帮的博客
08-29 6481
文章目录
二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 课设作业 完整代码
02-10
其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：1.若它的左子树非空，则左子树上所有结点的值均小于根结点的值；2.若它的右子树非空，则右子树上所有结点的值均大于根结点的值；3.左、右子树本身又各...
Java实现的二叉搜索树和平衡二叉树的代码示例
01-20
在实际应用中，二叉搜索树和平衡二叉树广泛用于数据库索引、文件系统、内存分配等场景，它们提供了高效的查找、插入和删除操作，是数据结构和算法领域的重要组成部分。了解和掌握这些概念，对于任何Java开发者来说都...
二叉树-基于C++实现的二叉搜索树.zip
最新发布
04-26
二叉树是一种特殊的树结构，每个节点最多只有两个子节点，通常分为左子节点和右子节点。...理解并掌握二叉搜索树的原理和操作是提升算法能力的关键，而自平衡二叉搜索树则进一步提高了在大规模数据处理中的效率。
二叉树的可视化
07-20
二叉树的可视化，里面有源程序，项目开发文档和使用说明书
动态平衡二叉树demo
08-04
通过C基于AVLTree结构实现的动态平衡二叉搜索树，具有GUI界面，可用于增删改查，二叉树的图形绘制，二叉树的深度求取，二叉树的先序遍历、中序遍历和后序遍历等功能。
平衡二叉树可视化
03-11
平衡二叉树，使用windows编程画出图形界面
二叉搜索树，红黑树，AVL平衡树，B树
05-08
二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的指针和一个指向右子树的指针。在二叉搜索树中，对于任意节点： 1. 所有左...
实现二叉排序树的各种算法
07-25
二叉排序树（Binary Sort Tree，BST），也称为二叉查找树或二叉搜索树，是一种自平衡的二叉树数据结构，它在处理搜索、插入和删除操作时具有较高的效率。二叉排序树的主要特性是：对于任意节点，其左子树中的所有...
BST、AVL、红黑树
LRC1062702315的博客
08-02 206
详解BST、AVL、红黑树
数据结构 二叉树（BST树） 和 平衡二叉树（AVL树 ）
weixin_49725030的博客
03-28 2057
二叉树（BST树） 和 平衡二叉树（AVL树 ）前言一、二叉树1.特点2.好处3.缺点二、平衡二叉树（红黑树）1.特点好处：缺点：总结 前言 说到数据结构，就不得不联想到 索引，其中以mysql为代表。索引底层就是利用树结构，以时间换空间。二叉树，平衡二叉树 也叫红黑树，B树，B+树。这篇文章就说下 我对 二叉树和平衡二叉树 的了解。 一、二叉树 1.特点 如图所示 每一个数字都是一个节点，第一排为根节点，上一排作为下一排的父节点。 1. 根节点的值大于其左子树中任意一个节点的值。 2. 根节点的值
详细图解高阶搜索树B树及C语言实现
ZER00000001的博客
07-26 1952
前言 对于大量的数据而言，链表的线性访问时间太慢，不宜使用。本章节将会介绍一种简单的数据结构：树（tree），其大部分操作的运行时间平均为O（logN）。在数据结构中树是非常有用的抽象概念，在本篇中我们将讨论一棵高阶搜索树——b树。前排提示：高阶搜索树的代码难度高出一个量级，建议先把逻辑理顺后再去看代码哦。...
平衡二叉树（BST）总结及代码实现
JiaQiao1997的博客
06-24 280
每个结点都有一个作为搜索依据的关键码 左子树上所有结点值小于根节点的值，右子树上所有结点值大于根结点的值 如果对一棵二叉搜索树进行中序遍历，可以按从小到大的顺序将各节点的值排列起来 typedef struct BstNode { KeyType key; BstNode* leftchild; BstNode* parent; BstNode* rightchild; }BstNode,*BSTree; BstNode* Buynode(KeyType kx) { BstNode*s

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值