ディレクトリ
@
まず、平衡二分木の定義
平衡二分木としても知られ、AVL木。それは空のツリー、または以下の特性を有することができるバイナリソートツリーの左の部分木の高さ及び右サブツリー（平衡因子）とその左の部分木のないつ以上と右の子との差の絶対値：ツリーは平衡二分木です。
上記の単純な定義から、我々はいくつかの重要な情報を引き出すことができます。
- 平衡二分木としても知られ、 AVL木
- バイナリツリーバランスをとらなければならないバイナリ・ソートツリーを
- 各ノードの左サブツリー及び右サブツリー高させいぜい1の差。
定義のツリーの高さと深さに言及、私は多くの読者は、ツリーの高さと深さに関するいくつかの誤解を持っている必要がありますがあります確信しています！最も美しい誤解は、ツリーの深さの高さとみなされ、木の高さと深さが異なっていないということです。宜春市は、我慢いくつかのビープ音する必要はないでしょう...
木の高さと深さとの間の本質的な違い：そのリーフノードに少数のルートノードからの深さ、高さは、そのルートにリーフノードからの点の数です。
二分木のルートから深さは蓄積層によるトップダウン層であり、リーフノードからバイナリツリー開始する蓄積層によるボトムアップ層からの高さです。同じ深さと高さの木のが、ツリーの特定のノードにあるが、深さと高さは同じではありません。
第二は、ツリーの高さと深さ1以降から、又は0カウントの数です。もちろん私は自分の答えを持っていますが、異なる意見、ブロガーは、その善悪を言っていないではなく、ビープ音に。しかし、私はまだビューダイアグラムこの点に同意：
：を参照してくださいhttps://www.zhihu.com/question/40286584
第二に、これは一つやバランスバイナリツリーではないでしょうか？
平衡二分木（AVLツリー）を分析すると、以下の必要条件を有します。
条件：二分探索木でなければなりません。
第二の条件：高さの差は、各ノードと高々 1の右の部分木の部分木を残しました。
第三に、バランス係数
ビープはるか、バランス係数=左サブツリーの深さ/高さ-右サブツリーの深さ/高さ
図用語の平衡二分木の場合：
ノード5バランス係数が3である- = 1 2、
ノード2は、バランス係数であります- 2 = -1;
接合バランス係数4は1--0 = 1であり、
ノード6バランス係数は0 - 1 = -1。
図不平衡二分木の目的のために：
ノード3 =バランス係数2--4 -2、
ノードバランス係数は1 0 - = 1 -1;
ジャンクション4バランス係数は0--3 = -3 ;
ノード5バランス係数は0--2 = -2である
ノード6バランス係数は0 - 1 = -1。
特別な注意：バランス係数リーフノードである0
第四には、どのようにバランスのバイナリツリーがバランスを維持するには？
通常のバイナリ検索ツリーを失うのは簡単だろうので、「バランス」は、極端な場合には、二分探索木は、リニアチェーンに退化う挿入になると複雑に見下しO(n)、これは心の中でバランスの取れたバイナリツリー設計ですので、。だから、バランスバイナリツリー「バランス」の平均を維持するためにどのように？
バランスの取れたバイナリツリーを見ることは困難ではない高さ、バランスのバイナリ検索ツリーです。したがって、それをビルドにバランスの取れたバイナリツリーを維持するためには、はるかに複雑普通のバイナリツリーよりもあります。結果がそうであれば、挿入と木のバランスを破壊し、されているかどうか、新しいノードが挿入されるとき、チェックを平衡二分木を構築するプロセスでは、あなたがする必要がありますか回転ツリーの構造を変更します。回転については、私は記述の単語が明確に困難な、あるいは良く理解するために、古典的な二つのグラフに依存していると信じています！ああ、もちろん、あなたがLのテキスト記述を読むことを試みることができると信じてはいけません。
左旋简单来说就是将节点的右支往左拉，右子节点变成父节点，并把晋升之后多余的左子节点出让给降级节点的右子节点。
相信你已经晕了。当然可以试着看看下面的经典动图理解！
左旋：
==试着用动态和下面的左旋结果图分析分析，想象一下，估计分分钟明白左旋！！！==
//左旋转方法代码
private void leftRotate() {
//创建新的结点，以当前根结点的值
Node newNode = new Node(value);
//把新的结点的左子树设置成当前结点的左子树
newNode.left = left;
//把新的结点的右子树设置成带你过去结点的右子树的左子树
newNode.right = right.left;
//把当前结点的值替换成右子结点的值
value = right.value;
//把当前结点的右子树设置成当前结点右子树的右子树
right = right.right;
//把当前结点的左子树(左子结点)设置成新的结点
left = newNode;
}相应的右旋就很好理解了：
反之就是右旋，这里就不再举例了！
小结：当二叉排序树每个节点的左子树和右子树的高度差超过1的时候，就需要通过旋转节点来维持平衡！旋转又分为左旋、右旋、双旋转。
啥？双旋转？是的，顾名思义，在一些添加节点的情况下旋转一次是不能达到平衡的，需要进行第二次旋转，
五、平衡二叉树插入节点的四种情况
当新节点插入后，有可能会有导致树不平衡，而可能出现的情况就有4种，分别称作左左，左右，右左，右右。
==而所谓的“左”和“右”无非就是代表新节点所插入的位置是左还是右！==
第一个左右代表位于根节点的左或者右，
第二个左右代表位于 【最接近插入节点的拥有两个子节点的父节点】 位置的左或者右
==当然针对于第二个左右是我个人的见解，不一定完全正确。有自己想法的读者，欢迎留言指正！==
下面以左左为例，分析一波：
其中要特别注意的是：
右右、左左只需要旋转一次就可以平衡。
左右、右左要旋转两次才能把树调整平衡！
==其中旋转的条件就是：当二叉排序树每个节点的左子树和右子树的高度差超过1的时候！==
六、平衡二叉树操作的代码实现
// 创建AVLTree
class AVLTree {
private Node root;
public Node getRoot() {
return root;
}
// 查找要删除的结点
public Node search(int value) {
if (root == null) {
return null;
} else {
return root.search(value);
}
}
// 查找父结点
public Node searchParent(int value) {
if (root == null) {
return null;
} else {
return root.searchParent(value);
}
}
// 编写方法:
// 1. 返回的 以node 为根结点的二叉排序树的最小结点的值
// 2. 删除node 为根结点的二叉排序树的最小结点
/**
*
* @param node 传入的结点(当做二叉排序树的根结点)
*
* @return 返回的 以node 为根结点的二叉排序树的最小结点的值
*/
public int delRightTreeMin(Node node) {
Node target = node;
// 循环的查找左子节点，就会找到最小值
while (target.left != null) {
target = target.left;
}
// 这时 target就指向了最小结点
// 删除最小结点
delNode(target.value);
return target.value;
}
// 删除结点
public void delNode(int value) {
if (root == null) {
return;
} else {
// 1.需求先去找到要删除的结点 targetNode
Node targetNode = search(value);
// 如果没有找到要删除的结点
if (targetNode == null) {
return;
}
// 如果我们发现当前这颗二叉排序树只有一个结点
if (root.left == null && root.right == null) {
root = null;
return;
}
// 去找到targetNode的父结点
Node parent = searchParent(value);
// 如果要删除的结点是叶子结点
if (targetNode.left == null && targetNode.right == null) {
// 判断targetNode 是父结点的左子结点，还是右子结点
if (parent.left != null && parent.left.value == value) { // 是左子结点
parent.left = null;
} else if (parent.right != null && parent.right.value == value) {// 是由子结点
parent.right = null;
}
} else if (targetNode.left != null && targetNode.right != null) { // 删除有两颗子树的节点
int minVal = delRightTreeMin(targetNode.right);
targetNode.value = minVal;
} else { // 删除只有一颗子树的结点
// 如果要删除的结点有左子结点
if (targetNode.left != null) {
if (parent != null) {
// 如果 targetNode 是 parent 的左子结点
if (parent.left.value == value) {
parent.left = targetNode.left;
} else { // targetNode 是 parent 的右子结点
parent.right = targetNode.left;
}
} else {
root = targetNode.left;
}
} else { // 如果要删除的结点有右子结点
if (parent != null) {
// 如果 targetNode 是 parent 的左子结点
if (parent.left.value == value) {
parent.left = targetNode.right;
} else { // 如果 targetNode 是 parent 的右子结点
parent.right = targetNode.right;
}
} else {
root = targetNode.right;
}
}
}
}
}
// 添加结点的方法
public void add(Node node) {
if (root == null) {
root = node;// 如果root为空则直接让root指向node
} else {
root.add(node);
}
}
// 中序遍历
public void infixOrder() {
if (root != null) {
root.infixOrder();
} else {
System.out.println("二叉排序树为空，不能遍历");
}
}
}
// 创建Node结点
class Node {
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
}
// 返回左子树的高度
public int leftHeight() {
if (left == null) {
return 0;
}
return left.height();
}
// 返回右子树的高度
public int rightHeight() {
if (right == null) {
return 0;
}
return right.height();
}
// 返回 以该结点为根结点的树的高度
public int height() {
return Math.max(left == null ? 0 : left.height(), right == null ? 0 : right.height()) + 1;
}
//左旋转方法
private void leftRotate() {
//创建新的结点，以当前根结点的值
Node newNode = new Node(value);
//把新的结点的左子树设置成当前结点的左子树
newNode.left = left;
//把新的结点的右子树设置成带你过去结点的右子树的左子树
newNode.right = right.left;
//把当前结点的值替换成右子结点的值
value = right.value;
//把当前结点的右子树设置成当前结点右子树的右子树
right = right.right;
//把当前结点的左子树(左子结点)设置成新的结点
left = newNode;
}
//右旋转
private void rightRotate() {
Node newNode = new Node(value);
newNode.right = right;
newNode.left = left.right;
value = left.value;
left = left.left;
right = newNode;
}
// 查找要删除的结点
/**
*
* @param value
* 希望删除的结点的值
* @return 如果找到返回该结点，否则返回null
*/
public Node search(int value) {
if (value == this.value) { // 找到就是该结点
return this;
} else if (value < this.value) {// 如果查找的值小于当前结点，向左子树递归查找
// 如果左子结点为空
if (this.left == null) {
return null;
}
return this.left.search(value);
} else { // 如果查找的值不小于当前结点，向右子树递归查找
if (this.right == null) {
return null;
}
return this.right.search(value);
}
}
// 查找要删除结点的父结点
/**
*
* @param value 要找到的结点的值
*
* @return 返回的是要删除的结点的父结点，如果没有就返回null
*/
public Node searchParent(int value) {
// 如果当前结点就是要删除的结点的父结点，就返回
if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {
return this;
} else {
// 如果查找的值小于当前结点的值, 并且当前结点的左子结点不为空
if (value < this.value && this.left != null) {
return this.left.searchParent(value); // 向左子树递归查找
} else if (value >= this.value && this.right != null) {
return this.right.searchParent(value); // 向右子树递归查找
} else {
return null; // 没有找到父结点
}
}
}
@Override
public String toString() {
return "Node [value=" + value + "]";
}
// 添加结点的方法
// 递归的形式添加结点，注意需要满足二叉排序树的要求
public void add(Node node) {
if (node == null) {
return;
}
// 判断传入的结点的值，和当前子树的根结点的值关系
if (node.value < this.value) {
// 如果当前结点左子结点为null
if (this.left == null) {
this.left = node;
} else {
// 递归的向左子树添加
this.left.add(node);
}
} else { // 添加的结点的值大于 当前结点的值
if (this.right == null) {
this.right = node;
} else {
// 递归的向右子树添加
this.right.add(node);
}
}
//当添加完一个结点后，如果: (右子树的高度-左子树的高度) > 1 , 左旋转
if(rightHeight() - leftHeight() > 1) {
//如果它的右子树的左子树的高度大于它的右子树的右子树的高度
if(right != null && right.leftHeight() > right.rightHeight()) {
//先对右子结点进行右旋转
right.rightRotate();
//然后在对当前结点进行左旋转
leftRotate(); //左旋转..
} else {
//直接进行左旋转即可
leftRotate();
}
return ; //必须要!!!
}
//当添加完一个结点后，如果 (左子树的高度 - 右子树的高度) > 1, 右旋转
if(leftHeight() - rightHeight() > 1) {
//如果它的左子树的右子树高度大于它的左子树的高度
if(left != null && left.rightHeight() > left.leftHeight()) {
//先对当前结点的左结点(左子树)->左旋转
left.leftRotate();
//再对当前结点进行右旋转
rightRotate();
} else {
//直接进行右旋转即可
rightRotate();
}
}
}
// 中序遍历
public void infixOrder() {
if (this.left != null) {
this.left.infixOrder();
}
System.out.println(this);
if (this.right != null) {
this.right.infixOrder();
}
}
}
public class AVLTreeDemo {
public static void main(String[] args) {
int[] arr = { 14, 21, 7, 3, 8, 9 };//任意测试节点数组
//创建一个 AVLTree对象
AVLTree avlTree = new AVLTree();
//添加结点
for(int i=0; i < arr.length; i++) {
avlTree.add(new Node(arr[i]));
}
//遍历
System.out.println("中序遍历");
avlTree.infixOrder();
System.out.println("平衡处理...");
System.out.println("树的高度=" + avlTree.getRoot().height());
System.out.println("树的左子树高度=" + avlTree.getRoot().leftHeight());
System.out.println("树的右子树高度=" + avlTree.getRoot().rightHeight());
System.out.println("当前的根结点=" + avlTree.getRoot());
}
}七、AVL树总结
1、平衡二叉树又称AVL树。
2、バランスバイナリツリー構造の問合せは、インサートは、すべての時間の複雑さを削除しますO(logN)。
挿入ノードのバランスが4を有している、またはそう、左、右、左、右、および右から3は、状況が出ています。
4、右、右、またはこれだけ回転する必要がいったんあなたは左と右、左と右回転させるようにバランスをとることができる二回木のバランスを調整するために！
5、長い回転などの二倍にバランスまでの損失なので、バランスを調整するためのプロセスの時間複雑O(1)。
効果的な同様の極端なケースの平衡二分木のヘビ単一のリストの溶液が、平衡二分木、AVL木完璧ではないが、最大の欠点は、連続、削除ノードのノードの親から開始する必要が生じ、あなたはノードの不均衡を削除するときので、それが可能であるということですが、ルートノードに戻って、ツリーのAVLツリーが高い場合、それは中間ノードの数を決定する必要がある、効率が低くなることは明らかです！私たちはツリーと赤の後ろに2-3を習得する必要があります - 自分自身を書くために時間を割いて、黒の木....
この記事へのあなたの助けの少しがある場合には、賞賛の聖歌をポイントしてください、あなたは私の最大の動機であることに同意、ありがとう〜
最後に、そこに不足しているか正しくない場合、感謝し、正しい私の批判をしてください！ご質問がある場合は、返信する絶対初めてメッセージを残してください！
私はいくつかのJava学習教材との大きな波があり、あなたが公共の数に集中することを歓迎するJavaの電子書籍など周志明教師の深さJava仮想マシン、Javaプログラミングのアイデア、コア技術のボリューム、西方のデザインパターン、Javaの並行プログラミングの戦闘など、... ...聖書は、Tomcat上で速い車を言っていないのjava、行くがたです！主なものは、技術、憧れ技術、技術の追求を探ることである、良いポットの友人は、ああ来ていると述べました...
