高温预警：请问大家清楚二叉树、二叉查找树、二叉排序树、二叉平衡树的区别是什么吗？

短命女 2024-03-17 11:47 11阅读 0赞

废话不多说，让我们直接进入正题，**让我们一起来看看二叉树、二叉查找树、二叉排序树、二叉平衡树的区别是什么吧！**

## 1. 二叉树 ##

二叉树是一种特殊的树形结构，每个节点最多只有两个子节点。二叉树的特点如下：

● 每个节点最多只有两个子节点

● 左子树和右子树是有顺序的

● 即使只有一棵子树，也要区分左右子树

![0b86a6237d8f98d43e3752568476e685.png][]

二叉树是每个节点最多有两个子树的树结构。通常子树被称作左子树和右子树。二叉树的定义如下：

public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(int x) { val = x; }
    }

二叉树的遍历方式有三种，分别是**前序遍历、中序遍历、后序遍历。**

## 2. 二叉查找树 ##

二叉查找树，又名二叉搜索树、二叉排序树，它或者是一棵空树，或者是具有下列性质的二叉树：

![2ae517c6cc27d91428debdafa4edc609.png][]

● 若它的左子树不空，则左子树上所有结点的值均小于它的根节点的值；

● 若它的右子树不空，则右子树上所有结点的值均大于它的根节点的值；

● 它的左、右子树也分别为二叉查找树。

**二叉查找树的实现代码如下：**

public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(int x) { val = x; }
    }
    
    public class BinarySearchTree {
        private TreeNode root;
        public void insert(int val) {
            root = insert(root, val);
        }
        private TreeNode insert(TreeNode root, int val) {
            if (root == null) {
                return new TreeNode(val);
            }
            if (val < root.val) {
                root.left = insert(root.left, val);
            } else if (val > root.val) {
                root.right = insert(root.right, val);
            }
            return root;
        }
        public boolean search(int val) {
            return search(root, val);
        }
        private boolean search(TreeNode root, int val) {
            if (root == null) {
                return false;
            }
            if (root.val == val) {
                return true;
            } else if (val < root.val) {
                return search(root.left, val);
            } else {
                return search(root.right, val);
            }
        }
    }

二叉查找树的遍历方式同二叉树，即前序遍历、中序遍历、后序遍历。

## 3. 二叉排序树 ##

![c4bb590b1b8b0cf4a72b19e680ce215e.png][]

二叉排序树（BST）是一种特殊的二叉树，它的每个节点都满足左子树上所有节点的值都小于该节点的值，右子树上所有节点的值都大于该节点的值。BST的特点如下：

● 左子树上所有节点的值都小于该节点的值

● 右子树上所有节点的值都大于该节点的值

● 左右子树都是BST

二叉排序树的实现代码如下：

public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(int x) { val = x; }
    }
    
    public class BinarySortTree {
        private TreeNode root;
        public void insert(int val) {
            root = insert(root, val);
        }
        private TreeNode insert(TreeNode root, int val) {
            if (root == null) {
                return new TreeNode(val);
            }
            if (val < root.val) {
                root.left = insert(root.left, val);
            } else if (val > root.val) {
                root.right = insert(root.right, val);
            }
            return root;
        }
        public boolean search(int val) {
            return search(root, val);
        }
        private boolean search(TreeNode root, int val) {
            if (root == null) {
                return false;
            }
            if (root.val == val) {
                return true;
            } else if (val < root.val) {
                return search(root.left, val);
            } else {
                return search(root.right, val);
            }
        }
    }

二叉排序树的遍历方式同二叉树，即前序遍历、中序遍历、后序遍历。

## 4. 二叉平衡树 ##

二叉平衡树是一种特殊的二叉排序树，它的每个节点的左右子树高度差不超过1。二叉平衡树的特点如下：

● 每个节点的左右子树高度差不超过1

● 左右子树都是平衡二叉树

![b002ddf2202ab38a5906e4e2d6406779.png][]

二叉平衡树的实现代码如下：

