【韩顺平-数据结构】树结构应用（学习笔记）

已于 2023-08-04 14:12:34 修改
阅读量50 收藏
点赞数
分类专栏： 数据结构（学习笔记） 文章标签： 数据结构 学习 笔记
于 2023-08-04 14:05:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wmh1024/article/details/132103142
版权

一、堆排序

1、堆排序概述

  1. 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏、最好、平均时间复杂度均为 O(nlogn)，它也是不稳定排序
  2. 堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆，每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。
  3. 结点的左孩子的值和右孩子的值的大小关系无要求

2、堆排序思路

  1. 将待排序序列构造成一个大顶堆（数组形式）
  2. 整个序列的最大值就是堆顶的根节点
  3. 将其与末尾元素进行交换，此时末尾就为最大值
  4. 然后将剩余 n-1 个元素重新构造成一个堆，这样会得到 n-1 个元素的次小值。如此反复执行，便能得到一个有序序列了

3、堆排序代码实现

package work.rexhao.tree;

import java.util.Arrays;

/**
 * 堆排序
 */
public class HeapSort {
    public static void main(String[] args) {
        int[] num = new int[]{3, 2, 4, 1, 5};
        System.out.println(Arrays.toString(num));
        heapSort(num, num.length);
        System.out.println(Arrays.toString(num));
    }

    /**
     * 维护大顶堆
     *
     * @param num   数组
     * @param len   数组长度
     * @param index 待维护元素的下表
     */
    public static void heapify(int[] num, int len, int index) {
        int max = index;
        // 找到最大值
        int leftSon = index * 2 + 1;
        int rightSon = index * 2 + 2;
        if (leftSon < len && num[max] < num[leftSon]) {
            max = leftSon;
        }
        if (rightSon < len && num[max] < num[rightSon]) {
            max = rightSon;
        }
        // 最大的不是父节点 => 交换
        if (max != index) {
            // 1.交换
            int temp = num[max];
            num[max] = num[index];
            num[index] = temp;
            // 2.继续维护下面的子堆
            heapify(num, len, max);
        }

    }


    /**
     * 堆排序入口
     *
     * @param num 待排序数组
     * @param len 数组长度
     */
    public static void heapSort(int[] num, int len) {
        // 建堆
        for (int i = len / 2 - 1; i >= 0; i--) {
            heapify(num, len, i);
        }
        // 交换首尾元素
        for (int i = len - 1; i > 0; i--) {
            int temp = num[i];
            num[i] = num[0];
            num[0] = temp;
            heapify(num, i, 0);
        }
    }
}

二、赫夫曼树

1、赫夫曼树基本介绍

赫夫曼树(Hufriman Tree)：给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度(wpl)达到最小，称这样的二叉树为最优二叉树

赫夫曼树是带权路径长度最短的树，权值较大的结点离根较近

2、赫夫曼树的概念

1）路径和路径长度

在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。

通路中分支的数目称为路径长度。

若规定根结点的层数为1，则从根结点到第工 层结点的路径长度为L-1

2）结点的权及带权路径长度

若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。

结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积

3）树的带权路径长度

树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为 WPL(weighted path
length)

权值越大的结点离根结点越近的二叉树才是最优二叉树。

4）WPL

WPL 最小的就是赫夫曼树

3、赫夫曼树的代码实现

package work.rexhao.huffmantree;

import org.jetbrains.annotations.NotNull;

import java.util.ArrayList;
import java.util.Collections;

/**
 * 哈夫曼树的生成
 */
public class HuffmanTreeDemo {
    public static void main(String[] args) {
        int num[] = {13, 7, 8, 3, 29, 6, 1};
        initHuffmanTree(num);

    }

    public static void initHuffmanTree(int[] num) {
        ArrayList<TreeNode> tnodes = new ArrayList<>();
        for (int i : num) {
            tnodes.add(new TreeNode(i));
        }
        while (tnodes.size() != 1) {
            Collections.sort(tnodes);
            TreeNode leftNode = tnodes.get(0);
            TreeNode rightNode = tnodes.get(1);
            tnodes.add(new TreeNode(leftNode.getData() + rightNode.getData(), leftNode, rightNode));
            tnodes.remove(leftNode);
            tnodes.remove(rightNode);
            Collections.sort(tnodes);
        }
        preOrder(tnodes.get(0));


    }

