文章目录
树结构
1, 二叉树的基本操作
遍历&搜索&删除
- 遍历
- 前序
- 中序
- 后序
- 搜索
- 前序
- 中序
- 后序
- 删除
- 这里删除比较简单，如果是叶子节点，把叶子节点删除，如果是根节点，把对应的树给删除
Tree
package com.shangguigu.dachang.algrithm.A09_basicTree;
/**
* @author : 不二
* @date : 2022/4/21-下午10:04
* @desc :
**/
public class Tree {
TreeNode root;
public void deleteNode(int val) {
if (root == null) {
return;
}
if (root.val == val) {
root = null;
}
root.deleteNode(val);
}
public TreeNode postorderSearch(int val) {
return root.postorderSearch(val);
}
public TreeNode inorderSearch(int val) {
return root.inorderSearch(val);
}
public TreeNode preorderSearch(int val) {
return root.preorderSearch(val);
}
// 以当前节点为根节点：后序遍历
public void postorderTraversal(){
root.postorderTraversal();
}
// 以当前节点为根节点：中序遍历
public void inorderTraversal(){
root.inorderTraversal();
}
// 以当前节点为根节点：前序遍历
public void preorderTraversal(){
root.preorderTraversal();
}
}
TreeNode
package com.shangguigu.dachang.algrithm.A09_basicTree;
/**
* @author : 不二
* @date : 2022/4/20-下午8:06
* @desc :
**/
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode() {}
public TreeNode(int val) { this.val = val; }
public TreeNode(int val, TreeNode left, TreeNode right) {
this.val = val;
this.left = left;
this.right = right;
}
@Override
public String toString() {
return "TreeNode{" +
"val=" + val +
'}';
}
/**
* 删除节点
* 如果是叶子节点，把叶子节点直接删除，如果是根节点，那么把以这个根节点为根的树给直接删除掉
* @param val
*/
public void deleteNode(int val) {
// 能进来，说明root肯定不为null
if (this.left != null) {
if (this.left.val == val) {
this.left = null;
return;
}
// 如果能走下来，那说明左都不是要删除的对象
this.left.deleteNode(val);
}
if (this.right != null) {
if (this.right.val == val) {
this.right = null;
return;
}
this.right.deleteNode(val);
}
}
public TreeNode postorderSearch(int val) {
if (this.left != null) {
return this.left.postorderSearch(val);
}
if (this.right != null) {
return this.right.postorderSearch(val);
}
if (this.val == val) {
return this;
}
return null;
}
public TreeNode inorderSearch(int val) {
if (this.left != null) {
return this.left.inorderSearch(val);
}
if (this.val == val) {
return this;
}
if (this.right != null) {
return this.right.inorderSearch(val);
}
return null;
}
public TreeNode preorderSearch(int val) {
if (this.val == val) {
return this;
}
if (this.left != null) {
return this.left.preorderSearch(val);
}
if (this.right != null) {
return this.right.preorderSearch(val);
}
return null;
}
// 以当前节点为根节点：后序遍历
public void postorderTraversal(){
if (this.left != null) {
this.left.postorderTraversal();
}
if (this.right != null) {
this.right.postorderTraversal();
}
System.out.println(this.val);
}
// 以当前节点为根节点：中序遍历
public void inorderTraversal(){
if (this.left != null) {
this.left.inorderTraversal();
}
System.out.println(this.val);
if (this.right != null) {
this.right.inorderTraversal();
}
}
// 以当前节点为根节点：前序遍历
public void preorderTraversal(){
System.out.println(this.val);
if (this.left != null) {
this.left.preorderTraversal();
}
if (this.right != null) {
this.right.preorderTraversal();
}
}
}
2, 顺序存储二叉树(二叉树通过数组存储)
ArrBinaryTree
package com.shangguigu.dachang.algrithm.A09_basicTree;
/**
* @author : 不二
* @date : 2022/4/21-下午11:29
* @desc :
**/
public class ArrBinaryTree {
int[] arr;
// 给定一个数组，可以通过前序，中序，后序遍历
public ArrBinaryTree(int[] arr) {
this.arr = arr;
}
public void postorderTraversal(int index) {
if (index > arr.length - 1) {
return;
}
int leftIndex = 2 * index + 1;
int rightIndex = 2 * index + 2;
postorderTraversal(leftIndex);
postorderTraversal(rightIndex);
System.out.println(arr[index]);
}
public void inorderTraversal(int index) {
if (index > arr.length - 1) {
return;
}
int leftIndex = 2 * index + 1;
int rightIndex = 2 * index + 2;
inorderTraversal(leftIndex);
System.out.println(arr[index]);
inorderTraversal(rightIndex);
}
public void preorderTraversal(int index) {
if (index > arr.length - 1) {
return;
}
int leftIndex = 2 * index + 1;
int rightIndex = 2 * index + 2;
System.out.println(arr[index]);
preorderTraversal(leftIndex);
preorderTraversal(rightIndex);
}
}
3, 线索化二叉树(左右指针空的指针：左指针指向前序节点，右指针指向后序节点)
- n个节点的二叉树链表中含有：==n+1(计算公式:2n-(n-1), 其中2n为n个节点的所有指针数，n-1为n个节点彼此连接的指针数。所有指针减去连接的指针，剩下的就是空指针)==个空指针域。
- 利用二叉链表中的空指针域，存放指向节点在某种遍历次序下的前驱和后继节点的指针，这种附加的指针叫做线索
- 加上这种线索的二叉树链表又被称为线索链表，相应的二叉树被称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树又分为：前序线索二叉树，中序线索二叉树，后续线索二叉树。
- 一个节点的前一个节点，称为前驱节点
- 一个节点的后一个节点，称为后继节点
线索化以及线索化后的二叉树的遍历
- 其中二叉树的遍历超级巧妙。需要仔细品味
- 画图更容易理解一些
A08_threadBinaryTree
package com.shangguigu.dachang.algrithm.A09_basicTree;
import java.util.List;
/**
* @author : 不二
* @date : 2022/4/22-下午2:28
* @desc : 线索化二叉树
**/
public class A08_threadBinaryTree {
public static void main(String[] args) {
TreeNode tn1 = new TreeNode(1);
// TreeNode tn_2 = new TreeNode(null);
TreeNode tn2 = new TreeNode(2);
TreeNode tn3 = new TreeNode(3);
tn1.right = tn2;
tn2.left = tn3;
Tree tree = new Tree();
tree.root = tn1;
tree.treeInorderThreaded();
tree.inorderThreadedTreeTraversal();
System.out.println("----");
}
}
Tree
package com.shangguigu.dachang.algrithm.A09_basicTree;
/**
* @author : 不二
* @date : 2022/4/21-下午10:04
* @desc :
**/
public class Tree {
TreeNode root;
public void deleteNode(int val) {
if (root == null) {
return;
}
if (root.val == val) {
root = null;
}
root.deleteNode(val);
}
public void inorderThreadedTreeTraversal() {
TreeNode.inorderThreadedTreeTraversal(root);
}
public void treeInorderThreaded(){
TreeNode.treeInorderThreaded(root);
}
public TreeNode postorderSearch(int val) {
return root.postorderSearch(val);
}
public TreeNode inorderSearch(int val) {
return root.inorderSearch(val);
}
public TreeNode preorderSearch(int val) {
return root.preorderSearch(val);
}
// 以当前节点为根节点：后序遍历
public void postorderTraversal(){
root.postorderTraversal();
}
// 以当前节点为根节点：中序遍历
public void inorderTraversal(){
root.inorderTraversal();
}
// 以当前节点为根节点：前序遍历
public void preorderTraversal(){
root.preorderTraversal();
}
}
TreeNode
package com.shangguigu.dachang.algrithm.A09_basicTree;
/**
* @author : 不二
* @date : 2022/4/20-下午8:06
* @desc :
**/
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
// 下面这两个属性只有是线索化二叉树的时候才会有意义
// 0代表当前左指针指向左子树，1代表左指针指向中序遍历的前一个节点
int leftType;
// 0代表当前右指针指向右子树，1代表右指针指向中序遍历的后一个节点
int rightType;
TreeNode() {}
public TreeNode(int val) { this.val = val; }
public TreeNode(int val, TreeNode left, TreeNode right) {
this.val = val;
this.left = left;
this.right = right;
}
@Override
public String toString() {
return "TreeNode{" +
"val=" + val +
'}';
}
/**
* 大概是算搞明白了
* @param root
*/
public static void inorderThreadedTreeTraversal(TreeNode root) {
if (root == null) {
return;
}
TreeNode node = root;
while (node != null) {
// 首次找到leftType = 1的时候，就是头节点了
while (node.leftType == 0) {
node = node.left;
}
// 这里说明找到了第一个节点
System.out.println(node.val);
// 当前节点右指针类型是1， 则右指针指向的是 中序遍历的后一个节点
while (node.rightType == 1) {
node = node.right;
System.out.println(node.val);
}
// 如果当前节点的右指针类型是0，那么就:重新开始上面的逻辑即可
node = node.right;
}
}
// 线索化的时候用得上
static TreeNode preNode;
// 这里是对树进行中序遍历线索化
public static void treeInorderThreaded(TreeNode node) {
if (node == null) {
return;
}
treeInorderThreaded(node.left);
// 如果是中序遍历，这里打印就可以了。
// 我们这里是进行线索化，所以这里把对应打印的代码替换为线索化代码就可以
// System.out.println(root.val);
// 先看下前一个节点的右指针
if (preNode != null && preNode.right == null) {
preNode.right = node;
preNode.rightType = 1;
}
// 然后设置一下当前节点的左指针
if (node.left == null) {
node.left = preNode;
node.leftType = 1;
}
preNode = node;
treeInorderThreaded(node.right);
}
/**
* 删除节点
* 如果是叶子节点，把叶子节点直接删除，如果是根节点，那么把以这个根节点为根的树给直接删除掉
* @param val
*/
public void deleteNode(int val) {
// 能进来，说明root肯定不为null
if (this.left != null) {
if (this.left.val == val) {
this.left = null;
return;
}
// 如果能走下来，那说明左都不是要删除的对象
this.left.deleteNode(val);
}
if (this.right != null) {
if (this.right.val == val) {
this.right = null;
return;
}
this.right.deleteNode(val);
}
}
public TreeNode postorderSearch(int val) {
if (this.left != null) {
return this.left.postorderSearch(val);
}
if (this.right != null) {
return this.right.postorderSearch(val);
}
if (this.val == val) {
return this;
}
return null;
}
public TreeNode inorderSearch(int val) {
if (this.left != null) {
return this.left.inorderSearch(val);
}
if (this.val == val) {
return this;
}
if (this.right != null) {
return this.right.inorderSearch(val);
}
return null;
}
public TreeNode preorderSearch(int val) {
if (this.val == val) {
return this;
}
if (this.left != null) {
return this.left.preorderSearch(val);
}
if (this.right != null) {
return this.right.preorderSearch(val);
}
return null;
}
// 以当前节点为根节点：后序遍历
public void postorderTraversal(){
if (this.left != null) {
this.left.postorderTraversal();
}
if (this.right != null) {
this.right.postorderTraversal();
}
System.out.println(this.val);
}
// 以当前节点为根节点：中序遍历
public void inorderTraversal(){
if (this.left != null) {
this.left.inorderTraversal();
}
System.out.println(this.val);
if (this.right != null) {
this.right.inorderTraversal();
}
}
// 以当前节点为根节点：前序遍历
public void preorderTraversal(){
System.out.println(this.val);
if (this.left != null) {
this.left.preorderTraversal();
}
if (this.right != null) {
this.right.preorderTraversal();
}
}
}
4, 树的应用：堆排序
- 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它最好，最坏以及平均复杂度均为O(nlogn)，它是不稳定的排序
package com.shangguigu.dachang.algrithm.A08_sort;
import java.util.Arrays;
/**
* @author : 不二
* @date : 2022/4/19-下午3:42
* @desc : 堆排序(通过二叉树构建大顶堆)
* 堆排序代码编写：构建大顶堆或者小顶堆
**/
public class A08_HeapSort {
public static void main(String[] args) {
// int[] nums = {9, 10, 100, 3, 4, 20};
int[] nums = {3, -1};
heapSort(nums);
System.out.println(Arrays.toString(nums));
}
private static void heapSort(int[] nums) {
// 这里需要先构建成大顶堆方便进行后续处理
// 首次构建大顶堆，需要从最右下，先同级往左， 然后再往上进行构建
// 这里i要大于等于0， 因为最上级根节点也需要调整
// arr.length / 2 - 1 是最下面的第一个非叶子节点
for (int i = nums.length / 2 - 1; i >= 0; i--) {
// 这里的作用是：把最大值移动到节点i处。i是从最后最左的一个非叶子开始遍历到最上面到，所以最后遍历结束之后就会变成大顶堆
adjustHeap(nums, i, nums.length);
}
// 构建成大顶堆之后，最大值就是0位置的数据了，把最大值移动到末尾
// 再根据adjustHeap把这个最小值移动到底层即可
int temp;
for (int i = nums.length - 1; i > 0; i--) {
temp = nums[i];
nums[i] = nums[0];
nums[0] = temp;
adjustHeap(nums, 0, i);
}
}
/**
*
* @param arr: 给定数组
* @param i：i是节点，这里调整i及i以下的节点，
* @param length
*/
public static void adjustHeap(int[] arr, int i, int length) {
// 先把i位置也就是当前调整的根节点数据记录下来
int temp = arr[i];
// i位置的两个子节点分别是：2i+1，2i+2
for (int j = 2 * i + 1; j < length; j = 2 * j + 1) {
// 其实就是找根当前节点有关系的下层节点，一层一层遍历下去
if (j + 1 < length && arr[j + 1] > arr[j]) {
// 两个子节点，哪个节点的数据大，就接着从大节点往下层找
j = j + 1;
}
// 如果下层已经不大于上层了，就可以退出了。
// (这里其实都是在：先构建成大顶堆后才发挥作用的，如果我这里i是根部，但是本身数据不是大顶堆，这里是没啥用的哈)
if (arr[j] < temp) {
break;
} else{
// 说明下层有比上层大的数据
arr[i] = arr[j];
// 这个是下次交换就交换本次这里的这个位置的数据，而非最原始的i了
i = j;
}
// 找一层换一层哈
// 如果走完之后， 说明当前i处就是把最小值放置的位置
arr[i] = temp;
// 至此，最大值依次往上走， 最小值被挪至最后一行(最后一级)
}
}
}
5, Huffman Tree(赫夫曼树)
- 给定n个权值作为n个叶子节点，构造一棵二叉树，若该树的带权路径长度wpl:weighted path length达到最小，则称为最优二叉树，即是Huffman Tree
- 赫夫曼树是带权路径最短的树，权值较大的节点离根较近
构建HuffmanTree的步骤
- 把从小到大进行排序，每个元素是一个节点，每个节点看作是一个最简单的二叉树
- 取出跟节点权值最小的两个二叉树组成一棵新的二叉树，该新二叉树根节点的权值是前面两棵二叉树根节点权值加和
- 再将这棵新的二叉树，以根节点权值大小再次排序。
- 不断重复1，2，3步骤，直到数列中， 所有的数据都被处理，最后得到一棵二叉树
// 后续补充
6, binarySortTree(BST:二叉排序树/二叉搜索树)
- 对于二叉排序树的任何一个非叶子节点， 要求：
- 左子节点的值 < 当前节点的值
- 右子节点的值 > 当前节点的值
- 特别说明：如果有相同的值，可以将该节点放在左子节点或者右子节点，按照规则存放即可
- 二叉排序树特性：中序遍历的结果刚好是从小到大打印
- 如下代码显示了二叉排序树的创建，新增，删除节点等
package com.shangguigu.dachang.algrithm.A09_basicTree;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;
/**
* @author : 不二
* @date : 2022/4/22-下午4:43
* @desc : 二叉排序树
* 为了方便直接处理，我们把节点直接写在内部
**/
public class A11_binarySortTree {
public static void main(String[] args) {
// int[] nums = {3, 4, 1, 7, 6, 5, 2, 0, 9, 8, 10};
int[] nums = {1, 15, 14, 17, 7, 2, 12, 3, 9, 11};
// int[] nums = {2, 1, 3, 4};
BSTree bsTree = new BSTree();
for (int i = 0; i < nums.length; i++) {
// 把数组中数据添加到二叉排序树中
bsTree.addNode(new BSTree.Node(nums[i]));
}
// 现在拿到一个BST树，对其平衡
List<List<Integer>> lists1 = bsTree.levelorderTraversal();
System.out.println(lists1);
// 二叉排序树的中序遍历就相当于排好序了
// bsTree.preorderTraversal();
// bsTree.deleteNode(new BSTree.Node(0));
// bsTree.deleteNode(new BSTree.Node(1));
// bsTree.deleteNode(new BSTree.Node(2));
// bsTree.deleteNode(new BSTree.Node(3));
// bsTree.deleteNode(new BSTree.Node(4));
// bsTree.deleteNode(new BSTree.Node(5));
bsTree.root = BSTree.balanceBST(bsTree.root);
// 二叉排序树的中序遍历就相当于排好序了
// bsTree.inorderTraversal();
List<List<Integer>> lists = bsTree.levelorderTraversal();
System.out.println(lists);
}
}
class BSTree{
/**
* 这里做成内部类
*/
static class Node {
int val;
Node left;
Node right;
public Node(int val) {
this.val = val;
}
}
Node root;
// 计算高度
// 给定node，计算改node的高度
public static int height(Node node) {
if (node == null) {
return 0;
}
return 1 + Math.max(height(node.left), height(node.right));
}
/**
* 把bst树转换成平衡二叉树
* @param root
* @return
*/
public static Node balanceBST(Node root) {
if (root == null) {
return null;
}
root.left = balanceBST(root.left);
root.right = balanceBST(root.right);
if (height(root.left) - height(root.right) > 1) {
// 说明不是平衡树，左边高于右边, 向右旋转
if (height(root.left.right) > height(root.left.left)) {
root.left = leftRotate(root.left);
}
root = rightRotate(root);
/*// 如果对于此处的root调整后，要重新调用以防止旋转后的数据依然没有平衡
root.left = balanceBST(root.left);
root.right = balanceBST(root.right);*/
root = balanceBST(root);
} else if (height(root.right) - height(root.left) >1) {
// 说明不是平衡树， 右边高于左边
if (height(root.right.left) > height(root.right.right)) {
root.right = rightRotate(root.right);
}
root = leftRotate(root);
/*// 如果对于此处的root调整后，要重新调用以防止旋转后的数据依然没有平衡
root.left = balanceBST(root.left);
root.right = balanceBST(root.right);*/
root = balanceBST(root);
}
System.out.println(root.val + ": 高度是：" + height(root));
System.out.println(root.val + ":左子高度是：" + height(root.left));
System.out.println(root.val + ":右子高度是：" + height(root.right));
return root;
}
// 如果左子树的高度比右子树高度 高出超过1的高度，需要把树进行右旋转
public static Node rightRotate(Node node){
// 不需要限定。有些情况等于1也需要旋转
/*while (height(node.left) - height(node.right) > 1) {
}*/
// 1, 首先创建一个新的节点，和root节点值一致
Node theTmpNode = new Node(node.val);
// 该新的节点是作为root的临时哨兵节点
// 该哨兵节点右侧不变和root一样
theTmpNode.right = node.right;
// 该哨兵节点左侧变为：root左侧节点的右侧节点(因为稍后要把root的左侧节点提升到root位置)
theTmpNode.left = node.left.right;
// 2, 然后把root的左侧节点提神到
node = node.left;
// 3, 最后再把提升后的当前root右侧关联到哨兵节点上
// 左侧不需要更改
node.right = theTmpNode;
return node;
}
// 右子树的高度比左子树高度 高出超过1的高度，需要把树进行左旋转
public static Node leftRotate(Node node){
// 说明不是平衡二叉树，需要进行左旋转
// 不需要限定。有些情况等于1也需要旋转
/*while (height(node.right) - height(node.left) > 1) {
}*/
// 1, 首先创建一个新的节点，和root节点值一致
Node theTmpNode = new Node(node.val);
// 该新的节点是作为root这个节点的临时哨兵节点
// 该哨兵节点左侧不变和root一样
theTmpNode.left = node.left;
// 右侧变为：root右侧节点的左侧节点(因为稍后要把右侧节点提升为root)
theTmpNode.right = node.right.left;
// 2, 然后把root的右侧节点提升到root位置
node = node.right;
// 3，然后再把root的左侧关联到新建的临时哨兵节点，
// 右侧关联到：之前root右侧节点的右侧(右侧这个没有断开过，所以不需要设置)
node.left = theTmpNode;
return node;
}
/**
* 删除节点相对比较麻烦：可以从小到大入手：
* 1，如果是删除的叶子节点
* 2，如果删除的是非root的根节点，而且只有一个叶子
* 2.1, left叶子存在
* 2.2, right叶子存在
* 3，如果删除的是非root的根节点，但是有两个叶子
* 4，如果删除的是root节点
* @param node
*/
public void deleteNode(Node node) {
Node preNode = null;
boolean isLeft = false;
Node currNode = root;
// Node nxtNode = null;
while (true) {
if (node.val < currNode.val) {
if (currNode.left == null) {
break;
}
preNode = currNode;
isLeft = true;
currNode = currNode.left;
} else if (node.val > currNode.val) {
if (currNode.right == null) {
break;
}
preNode = currNode;
isLeft = false;
currNode = currNode.right;
} else {
//说明相等了
break;
}
}
System.out.println(currNode);
if (node.val != currNode.val) {
return;
}
if (preNode == null) {
// 说明是root节点
root = currNode.right;
// 直接把当前的左侧 挂在新的节点的 最左即可
Node theTmpLeft = currNode.left;
Node thePositionNode = currNode.right;
while (thePositionNode.left != null) {
thePositionNode = thePositionNode.left;
}
thePositionNode.left = theTmpLeft;
} else {
// 说明找到删除的节点
// currNode为待删除节点， preNode是待删除节点的前一个节点
// 1, 这种情况说明是叶子节点，直接比前一个节点的下一个节点设置为null即可
if (currNode.left == null && currNode.right == null) {
if (isLeft) {
preNode.left = null;
} else {
preNode.right = null;
}
}
// 2, 说明是一个根节点，左子树为null，右子树不为null
if(currNode.left == null && currNode.right != null){
if (isLeft) {
preNode.left = currNode.right;
} else{
preNode.right = currNode.right;
}
}
// 3, 说明是一个根节点，左子树不为null，右子树为null
if(currNode.left != null && currNode.right == null){
if (isLeft) {
preNode.left = currNode.left;
} else{
preNode.right = currNode.left;
}
}
// 4, 说明删除的是两个叶子都有的根节点(但是非root点，因为进来就代表preNode != nul)
if (currNode.left != null && currNode.right != null) {
// 说明是两个叶子节点都有的根节点
// 这里就超级麻烦了。。。
// 我们直接把小的节点重新添加一下
if (isLeft) {
preNode.left = currNode.right;
// 直接把当前的左侧 挂在新的节点的 最左即可
Node theTmpLeft = currNode.left;
Node thePositionNode = currNode.right;
while (thePositionNode.left != null) {
thePositionNode = thePositionNode.left;
}
thePositionNode.left = theTmpLeft;
} else {
preNode.right = currNode.right;
Node theTmpLeft = currNode.left;
Node thePositionNode = currNode.right;
while (thePositionNode.left != null) {
thePositionNode = thePositionNode.left;
}
thePositionNode.left = theTmpLeft;
}
}
}
System.out.println("-----");
}
public List<List<Integer>> levelorderTraversal() {
List<List<Integer>> result = new ArrayList<>();
if (root == null) {
return result;
}
Deque<Node> deque = new ArrayDeque<>();
deque.offer(root);
while (deque.size() > 0) {
int length = deque.size();
List<Integer> tmp = new ArrayList<>();
for (int i = 0; i < length; i++) {
Node node = deque.poll();
System.out.println("当前是：" + node.val +
", 左子树高度是：" + height(node.left) +
", 右子树高度是：" + height(node.right));
tmp.add(node.val);
if (node.left != null) {
deque.add(node.left);
}
if (node.right != null) {
deque.add(node.right);
}
}
result.add(tmp);
}
return result;
}
public void inorderTraversal(){
inorderTraversal(root);
}
// 对于二叉排序树，中序遍历就是从小到大排序了
public void inorderTraversal(Node node){
if (node == null) {
return;
}
if (node.left != null) {
inorderTraversal(node.left);
}
System.out.println(node.val);
if (node.right != null) {
inorderTraversal(node.right);
}
}
// 把给定的节点按照二叉排序树进行添加到树中
public void addNode(Node node) {
if (node == null) {
return;
}
if (root == null) {
root = node;
return;
}
Node curr = root;
// 找到需要添加的根节点
while (true) {
if (node.val <= curr.val) {
if (curr.left == null) {
break;
}
curr = curr.left;
}
if (node.val > curr.val) {
if (curr.right == null) {
break;
}
curr = curr.right;
}
}
// 走到这里，说明找到需要添加位置到根节点了
if (node.val <= curr.val) {
curr.left = node;
} else {
curr.right = node;
}
/*System.out.println(curr.val);
System.out.println("-----");*/
}
}
7, AVL树(Adelson-Velsky and Landis Tree)：也叫平衡二叉树(Self-Balancing Binary Search Tree)
- 它是一棵空树或者它的左右两个子树的高度的绝对值不超过1
- 并且左右两棵子树都是一棵平衡二叉树
- 平衡二叉树常用的实现形式：红黑树，AVL(算法)，替罪羊树，Treap，伸展树
package com.shangguigu.dachang.algrithm.A09_basicTree;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;
/**
* @author : 不二
* @date : 2022/4/22-下午9:34
* @desc : AVL树(平衡二叉树)
**/
public class A12_AVLTree {
public static void main(String[] args) {
int[] nums = {3, 4, 1, 7, 6, 5, 2, 0, 9, 8, 10};
// int[] nums = {0, 1, 2, 3};
// int[] nums = {4, 2, 7, 8, 9};
// int[] nums = {4, 3, 6, 5, 7, 8};
// int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// int[] nums = {1, 15, 14, 17, 7, 2, 12, 3, 9, 11};
// int[] nums = {10, 11, 7, 6, 8, 9};
AVLTree avlTree = new AVLTree();
for (int i = 0; i < nums.length; i++) {
// System.out.println(nums[i]);
// 把数组中数据添加到二叉排序树中
avlTree.root = avlTree.addAVLNode(new AVLTree.Node(nums[i]), avlTree.root);
}
System.out.println("done---");
avlTree.inorderTraversal();
/*System.out.println("高度是：" + avlTree.height(avlTree.root));
System.out.println("左子高度是：" + avlTree.height(avlTree.root.left));
System.out.println("右子高度是：" + avlTree.height(avlTree.root.right));*/
List<List<Integer>> lists = avlTree.levelorderTraversal();
System.out.println("结果是：" + lists);
// System.out.println("开始旋转");
// avlTree.leftRotate(avlTree.root);
// avlTree.balanceBST(avlTree.root);
// System.out.println("高度是：" + avlTree.height(avlTree.root));
// System.out.println("左子高度是：" + avlTree.height(avlTree.root.left));
// System.out.println("右子高度是：" + avlTree.height(avlTree.root.right));
}
}
/**
* AVL平衡二叉树本质上和BST二叉排序树是类似的，只不过是前者能保证平衡
* 所以BST二叉排序树的所有方法，AVL平衡二叉树都能用。
* 当天添加节点的时候需要调整成平衡树
*/
class AVLTree{
public List<List<Integer>> levelorderTraversal() {
List<List<Integer>> result = new ArrayList<>();
if (root == null) {
return result;
}
Deque<Node> deque = new ArrayDeque<>();
deque.offer(root);
while (deque.size() > 0) {
int length = deque.size();
List<Integer> tmp = new ArrayList<>();
for (int i = 0; i < length; i++) {
Node node = deque.poll();
System.out.println("当前是：" + node.val +
", 左子树高度是：" + height(node.left) +
", 右子树高度是：" + height(node.right));
tmp.add(node.val);
if (node.left != null) {
deque.add(node.left);
}
if (node.right != null) {
deque.add(node.right);
}
}
result.add(tmp);
}
return result;
}
/**
* 把指定节点添加到指定位置后，返回根root节点
* @param node
* @param theRoot
* @return
*/
public Node addAVLNode(Node node, Node theRoot){
if (node == null) {
return null;
}
if (theRoot == null) {
root = node;
return root;
}
// 记录前一个节点，方便：旋转后，前一个节点重新指向调整后到节点
// Node preNode;
if (node.val <= theRoot.val) {
if (theRoot.left == null) {
System.out.println("start----left:" + theRoot.val);
theRoot.left = node;
System.out.println("enden----left:" + theRoot.val);
} else {
// 说明这里已经有二级了
theRoot.left = addAVLNode(node, theRoot.left);
}
} else {
if (theRoot.right == null) {
theRoot.right = node;
} else {
// 说明这里已经有二级了
System.out.println("start----right:" + theRoot.val);
theRoot.right = addAVLNode(node, theRoot.right);
System.out.println("enden----right:" + theRoot.val);
System.out.println("----------");
}
}
System.out.println("开始旋转处理：" + theRoot.val);
if (height(theRoot.left) - height(theRoot.right) > 1) {
// 需要留意的是：如果左子 大于 右子，但是左子的左子 小于 左子的右子
// 那么需要先把左子进行左旋转。
if (height(theRoot.left.left) < height(theRoot.left.right)) {
theRoot.left = leftRotate(theRoot.left);
}
theRoot = rightRotate(theRoot);
System.out.println("右旋转结束");
} else if (height(theRoot.right) - height(theRoot.left) > 1) {
if (height(theRoot.right.left) > height(theRoot.right.right)) {
theRoot.right = rightRotate(theRoot.right);
}
theRoot = leftRotate(theRoot);
System.out.println("左旋转结束");
} else {
System.out.println("不需要旋转处理：" + theRoot.val);
// theRoot;
}
System.out.println(theRoot.val + ": 高度是：" + height(theRoot));
System.out.println(theRoot.val + ":左子高度是：" + height(theRoot));
System.out.println(theRoot.val + ":右子高度是：" + height(theRoot));
return theRoot;
}
/**
* 这里节点做成内部类
*/
static class Node {
int val;
Node left;
Node right;
public Node(int val) {
this.val = val;
}
}
Node root;
// 如果左子树的高度比右子树高度 高出超过1的高度，需要把树进行右旋转
public Node rightRotate(Node node){
// 不需要限定。有些情况等于1也需要旋转
/*while (height(node.left) - height(node.right) > 1) {
}*/
// 1, 首先创建一个新的节点，和root节点值一致
Node theTmpNode = new Node(node.val);
// 该新的节点是作为root的临时哨兵节点
// 该哨兵节点右侧不变和root一样
theTmpNode.right = node.right;
// 该哨兵节点左侧变为：root左侧节点的右侧节点(因为稍后要把root的左侧节点提升到root位置)
theTmpNode.left = node.left.right;
// 2, 然后把root的左侧节点提神到
node = node.left;
// 3, 最后再把提升后的当前root右侧关联到哨兵节点上
// 左侧不需要更改
node.right = theTmpNode;
return node;
}
// 右子树的高度比左子树高度 高出超过1的高度，需要把树进行左旋转
public Node leftRotate(Node node){
// 说明不是平衡二叉树，需要进行左旋转
// 不需要限定。有些情况等于1也需要旋转
/*while (height(node.right) - height(node.left) > 1) {
}*/
// 1, 首先创建一个新的节点，和root节点值一致
Node theTmpNode = new Node(node.val);
// 该新的节点是作为root这个节点的临时哨兵节点
// 该哨兵节点左侧不变和root一样
theTmpNode.left = node.left;
// 右侧变为：root右侧节点的左侧节点(因为稍后要把右侧节点提升为root)
theTmpNode.right = node.right.left;
// 2, 然后把root的右侧节点提升到root位置
node = node.right;
// 3，然后再把root的左侧关联到新建的临时哨兵节点，
// 右侧关联到：之前root右侧节点的右侧(右侧这个没有断开过，所以不需要设置)
node.left = theTmpNode;
return node;
}
/**
* 计算树的高度
* 方便后续查看其是否是平衡二叉树
* 给定一个节点， 计算从该节点开始的高度
*/
public int height(Node node) {
if (node == null) {
return 0;
}else if (node.left == null && node.right == null) {
return 1;
} else if (node.left == null && node.right != null) {
return 1 + height(node.right);
} else if (node.left != null && node.right == null) {
return 1 + height(node.left);
} else if (node.left != null && node.right != null) {
return 1 + Math.max(height(node.left), height(node.right));
} else {
// 这里应该没有进来的可能
return 0;
}
}
// 艹，原来一句代码就能搞定
public int height_v1(Node node){
return 1 + Math.max(node.left == null ? 0 : height_v1(node.left), node.right == null ? 0 : height_v1(node.right));
}
public void inorderTraversal(){
inorderTraversal(root);
}
// 对于二叉排序树，中序遍历就是从小到大排序了
public void inorderTraversal(Node node){
if (node == null) {
return;
}
if (node.left != null) {
inorderTraversal(node.left);
}
System.out.println(node.val);
if (node.right != null) {
inorderTraversal(node.right);
}
}
}
8, 多路查找树
对于二叉树的话， 如果节点表多， 那么树多高度可能就会越来越高
那么可以在二叉树的基础上进行升级， 把二叉树变为多叉树
常见的有B树/B+树
比如23树/234树等都是B树
309
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