public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        int height;
        TreeNode(int x) { val = x; }
    }
    
    public class AVLTree {
        private TreeNode root;
        private int height(TreeNode node) {
            if (node == null) {
                return -1;
            } else {
                return node.height;
            }
        }
        private int max(int a, int b) {
            return a > b ? a : b;
        }
        private TreeNode rightRotate(TreeNode y) {
            TreeNode x = y.left;
            TreeNode 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;
        }
        private TreeNode leftRotate(TreeNode x) {
            TreeNode y = x.right;
            TreeNode 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;
        }
        private int getBalance(TreeNode node) {
            if (node == null) {
                return 0;
            } else {
                return height(node.left) - height(node.right);
            }
        }
        public void insert(int val) {
            root = insert(root, val);
        }
        private TreeNode insert(TreeNode root, int val) {
            if (root == null) {
                return new TreeNode(val);
            }
            if (val < root.val) {
                root.left = insert(root.left, val);
            } else if (val > root.val) {
                root.right = insert(root.right, val);
            } else {
                return root;
            }
            root.height = 1 + max(height(root.left), height(root.right));
            int balance = getBalance(root);
            if (balance > 1 && val < root.left.val) {
                return rightRotate(root);
            }
            if (balance < -1 && val > root.right.val) {
                return leftRotate(root);
            }
            if (balance > 1 && val > root.left.val) {
                root.left = leftRotate(root.left);
                return rightRotate(root);
            }
            if (balance < -1 && val < root.right.val) {
                root.right = rightRotate(root.right);
                return leftRotate(root);
            }
            return root;
        }
        public boolean search(int val) {
            return search(root, val);
        }
        private boolean search(TreeNode root, int val) {
            if (root == null) {
                return false;
            }
            if (root.val == val) {
                return true;
            } else if (val < root.val) {
                return search(root.left, val);
            } else {
                return search(root.right, val);
            }
        }
    }

二叉平衡树的遍历方式同二叉树，即**前序遍历、中序遍历、后序遍历。**

## 5. 总结 ##

**二叉树、二叉查找树、二叉排序树、二叉平衡树都是树结构的一种形式，但是它们在实现和使用上有很大的区别。**

二叉查找树和二叉排序树都是基于二叉树的基础上进行了优化，可以更快速地查找特定的数据。而二叉平衡树则是为了解决二叉查找树在极端情况下退化为链表的问题而提出的，它保证了每个节点的左右子树高度差不超过1，使得树的高度始终保持在O(log n)的级别。因此，在不同的场景下，我们要根据自己的需求选择不同的树结构来实现哦。

**最后给大家把二叉树、二叉查找树、二叉排序树、二叉平衡树他们之间的区别给大家做一个汇总，这样方便大家总结学习：**

● 二叉树是一种树状数据结构，每个节点最多有两个子节点。其中，根节点没有父节点，叶子节点没有子节点。二叉树可以为空树。

● 二叉查找树（BST）是一种二叉树，它满足以下条件：

> 若左子树不为空，则左子树上所有节点的值均小于它的根节点的值
> 
> 若右子树不为空，则右子树上所有节点的值均大于它的根节点的值
> 
> 左右子树均为二叉查找树
> 
> 没有键值相等的节点

● 二叉排序树（BST）和二叉查找树（BST）是同一个概念，是一种二叉树，满足二叉查找树的条件。

● 二叉平衡树（AVL）是一种自平衡的二叉查找树，它满足以下条件：

> 左子树和右子树的高度之差不超过1
> 
> 左右子树均为二叉平衡树

**总结一下，二叉树是一种树状数据结构，每个节点最多有两个子节点。二叉查找树和二叉排序树是同一个概念，它们是一种满足特定条件的二叉树。二叉平衡树是一种自平衡的二叉查找树，它保证了树的高度平衡，防止树失衡过深。**

[0b86a6237d8f98d43e3752568476e685.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/ac674bc1ee18411fb15d357d4664c4a8.png
[2ae517c6cc27d91428debdafa4edc609.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/3c7870079c9943749684e79454905cab.png
[c4bb590b1b8b0cf4a72b19e680ce215e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/53f986d29c2d42a287e295051791a8af.png
[b002ddf2202ab38a5906e4e2d6406779.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/670c815477a94ec5a777bf0e9340cf37.png