    /**
     * 先序遍历
     */
    public static void preOrder(TreeNode tn) {
        if (tn != null) {
            System.out.print(tn.getData() + " ");
            preOrder(tn.leftNode);
            preOrder(tn.rightNode);
        }
    }


}

/**
 * 二叉树的节点
 */
class TreeNode implements Comparable<TreeNode> {
    private int data;
    TreeNode leftNode;
    TreeNode rightNode;

    TreeNode(int data) {
        this.data = data;
    }

    public TreeNode(int data, TreeNode leftNode, TreeNode rightNode) {
        this.data = data;
        this.leftNode = leftNode;
        this.rightNode = rightNode;
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    @Override
    public int compareTo(@NotNull TreeNode o) {
        return this.data - o.data;
    }
}

三、赫夫曼编码

1、赫夫曼编码的基本介绍

  1. 赫夫曼编码是赫哈大曼树在电讯通信中的经典的应用之一
  2. 赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%~-90%之间
  3. 赫夫曼码是可变字长编码(VLC)的一种
  4. Huffman于1952年提出一种编码方法，称之为最佳编码
  5. 宇符的编码都不能是其他字符编码的前缀，符合此要求的编码叫做前缀编码，即不能匹配到重复的编码

2、赫夫曼编码的注意事项

  1. 赫夫曼树根据排序方法不同，也可能不太一样，这样对应的赫夫曼编码也不完全一样，但是wpl是一样的，都是最小的，最后生成的赫夫曼编码的长度是一样
  2. 如果文件本身就是经过压缩处理的，那么使用赫夫曼编码再压缩效率不会有明显变化，比如视频、ppt 等等文件
  3. 赫夫曼编码是按字节来处理的，因此可以处理所有的文件（二进制文件、文本文件）
  4. 如果一个文件中的内容，重复的数据不多，压缩效果也不会很明显

3、代码实现

未解决的Bug：

哈夫曼字节编码8个二进制数一组。
对于最后一组，若0开头，转换后因为不去补零，丢失前面的0；如果补零，最后一组不一定是8位，不能补零。
我的做法是：将最后一组后面补零至8位，但是会造成解码后产生多余字符。

package work.rexhao.huffmantree;

import org.jetbrains.annotations.NotNull;

import java.util.*;

/**
 * 哈夫曼编码与解码
 */
public class HuffmanCode {
    // 存储哈夫曼编码表
    static Map<Byte, String> HuffmanCodes = new HashMap<>();

    public static void main(String[] args) {
        String str1 = "i like java java java do you like java?";
        System.out.println("str1:" + str1);
        byte[] huffmanBytes = huffmanZip(str1.getBytes());
        System.out.println("huffmanBytes:" + Arrays.toString(huffmanBytes));
        String str2 = huffmanUnzip(huffmanBytes);
        System.out.println("str2:" + str2);
    }

    /**
     * 哈夫曼解码
     *
     * @param huffmanBytes 哈夫曼编码
     * @return 解码后字符串
     */
    private static String huffmanUnzip(byte[] huffmanBytes) {
        StringBuilder code = new StringBuilder();
        for (byte b : huffmanBytes) {
            code.append(Integer.toBinaryString(b | 256).substring(
                    Integer.toBinaryString(b | 256).length() - 8));
        }
        Map<String, Byte> unzipCodes = new HashMap<>();
        for (Map.Entry<Byte, String> entry : HuffmanCodes.entrySet()) {
            unzipCodes.put(entry.getValue(), entry.getKey());
        }
        List<Byte> bytesList = new ArrayList<>();
        for (int i = 0; i < code.length(); ) {
            int count = 1;
            while (true) {
                if (i + count >= code.length()) {
                    i = code.length();
                    break;
                }
                String key = code.substring(i, i + count);
                Byte value = unzipCodes.get(key);
                if (value == null) {
                    count++;
                } else {
                    bytesList.add(value);
                    i += count;
                    break;
                }
            }
        }
        byte[] bytes = new byte[bytesList.size()];
        for (int i = 0; i < bytesList.size(); i++) {
            bytes[i] = bytesList.get(i);
        }
        return new String(bytes);
    }

    /**
     * 哈夫曼编码
     *
     * @param bytes 编码前
     * @return 编码后
     */
    public static byte[] huffmanZip(byte[] bytes) {
        // 1.创建哈夫曼树
        Map<Byte, Integer> huffmanMap = byteCounter(bytes);
        HuffmanCodeNode root = initHuffmanTree(huffmanMap);
        // 2.获得哈夫曼编码表
        toHuffmanCodes(root);
        // 3.进行转码
        return toHuffmanBytes(bytes, HuffmanCodes);
    }

