yetao
/
hello-algo
mirror of https://github.com/krahets/hello-algo.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update AVL Tree.

Browse Source
pull/88/head
Yudong Jin 2 years ago
parent 2a2c0b74e8
commit 5e9a5524d4
3 changed files with 284 additions and 272 deletions
Show Stats Download Patch File Download Diff File

432
codes/java/chapter_tree/avl_tree.java
Unescape View File

@ -4,215 +4,223 @@
* Author: Krahets (krahets@163.com) * Author: Krahets (krahets@163.com)
*/ */
package chapter_tree; package chapter_tree;
import include.*; import include.*;
// Tree class // Tree class
class AVLTree { class AVLTree {
TreeNode root; // 根节点 TreeNode root; // 根节点
/* 获取结点高度 */ /* 获取结点高度 */
public int height(TreeNode node) { public int height(TreeNode node) {
// 空结点高度为 -1 ，叶结点高度为 0 // 空结点高度为 -1 ，叶结点高度为 0
return node == null ? -1 : node.height; return node == null ? -1 : node.height;
} }
/* 更新结点高度 */ /* 更新结点高度 */
private void updateHeight(TreeNode node) { private void updateHeight(TreeNode node) {
node.height = Math.max(height(node.left), height(node.right)) + 1; // 结点高度等于最高子树高度 + 1
} node.height = Math.max(height(node.left), height(node.right)) + 1;
}
/* 获取平衡因子 */
public int balanceFactor(TreeNode node) { /* 获取平衡因子 */
if (node == null) public int balanceFactor(TreeNode node) {
return 0; // 空结点平衡因子为 0
return height(node.left) - height(node.right); if (node == null) return 0;
} // 结点平衡因子 = 左子树高度 - 右子树高度
return height(node.left) - height(node.right);
/* 右旋操作 */ }
private TreeNode rightRotate(TreeNode node) {
TreeNode child = node.left; /* 右旋操作 */
TreeNode grandChild = child.right; private TreeNode rightRotate(TreeNode node) {
child.right = node; TreeNode child = node.left;
node.left = grandChild; TreeNode grandChild = child.right;
updateHeight(node); // 以 child 为原点，将 node 向右旋转
updateHeight(child); child.right = node;
return child; node.left = grandChild;
} // 更新结点高度
updateHeight(node);
/* 左旋操作 */ updateHeight(child);
private TreeNode leftRotate(TreeNode node) { // 返回旋转后子树的根节点
TreeNode child = node.right; return child;
TreeNode grandChild = child.left; }
child.left = node;
node.right = grandChild; /* 左旋操作 */
updateHeight(node); private TreeNode leftRotate(TreeNode node) {
updateHeight(child); TreeNode child = node.right;
return child; TreeNode grandChild = child.left;
} // 以 child 为原点，将 node 向左旋转
child.left = node;
/* 执行旋转操作，使该子树重新恢复平衡 */ node.right = grandChild;
private TreeNode rotate(TreeNode node) { // 更新结点高度
int balanceFactor = balanceFactor(node); updateHeight(node);
// 根据失衡情况分为四种操作：右旋、左旋、先左后右、先右后左 updateHeight(child);
if (balanceFactor > 1) { // 返回旋转后子树的根节点
if (balanceFactor(node.left) >= 0) { return child;
// 右旋 }
return rightRotate(node);
} else { /* 执行旋转操作，使该子树重新恢复平衡 */
// 先左旋后右旋 private TreeNode rotate(TreeNode node) {
node.left = leftRotate(node.left); // 获取结点 node 的平衡因子
return rightRotate(node); int balanceFactor = balanceFactor(node);
} // 左偏树
} if (balanceFactor > 1) {
if (balanceFactor < -1) { if (balanceFactor(node.left) >= 0) {
if (balanceFactor(node.right) <= 0) { // 右旋
// 左旋 return rightRotate(node);
return leftRotate(node); } else {
} else { // 先左旋后右旋
// 先右旋后左旋 node.left = leftRotate(node.left);
node.right = rightRotate(node.right); return rightRotate(node);
return leftRotate(node); }
} }
} // 右偏树
return node; if (balanceFactor < -1) {
} if (balanceFactor(node.right) <= 0) {
// 左旋
/* 插入结点 */ return leftRotate(node);
public TreeNode insert(int val) { } else {
root = insertHelper(root, val); // 先右旋后左旋
return root; node.right = rightRotate(node.right);
} return leftRotate(node);
}
/* 递归插入结点 */ }
private TreeNode insertHelper(TreeNode node, int val) { // 平衡树，无需旋转，直接返回
// 1. 查找插入位置，并插入结点 return node;
if (node == null) }
return new TreeNode(val);
if (val < node.val) /* 插入结点 */
node.left = insertHelper(node.left, val); public TreeNode insert(int val) {
else if (val > node.val) root = insertHelper(root, val);
node.right = insertHelper(node.right, val); return root;
else }
return node; // 重复结点则直接返回
// 2. 更新结点高度 /* 递归插入结点（辅助函数） */
updateHeight(node); private TreeNode insertHelper(TreeNode node, int val) {
// 3. 执行旋转操作，使该子树重新恢复平衡 if (node == null) return new TreeNode(val);
node = rotate(node); /* 1. 查找插入位置，并插入结点 */
// 返回该子树的根节点 if (val < node.val)
return node; node.left = insertHelper(node.left, val);
} else if (val > node.val)
node.right = insertHelper(node.right, val);
/* 删除结点 */ else
public TreeNode remove(int val) { return node; // 重复结点不插入，直接返回
root = removeHelper(root, val); updateHeight(node); // 更新结点高度
return root; /* 2. 执行旋转操作，使该子树重新恢复平衡 */
} node = rotate(node);
// 返回子树的根节点
/* 递归删除结点 */ return node;
private TreeNode removeHelper(TreeNode node, int val) { }
// 1. 查找结点，并删除之
if (node == null) /* 删除结点 */
return null; public TreeNode remove(int val) {
if (val < node.val) root = removeHelper(root, val);
node.left = removeHelper(node.left, val); return root;
else if (val > node.val) }
node.right = removeHelper(node.right, val);
else { /* 递归删除结点（辅助函数） */
if (node.left == null || node.right == null) { private TreeNode removeHelper(TreeNode node, int val) {
TreeNode child = node.left != null ? node.left : node.right; if (node == null) return null;
// 子结点数量 = 0 ，直接删除 node 并返回 /* 1. 查找结点，并删除之 */
if (child == null) if (val < node.val)
return null; node.left = removeHelper(node.left, val);
// 子结点数量 = 1 ，直接删除 node else if (val > node.val)
else node.right = removeHelper(node.right, val);
node = child; else {
} else { if (node.left == null || node.right == null) {
// 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点 TreeNode child = node.left != null ? node.left : node.right;
TreeNode temp = minNode(node.right); // 子结点数量 = 0 ，直接删除 node 并返回
node.right = removeHelper(node.right, temp.val); if (child == null)
node.val = temp.val; return null;
} // 子结点数量 = 1 ，直接删除 node
} else
// 2. 更新结点高度 node = child;
updateHeight(node); } else {
// 3. 执行旋转操作，使该子树重新恢复平衡 // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
node = rotate(node); TreeNode temp = minNode(node.right);
// 返回该子树的根节点 node.right = removeHelper(node.right, temp.val);
return node; node.val = temp.val;
} }
}
/* 获取最小结点 */ updateHeight(node); // 更新结点高度
private TreeNode minNode(TreeNode node) { /* 2. 执行旋转操作，使该子树重新恢复平衡 */
if (node == null) return node; node = rotate(node);
// 循环访问左子结点，直到叶结点时为最小结点，跳出 // 返回子树的根节点
while (node.left != null) { return node;
node = node.left; }
}
return node; /* 获取最小结点 */
} private TreeNode minNode(TreeNode node) {
if (node == null) return node;
/* 查找结点 */ // 循环访问左子结点，直到叶结点时为最小结点，跳出
public TreeNode search(int val) { while (node.left != null) {
TreeNode cur = root; node = node.left;
// 循环查找，越过叶结点后跳出 }
while (cur != null) { return node;
// 目标结点在 root 的右子树中 }
if (cur.val < val) cur = cur.right;
// 目标结点在 root 的左子树中 /* 查找结点 */
else if (cur.val > val) cur = cur.left; public TreeNode search(int val) {
// 找到目标结点，跳出循环 TreeNode cur = root;
else break; // 循环查找，越过叶结点后跳出
} while (cur != null) {
// 返回目标结点 // 目标结点在 root 的右子树中
return cur; if (cur.val < val)
} cur = cur.right;
} // 目标结点在 root 的左子树中
else if (cur.val > val)
cur = cur.left;
public class avl_tree { // 找到目标结点，跳出循环
static void testInsert(AVLTree tree, int val) { else
tree.insert(val); break;
System.out.println("\n插入结点 " + val + " 后，AVL 树为"); }
PrintUtil.printTree(tree.root); // 返回目标结点
} return cur;
}
static void testRemove(AVLTree tree, int val) { }
tree.remove(val);
System.out.println("\n删除结点 " + val + " 后，AVL 树为"); public class avl_tree {
PrintUtil.printTree(tree.root); static void testInsert(AVLTree tree, int val) {
} tree.insert(val);
System.out.println("\n插入结点 " + val + " 后，AVL 树为");
public static void main(String[] args) { PrintUtil.printTree(tree.root);
/* 初始化空 AVL 树 */ }
AVLTree avlTree = new AVLTree();
static void testRemove(AVLTree tree, int val) {
/* 插入结点 */ tree.remove(val);
// 请关注插入结点后，AVL 树是如何保持平衡的 System.out.println("\n删除结点 " + val + " 后，AVL 树为");
testInsert(avlTree, 1); PrintUtil.printTree(tree.root);
testInsert(avlTree, 2); }
testInsert(avlTree, 3);
testInsert(avlTree, 4); public static void main(String[] args) {
testInsert(avlTree, 5); /* 初始化空 AVL 树 */
testInsert(avlTree, 8); AVLTree avlTree = new AVLTree();
testInsert(avlTree, 7);
testInsert(avlTree, 9); /* 插入结点 */
testInsert(avlTree, 10); // 请关注插入结点后，AVL 树是如何保持平衡的
testInsert(avlTree, 6); testInsert(avlTree, 1);
testInsert(avlTree, 2);
/* 插入重复结点 */ testInsert(avlTree, 3);
testInsert(avlTree, 7); testInsert(avlTree, 4);
testInsert(avlTree, 5);
/* 删除结点 */ testInsert(avlTree, 8);
// 请关注删除结点后，AVL 树是如何保持平衡的 testInsert(avlTree, 7);
testRemove(avlTree, 8); // 删除度为 0 的结点 testInsert(avlTree, 9);
testRemove(avlTree, 5); // 删除度为 1 的结点 testInsert(avlTree, 10);
testRemove(avlTree, 4); // 删除度为 2 的结点 testInsert(avlTree, 6);
/* 查询结点 */ /* 插入重复结点 */
TreeNode node = avlTree.search(7); testInsert(avlTree, 7);
System.out.println("\n查找到的结点对象为 " + node + "，结点值 = " + node.val);
} /* 删除结点 */
} // 请关注删除结点后，AVL 树是如何保持平衡的
testRemove(avlTree, 8); // 删除度为 0 的结点
testRemove(avlTree, 5); // 删除度为 1 的结点
testRemove(avlTree, 4); // 删除度为 2 的结点
/* 查询结点 */
TreeNode node = avlTree.search(7);
System.out.println("\n查找到的结点对象为 " + node + "，结点值 = " + node.val);
}
}

122
docs/chapter_tree/avl_tree.md
Unescape View File

@ -1,4 +1,8 @@
# AVL 树 ---
comments: true
---
# AVL 树 *
在「二叉搜索树」章节中提到，在进行多次插入与删除操作后，二叉搜索树可能会退化为链表。此时所有操作的时间复杂度都会由 $O(\log n)$ 劣化至 $O(n)$ 。 在「二叉搜索树」章节中提到，在进行多次插入与删除操作后，二叉搜索树可能会退化为链表。此时所有操作的时间复杂度都会由 $O(\log n)$ 劣化至 $O(n)$ 。
@ -38,43 +42,43 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
=== "C++" === "C++"
```cpp title="avl_tree.cpp" ```cpp title="avl_tree.cpp"
``` ```
=== "Python" === "Python"
```python title="avl_tree.py" ```python title="avl_tree.py"
``` ```
=== "Go" === "Go"
```go title="avl_tree.go" ```go title="avl_tree.go"
``` ```
=== "JavaScript" === "JavaScript"
```js title="avl_tree.js" ```js title="avl_tree.js"
``` ```
=== "TypeScript" === "TypeScript"
```typescript title="avl_tree.ts" ```typescript title="avl_tree.ts"
``` ```
=== "C" === "C"
```c title="avl_tree.c" ```c title="avl_tree.c"
``` ```
=== "C#" === "C#"
```csharp title="avl_tree.cs" ```csharp title="avl_tree.cs"
``` ```
「结点高度」是最远叶结点到该结点的距离，即走过的「边」的数量。需要特别注意，**叶结点的高度为 0 ，空结点的高度为 -1** 。我们封装两个工具函数，分别用于获取与更新结点的高度。 「结点高度」是最远叶结点到该结点的距离，即走过的「边」的数量。需要特别注意，**叶结点的高度为 0 ，空结点的高度为 -1** 。我们封装两个工具函数，分别用于获取与更新结点的高度。
@ -98,43 +102,43 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
=== "C++" === "C++"
```cpp title="avl_tree.cpp" ```cpp title="avl_tree.cpp"
``` ```
=== "Python" === "Python"
```python title="avl_tree.py" ```python title="avl_tree.py"
``` ```
=== "Go" === "Go"
```go title="avl_tree.go" ```go title="avl_tree.go"
``` ```
=== "JavaScript" === "JavaScript"
```js title="avl_tree.js" ```js title="avl_tree.js"
``` ```
=== "TypeScript" === "TypeScript"
```typescript title="avl_tree.ts" ```typescript title="avl_tree.ts"
``` ```
=== "C" === "C"
```c title="avl_tree.c" ```c title="avl_tree.c"
``` ```
=== "C#" === "C#"
```csharp title="avl_tree.cs" ```csharp title="avl_tree.cs"
``` ```
### 结点平衡因子 ### 结点平衡因子
@ -156,43 +160,43 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
=== "C++" === "C++"
```cpp title="avl_tree.cpp" ```cpp title="avl_tree.cpp"
``` ```
=== "Python" === "Python"
```python title="avl_tree.py" ```python title="avl_tree.py"
``` ```
=== "Go" === "Go"
```go title="avl_tree.go" ```go title="avl_tree.go"
``` ```
=== "JavaScript" === "JavaScript"
```js title="avl_tree.js" ```js title="avl_tree.js"
``` ```
=== "TypeScript" === "TypeScript"
```typescript title="avl_tree.ts" ```typescript title="avl_tree.ts"
``` ```
=== "C" === "C"
```c title="avl_tree.c" ```c title="avl_tree.c"
``` ```
=== "C#" === "C#"
```csharp title="avl_tree.cs" ```csharp title="avl_tree.cs"
``` ```
!!! note !!! note
@ -237,7 +241,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
// 更新结点高度 // 更新结点高度
updateHeight(node); updateHeight(node);
updateHeight(child); updateHeight(child);
// 返回旋转后的根节点 // 返回旋转后子树的根节点
return child; return child;
} }
``` ```
@ -245,43 +249,43 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "C++" === "C++"
```cpp title="avl_tree.cpp" ```cpp title="avl_tree.cpp"
``` ```
=== "Python" === "Python"
```python title="avl_tree.py" ```python title="avl_tree.py"
``` ```
=== "Go" === "Go"
```go title="avl_tree.go" ```go title="avl_tree.go"
``` ```
=== "JavaScript" === "JavaScript"
```js title="avl_tree.js" ```js title="avl_tree.js"
``` ```
=== "TypeScript" === "TypeScript"
```typescript title="avl_tree.ts" ```typescript title="avl_tree.ts"
``` ```
=== "C" === "C"
```c title="avl_tree.c" ```c title="avl_tree.c"
``` ```
=== "C#" === "C#"
```csharp title="avl_tree.cs" ```csharp title="avl_tree.cs"
``` ```
### Case 2 - 左旋 ### Case 2 - 左旋
@ -303,7 +307,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
// 更新结点高度 // 更新结点高度
updateHeight(node); updateHeight(node);
updateHeight(child); updateHeight(child);
// 返回旋转后的根节点 // 返回旋转后子树的根节点
return child; return child;
} }
``` ```
@ -311,43 +315,43 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "C++" === "C++"
```cpp title="avl_tree.cpp" ```cpp title="avl_tree.cpp"
``` ```
=== "Python" === "Python"
```python title="avl_tree.py" ```python title="avl_tree.py"
``` ```
=== "Go" === "Go"
```go title="avl_tree.go" ```go title="avl_tree.go"
``` ```
=== "JavaScript" === "JavaScript"
```js title="avl_tree.js" ```js title="avl_tree.js"
``` ```
=== "TypeScript" === "TypeScript"
```typescript title="avl_tree.ts" ```typescript title="avl_tree.ts"
``` ```
=== "C" === "C"
```c title="avl_tree.c" ```c title="avl_tree.c"
``` ```
=== "C#" === "C#"
```csharp title="avl_tree.cs" ```csharp title="avl_tree.cs"
``` ```
### Case 3 - 先左后右 ### Case 3 - 先左后右
@ -420,43 +424,43 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "C++" === "C++"
```cpp title="avl_tree.cpp" ```cpp title="avl_tree.cpp"
``` ```
=== "Python" === "Python"
```python title="avl_tree.py" ```python title="avl_tree.py"
``` ```
=== "Go" === "Go"
```go title="avl_tree.go" ```go title="avl_tree.go"
``` ```
=== "JavaScript" === "JavaScript"
```js title="avl_tree.js" ```js title="avl_tree.js"
``` ```
=== "TypeScript" === "TypeScript"
```typescript title="avl_tree.ts" ```typescript title="avl_tree.ts"
``` ```
=== "C" === "C"
```c title="avl_tree.c" ```c title="avl_tree.c"
``` ```
=== "C#" === "C#"
```csharp title="avl_tree.cs" ```csharp title="avl_tree.cs"
``` ```
## AVL 树常用操作 ## AVL 树常用操作
@ -495,43 +499,43 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "C++" === "C++"
```cpp title="avl_tree.cpp" ```cpp title="avl_tree.cpp"
``` ```
=== "Python" === "Python"
```python title="avl_tree.py" ```python title="avl_tree.py"
``` ```
=== "Go" === "Go"
```go title="avl_tree.go" ```go title="avl_tree.go"
``` ```
=== "JavaScript" === "JavaScript"
```js title="avl_tree.js" ```js title="avl_tree.js"
``` ```
=== "TypeScript" === "TypeScript"
```typescript title="avl_tree.ts" ```typescript title="avl_tree.ts"
``` ```
=== "C" === "C"
```c title="avl_tree.c" ```c title="avl_tree.c"
``` ```
=== "C#" === "C#"
```csharp title="avl_tree.cs" ```csharp title="avl_tree.cs"
``` ```
### 删除结点 ### 删除结点
@ -592,43 +596,43 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "C++" === "C++"
```cpp title="avl_tree.cpp" ```cpp title="avl_tree.cpp"
``` ```
=== "Python" === "Python"
```python title="avl_tree.py" ```python title="avl_tree.py"
``` ```
=== "Go" === "Go"
```go title="avl_tree.go" ```go title="avl_tree.go"
``` ```
=== "JavaScript" === "JavaScript"
```js title="avl_tree.js" ```js title="avl_tree.js"
``` ```
=== "TypeScript" === "TypeScript"
```typescript title="avl_tree.ts" ```typescript title="avl_tree.ts"
``` ```
=== "C" === "C"
```c title="avl_tree.c" ```c title="avl_tree.c"
``` ```
=== "C#" === "C#"
```csharp title="avl_tree.cs" ```csharp title="avl_tree.cs"
``` ```
### 查找结点 ### 查找结点

2
mkdocs.yml
Unescape View File

@ -154,7 +154,7 @@ nav:
- 二叉树（Binary Tree）: chapter_tree/binary_tree.md - 二叉树（Binary Tree）: chapter_tree/binary_tree.md
- 二叉树常见类型: chapter_tree/binary_tree_types.md - 二叉树常见类型: chapter_tree/binary_tree_types.md
- 二叉搜索树: chapter_tree/binary_search_tree.md - 二叉搜索树: chapter_tree/binary_search_tree.md
- AVL 树: chapter_tree/avl_tree.md - AVL 树 *: chapter_tree/avl_tree.md
- 小结: chapter_tree/summary.md - 小结: chapter_tree/summary.md
- 查找算法: - 查找算法:
- 线性查找: chapter_searching/linear_search.md - 线性查找: chapter_searching/linear_search.md

Write Preview
Loading…
Cancel
Save