    /**
     * 通过哈夫曼编码表转化成哈弗曼编码
     *
     * @param bytes        原字符数组
     * @param huffmanCodes 哈夫曼编码表
     * @return 编码后的哈夫曼编码
     */
    private static byte[] toHuffmanBytes(byte[] bytes, Map<Byte, String> huffmanCodes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(huffmanCodes.get(b));
        }
        byte[] code = new byte[(sb.length() + 7) / 8];
        int index = 0;
        for (int i = 0; i < sb.length(); i += 8) {
            if (i + 8 < sb.length()) {
                code[index++] = (byte) Integer.parseInt(sb.substring(i, i + 8), 2);
            } else {
                StringBuilder temp = new StringBuilder(sb.substring(i));
                for (int j = temp.length(); j < 8; j++) {
                    temp.append("0");
                }
                code[index++] = (byte) Integer.parseInt(temp.toString(), 2);
            }
        }
        return code;
    }

    /**
     * 将哈夫曼树转换为哈夫曼编码表（重载）
     *
     * @param root 根节点
     */
    private static void toHuffmanCodes(HuffmanCodeNode root) {
        toHuffmanCodes(root, "");
    }

    /**
     * 将哈夫曼树转换为哈夫曼编码表
     *
     * @param node 节点
     * @param s    代拼接编码
     */
    private static void toHuffmanCodes(HuffmanCodeNode node, String s) {
        if (node == null) {
            return;
        }
        // node有值的话 -> 将b放进去
        if (node.b != null) {
            HuffmanCodes.put(node.b, s);
        }
        toHuffmanCodes(node.leftNode, s + "0");
        toHuffmanCodes(node.rightNode, s + "1");
    }

    /**
     * 创建哈夫曼树
     *
     * @param huffmanMap 字符权重
     * @return 根节点
     */
    private static HuffmanCodeNode initHuffmanTree(Map<Byte, Integer> huffmanMap) {
        List<HuffmanCodeNode> list = new ArrayList<>();
        for (Byte b : huffmanMap.keySet()) {
            list.add(new HuffmanCodeNode(b, huffmanMap.get(b)));
        }
        while (list.size() != 1) {
            Collections.sort(list);
            HuffmanCodeNode hcn1 = list.get(0);
            HuffmanCodeNode hcn2 = list.get(1);
            list.remove(0);
            list.remove(0);
            list.add(new HuffmanCodeNode(null, hcn1.weight + hcn2.weight, hcn1, hcn2));
        }
        return list.get(0);
    }

    /**
     * 统计字符出现的次数
     *
     * @param bytes 待统计字符
     * @return 字符权重map
     */
    public static Map<Byte, Integer> byteCounter(byte[] bytes) {
        Map<Byte, Integer> map = new HashMap<>();
        for (byte b : bytes) {
            map.merge(b, 1, Integer::sum);
        }
        return map;
    }
}

/**
 * 哈夫曼编码的哈夫曼树节点
 */
class HuffmanCodeNode implements Comparable<HuffmanCodeNode> {
    Byte b;
    int weight;
    HuffmanCodeNode rightNode;
    HuffmanCodeNode leftNode;

    public HuffmanCodeNode(Byte b, int weight) {
        this.b = b;
        this.weight = weight;
    }

    public HuffmanCodeNode(Byte b, int weight, HuffmanCodeNode rightNode, HuffmanCodeNode leftNode) {
        this.b = b;
        this.weight = weight;
        this.rightNode = rightNode;
        this.leftNode = leftNode;
    }

    @Override
    public int compareTo(@NotNull HuffmanCodeNode o) {
        return this.weight - o.weight;
    }

    @Override
    public String toString() {
        return "HuffmanCodeNode{" + "b=" + b + ", weight=" + weight + ", rightNode=" + rightNode + ", leftNode=" + leftNode + '}';
    }
}

四、二叉排序树（BST）

1、二叉排序树概述

二叉排序树：BST(Binary Sort(Search) Tree)，对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。

如果有相同的值，可以将该节点放在左子节点或右子节点

2、二叉排序树删除节点

1）叶子节点

  1. 找到该节点
  2. 找到该节点的父节点
  3. 判断该节点与其父节点的位置
    1. 左子树：parentNode.left == null
    2. 右子树：parentNode.right == null

2）度为一的节点

  1. 找到该节点
  2. 找到该节点的父节点
  3. 判断该节点与其父节点的位置
    1. 该节点是父节点的左子树
      1. 该节点存在左子树：parentNode.left == node.left
      2. 该节点存在右子树：parentNode.left == node.right
    2. 该节点是父节点的右子树
      1. 该节点存在左子树：parentNode.right == node.left
      2. 该节点存在右子树：parentNode.right == node.right

3）度为二的节点

  1. 找到该节点
  2. 找到该节点右子树的最小节点（递归其右子树的左节点的左节点…）
  3. 保存最小节点的值temp
  4. 删除最小节点（叶子结点）
  5. 将该节点的的值改为temp

3、二叉排序树代码实现

package work.rexhao.binarySortTree;

/**
 * 二叉排序树BST
 */
public class BinarySortTreeDemo {
    public static void main(String[] args) {
        BinarySortTree bst = new BinarySortTree();
        int[] num = {7, 3, 10, 1, 6, 9, 12, 2};
        for (int i : num) {
            bst.add(new Node(i));
        }
        BinarySortTree.infixOrder(bst.root);
        System.out.println();

        bst.delete(10);
        BinarySortTree.infixOrder(bst.root);
        System.out.println();

    }
}

/**
 * 二叉排序树
 */
class BinarySortTree {
    Node root;

    /**
     * 添加节点
     *
     * @param next 待添加节点
     */
    public void add(Node next) {
        if (root == null) {
            root = next;
        } else {
            root.add(next);
        }
    }

    /**
     * 前序遍历
     *
     * @param node 根节点
     */
    public static void infixOrder(Node node) {
        if (node == null) {
            return;
        }
        infixOrder(node.left);
        System.out.print(node.data + " ");
        infixOrder(node.right);
    }

    /**
     * 删除节点
     *
     * @param target 待删除节点的值
     */
    public void delete(int target) {
        Node node = search(root, target);
        Node nodeParent = searchParent(root, node);
        // 经典判空
        if (node == null || nodeParent == null) {
            System.out.println("节点不存在或节点无父节点!");
            return;
        }
        // 判断待删除节点的形式
        if (node.left == null && node.right == null) {
            // 叶子节点
            if (nodeParent.right == node) {
                // 右节点
                nodeParent.right = null;
            } else {
                // 左节点
                nodeParent.left = null;
            }
        } else if (node.left != null && node.right != null) {
            // 两个子树的节点
            // 1. 找右子树的最小值(右子树的左子树的叶子结点)
            Node min = searchRightMinNode(node.right);
            // 2. 记录最小值
            int temp = min.data;
            // 3. 删除原来的最小值节点
            delete(min.data);
            // 4. 将最小值提到(覆盖)节点位置
            node.data = temp;
        } else {
            // 一个子树的节点
            if (node.left == null) {
                // 存在右子树
                if (nodeParent.right == node) {
                    // 右节点
                    nodeParent.right = node.right;
                } else {
                    // 左节点
                    nodeParent.left = node.right;
                }
            } else {
                // 存在左子树
                if (nodeParent.right == node) {
                    // 右节点
                    nodeParent.right = node.left;
                } else {
                    // 左节点
                    nodeParent.left = node.left;
                }
            }
        }


    }

    /**
     * 找 node 节点右子树的最小节点
     *
     * @param node 开始寻找的节点
     * @return 右子树的最小节点
     */
    private Node searchRightMinNode(Node node) {
        // 找到叶子结点(最小的点)
        return node.left == null ? node : searchRightMinNode(node.left);
    }

    /**
     * 找 data 为 i 的节点
     *
     * @param root 根节点
     * @param i    待查找数据
     * @return 查找到的节点，不存在返回null
     */
    public static Node search(Node root, int i) {
        // 1.经典判空
        if (root == null) {
            return null;
        }
        // 2.找节点
        if (i == root.data) {
            return root;
        } else if (i < root.data) {
            return search(root.left, i);
        } else {
            return search(root.right, i);
        }
    }

    /**
     * 找到 target 的父节点
     *
     * @param root   根节点
     * @param target 待寻找节点
     * @return 待寻找节点的父节点，不存在返回null
     */
    public static Node searchParent(Node root, Node target) {
        // 经典判空
        if (root == null || target == null) {
            return null;
        }
        // 判左右的节点
        if ((root.right != null && root.right.data == target.data) || (root.left != null && root.left.data == target.data)) {
            return root;
        }
        // 没找到 -> 递归往下找
        if (root.data > target.data) {
            return searchParent(root.left, target);
        } else {
            return searchParent(root.right, target);
        }
    }
}

/**
 * 节点
 */
class Node {
    int data;
    Node left;
    Node right;

    public Node(int data) {
        this.data = data;
    }

    /**
     * 添加节点
     *
     * @param next 待添加节点
     */
    public void add(Node next) {
        if (next == null) {
            return;
        }
        if (this.data > next.data) {
            if (this.left == null) {
                this.left = next;
            } else {
                this.left.add(next);
            }
        } else {
            if (this.right == null) {
                this.right = next;
            } else {
                this.right.add(next);
            }
        }
    }

    @Override
    public String toString() {
        return "Node{" + "data=" + data + '}';
    }
}

五、平衡二叉树（AVL树）

1、BST可能的问题

若BST左子树or右子树为空 -> 单链表

查询速度明显降低（因为需要依次比较），不能发挥BST的优势

2、平衡二叉树概述

定义：平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为 AVL 树（AVL树得名于它的发明者G. M. Adelson-Velsky和E. M. Landis）

特点：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树

3、平衡二叉树的转换

1）左旋转

  1. 取右子节点
  2. 将根节点的值挂在 newRoot 上
  3. 将 root 的左子节点挂在 newRoot.left.left
  4. 将原 newRoot 的左子节点挂在 newRoot.left.right
  5. 将原 newRoot 的右子节点挂在 newRoot.right
  6. 用 newRoot 替换 root

2）右旋转

  1. 取左子节点
  2. 将根节点的值挂在 newRoot 上
  3. 将 root 的右子节点挂在 newRoot.right.right
  4. 将原 newRoot 的右子节点挂在 newRoot.right.left
  5. 将原 newRoot 的左子节点挂在 newRoot.left
  6. 用 newRoot 替换 root

3）双旋转

左子树 > 右子树：右旋转

左子树 < 右子树：左旋转

4、AVL树的代码实现

package work.rexhao.AVLTree;

import java.util.Arrays;

/**
 * 平衡二叉树
 */
public class AVLDemo {
    public static void main(String[] args) {
        // 案例1：左旋转
        int[] num0 = {4, 3, 6, 5, 7, 8};
        System.out.println(Arrays.toString(num0));
        AVLTree avl0 = new AVLTree();
        for (int i : num0) {
            avl0.add(new Node(i));
        }
        avl0.infixOrder();
        System.out.println("left = " + avl0.findLeftHeight());
        System.out.println("right = " + avl0.findRightHeight());
        System.out.println("是否为AVL树:" + avl0.isAVL());
        avl0.leftRotate();
        avl0.infixOrder();
        System.out.println("left = " + avl0.findLeftHeight());
        System.out.println("right = " + avl0.findRightHeight());
        System.out.println("是否为AVL树:" + avl0.isAVL());

        System.out.println("-------------");

        // 案例2：右旋转
        int[] num1 = {7, 5, 8, 4, 6, 3};
        System.out.println(Arrays.toString(num1));
        AVLTree avl1 = new AVLTree();
        for (int i : num1) {
            avl1.add(new Node(i));
        }
        avl1.infixOrder();
        System.out.println("left = " + avl1.findLeftHeight());
        System.out.println("right = " + avl1.findRightHeight());
        System.out.println("是否为AVL树:" + avl1.isAVL());
        avl1.rightRotate();
        avl1.infixOrder();
        System.out.println("left = " + avl1.findLeftHeight());
        System.out.println("right = " + avl1.findRightHeight());
        System.out.println("是否为AVL树:" + avl1.isAVL());

        System.out.println("-------------");

        // 案例3：双旋转
        int[] num2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        System.out.println(Arrays.toString(num2));
        AVLTree avl2 = new AVLTree();
        for (int i : num2) {
            avl2.add(new Node(i));
        }
        avl2.infixOrder();
        System.out.println("left = " + avl2.findLeftHeight());
        System.out.println("right = " + avl2.findRightHeight());
        System.out.println("是否为AVL树:" + avl2.isAVL());
        avl2.rotate();
        avl2.infixOrder();
        System.out.println("left = " + avl2.findLeftHeight());
        System.out.println("right = " + avl2.findRightHeight());
        System.out.println("是否为AVL树:" + avl2.isAVL());

        System.out.println("-------------");
    }
}

/**
 * 二叉排序树
 */
class AVLTree {
    Node root;

    /**
     * 双旋转
     */
    public void rotate() {
        while (true) {
            if (isAVL()) {
                break;
            } else {
                if (findLeftHeight() > findRightHeight()) {
                    rightRotate();
                } else {
                    leftRotate();
                }
            }
        }
    }

    /**
     * 左旋转
     */
    public void leftRotate() {
        // 0. 经典判空
        if (root == null) return;
        // 1. 取右子节点
        Node newRoot = new Node(root.right.data);
        // 2. 将根节点的值挂在 newRoot 上
        newRoot.left = new Node(root.data);
        // 3. 将 root 的左子节点挂在 newRoot.left.left
        newRoot.left.left = root.left;
        // 4. 将原 newRoot 的左子节点挂在 newRoot.left.right
        newRoot.left.right = root.right.left;
        // 5. 将原 newRoot 的右子节点挂在 newRoot.right
        newRoot.right = root.right.right;
        // 6. 用 newRoot 替换 root
        this.root = newRoot;
    }

    /**
     * 右旋转
     */
    public void rightRotate() {
        // 0. 经典判空
        if (root == null) return;
        // 1. 取左子节点
        Node newRoot = new Node(root.left.data);
        // 2. 将根节点的值挂在 newRoot 上
        newRoot.right = new Node(root.data);
        // 3. 将 root 的右子节点挂在 newRoot.right.right
        newRoot.right.right = root.right;
        // 4. 将原 newRoot 的右子节点挂在 newRoot.right.left
        newRoot.right.left = root.left.right;
        // 5. 将原 newRoot 的左子节点挂在 newRoot.left
        newRoot.left = root.left.left;
        // 6. 用 newRoot 替换 root
        this.root = newRoot;
    }

    /**
     * 判断是否为平衡二叉树
     */
    public boolean isAVL() {
        return Math.abs(findLeftHeight() - findRightHeight()) <= 1;
    }

    /**
     * 找右子树深度
     *
     * @return 右子树深度
     */
    public int findRightHeight() {
        if (root == null) {
            return 0;
        }
        int[] r = {1};
        int[] l = {1};
        findHeight(root.right, r, l);
        return Math.max(r[0], l[0]);
    }

    /**
     * 找左子树深度
     *
     * @return 左子树深度
     */
    public int findLeftHeight() {
        if (root == null) {
            return 0;
        }
        int[] r = {1};
        int[] l = {1};
        findHeight(root.left, r, l);
        return Math.max(r[0], l[0]);
    }

    /**
     * 求深度
     */
    private void findHeight(Node node, int[] r, int[] l) {
        // 经典判空
        if (node == null) {
            return;
        }
        // 判叶子节点
        if (node.left == null && node.right == null) {
            return;
        }
        if (node.left != null) {
            r[0]++;
            findHeight(node.left, r, l);
        }
        if (node.right != null) {
            l[0]++;
            findHeight(node.right, r, l);
        }
    }


    /**
     * 添加节点
     *
     * @param next 待添加节点
     */
    public void add(Node next) {
        if (root == null) {
            root = next;
        } else {
            root.add(next);
        }
    }

    /**
     * 中序遍历
     */
    public void infixOrder() {
        Node.infixOrder(root);
        System.out.println();
    }

}

/**
 * 节点
 */
class Node {
    int data;
    Node left;
    Node right;

    public Node(int data) {
        this.data = data;
    }

    /**
     * 添加节点
     *
     * @param next 待添加节点
     */
    public void add(Node next) {
        if (next == null) {
            return;
        }
        if (this.data > next.data) {
            if (this.left == null) {
                this.left = next;
            } else {
                this.left.add(next);
            }
        } else {
            if (this.right == null) {
                this.right = next;
            } else {
                this.right.add(next);
            }
        }
    }

    /**
     * 中序遍历
     *
     * @param node 根节点
     */
    public static void infixOrder(Node node) {
        if (node == null) {
            return;
        }
        infixOrder(node.left);
        System.out.print(node.data + " ");
        infixOrder(node.right);
    }

    @Override
    public String toString() {
        return "Node{" + "data=" + data + '}';
    }
}
wmh1024
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
尚硅谷韩顺平大数据技术之Scala数据结构和算法.txt
07-12
数据结构和算法中韩顺平老师讲的是最好的值得大家学习交流 大数据技术之Scala数据结构和算法
韩顺平JAVA数据结构与算法，重点是算法！.zip
01-14
Java是一种高性能、跨平台的面向对象编程语言。它由Sun Microsystems（现在是Oracle Corporation）的James Gosling等人在1995年推出，被设计为一种简单、健壮、可移植、多线程、动态的语言。Java的主要特点和优势包括以下几个方面： 跨平台性（Write Once, Run Anywhere）： Java的代码可以在不同的平台上运行，只需编写一次代码，就可以在任何支持Java的设备上执行。这得益于Java虚拟机（JVM），它充当了代码和底层硬件之间的中介。 面向对象： Java是一种纯粹的面向对象编程语言，支持封装、继承和多态等面向对象的概念。这使得Java编写的代码更加模块化、可维护和可扩展。 多线程支持： Java内置了对多线程的支持，允许程序同时执行多个任务。这对于开发需要高并发性能的应用程序（如服务器端应用、网络应用等）非常重要。 自动内存管理（垃圾回收）： Java具有自动内存管理机制，通过垃圾回收器自动回收不再使用的对象，使得开发者不需要手动管理内存，减轻了程序员的负担，同时也减少了内存泄漏的风险。
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
算法-动态规划算法
cc098818的博客
10-19 324
package com.chb.DP; public class Pack01 { public static void main(String[] args) { int[] w = { 1, 4, 3 }; int[] val = { 1500, 3000, 2000 }; int C = 4; int n = w.length;// 物品的个数 // 创建二...
韩顺平数据结构排序算法笔记整理
weixin_52688663的博客
11-30 637
冒泡排序 选择排序 插入排序 希尔排序 快速排序 归并排序 基数排序 本章节一共介绍了7种常用排序方法，堆排序放在二叉树章节中再进行讲解 本次笔记主要是记录代码实现部分，后面会更新比较难理解的排序的分析 1、冒泡排序： package Sort; import java.util.Arrays; public class BubbleSort { public static void main(String[] args) { //测试 int
Linux-韩顺平学习笔记 - PDF-PPT
07-28
Linux课程学习笔记 -韩顺平 包含c/c++/python/java 专项 面试题 PDF PPT 笔记 面试题 （百度网盘链接 永久有效） 自学,做笔记,复习可用
韩顺平数据结构单链表案例代码实现
weixin_52688663的博客
11-16 125
主要实现了单链表的增删改查操作 图解分析： 1、增：（按照添加顺序增加） 2、自动按照编号排序增加 3、修改以及删除: 代码实现： 1、定义一个英雄节点，加入英雄的属性，其中next表示连接下一个节点 //每一个HeroNode就是一个节点 class HeroNode{ public int no; public String name; public String nickName; public HeroNode next;//指向下一...
【韩顺平-数据结构】稀疏矩阵和队列（学习笔记）
wmh的博客
08-04 51
队列是一个有序列表，可以用数组或链表实现遵循先入先出原则数组的结构存储队列元素，maxSize是队列最大容量两个变量front和rear记录队列前后端。
韩顺平数据结构单链表面试题笔记
weixin_52688663的博客
11-19 265
1、新浪面试题：找到单链表中倒数第K个节点 代码实现： /** * 获取倒数第k个节点的信息 * index表示倒数第K个节点 * size是获取有小姐点个数 */ public static HeroNode findLastNode(HeroNode head, int index){ if (head.next == null){ return null;//链表为空，没找到 }
【韩顺平-数据结构】十大算法（学习笔记）
wmh的博客
08-04 161
分治法（Divide-and-Conquer§）是一种很重要的算法。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。动态规划（Dynamic Programming）算法的核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。
Java—选择排序
qq_56725871的博客
05-22 256
它的基本思想是从待排序的数据中选择最小（或最大）的元素，放到已排序序列的末尾（或开头），然后再从剩余未排序的元素中选择最小（或最大）的元素，放到已排序序列的末尾（或开头），以此类推，直到全部元素排序完成。选择排序的时间复杂度为O(n^2)，其中n为待排序数组的长度。尽管选择排序的时间复杂度较高，但它简单易懂，适用于小规模数据的排序。对于大规模数据，更高效的排序算法如快速排序和归并排序更为常用。以上代码通过遍历整个数组，找到剩余未排序部分的最小值，并将其与当前位置的元素交换，重复这个过程直到数组排序完成。
刷题篇--数据结构--链表
hyldzbg的博客
05-18 457
如果我们有一个链表是1-->2-->3-->4-->5这样的，那我们反转后就是5-->4-->3-->2-->1这样的，那么要如果对链表操作呢？我们可以发现在反转后的链表里1-->2,变成2-->1那么我们就顺着这个思路，直接将下一个节点插到头节点前不就好了！！看起来好像不是很难，但是实现起来却很简单😉👌，嘿嘿！(^0^)我们可以再思考一下，将一个节点插到头节点前不就是头插嘛对不对，所以我们可以直接利用头插的方法来解决问题。
数据结构：二叉树---堆
Auroral_0218的博客
05-18 659
二叉树是一种特殊的树结构，其中每个节点最多有两个子节点。堆是一个完全二叉树：除了最后一层外，其他层节点个数都是满的，最后一层的节点都集中在左侧。堆中每个节点的值大于等于（或小于等于）其子节点的值，这个性质被称为堆序性。堆是一种特殊的数据结构，用于存储和管理一组元素。它的主要作用包括：1. 优先级队列：堆可以将元素按照一定的优先级进行排序，使得可以快速访问和操作优先级最高的元素。这在诸如调度算法、事件处理等场景中非常有用。2. 堆排序：堆排序是一种高效的排序算法，它利用堆的性质将元素快速排序。
二叉树——基础知识详解
最新发布
2302_81016149的博客
05-22 1126
对于二叉树基础的理论知识，我们就学习到这里，虽然这些知识相对后面来说简单一点，但别忘记复习。有了这些预备知识才能够更好的理解后面知识。另外对于递归理解还不够的读者一定要去尽可能的去理解，对于二叉树的学习非常重要。今天的学习就结束了，有问题可在评论区交流，也可私信。我们下篇见！完！
数据结构——栈
2302_80339723的博客
05-15 339
1.我们可以定义一个结构体（ struct stack），其中有数组（SLDataType *a），栈顶元素的下标（top）和栈的空间（capacity）。通常为0.我们会将栈为空时状态定义为以下，但是如果将没有元素时top为0，这是top指向的就不是栈顶元素，而是栈顶元素的下一个元素。我们可以实现一个静态栈（数组的长度是一定），但是这种结构并不实用，我们接下来实现的是动态栈。如果不是左括号，就要判断栈是不是为空，若为空，直接返回false，不为空，再取栈顶元素与之比较。总体来说，实现一个栈还是很容易的。
引用实战学习
qiuzhiuser的博客
05-19 141
【代码】引用实战学习。
在学习uni-app过程中使用的css样式记录
qq_34080064的博客
05-20 875
​在学习uni-app过程中，记录下使用的css样式，持续更新。
JVM学习-执行引擎
丢爸
05-21 838
当然是否需要启动JIT编译器将字节码直接编译为对应平台的本地机器指令，则需要根据代码被调用。大部分的程序代码转换为物理机的目标代码或虚拟机能执行的指令集之前，都需要经过下图各个步骤。，将其直接编译为对应平台的本地机器指令，以此提升Java程序的执行性能。”，JIT编译器在运行时会针对那些频繁被调用的热点代码做出。Java代码编译是由Java源码编译器来完成，流程图如下。而定，关于那些需要被编译为本地代码的字节码，称为“Java字节码的执行是由JVM执行引擎来完成。
数据结构与算法老师推荐
08-17
我推荐您观看青岛大学王卓老师的《数据结构与算法基础》课程。这个课程共有173集，可以在Bilibili上观看，视频链接为：https://www.bilibili.com/video/av82837069?from=search&seid=16668239479775468624 [1。在该课程中，王卓老师会介绍数据结构和算法的基础知识，包括线性结构和非线性结构。线性结构包括数组、队列、链表和栈，而非线性结构包括二维数组、多维数组、广义表、树结构和图结构 [2][3。通过学习这门课程，您将能够了解数据结构和算法的基本概念、原理和应用，为进一步深入学习和应用提供坚实的基础。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [数据结构与算法基础-青岛大学-王卓](https://blog.csdn.net/weixin_45433031/article/details/128307330)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [Java数据结构与算法（韩顺平老师）自学笔记](https://blog.csdn.net/weixin_38587462/article/details/105750552)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wmh1024

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值