《数据结构与算法之美》专栏阅读笔记6—

本文链接：https://blog.youkuaiyun.com/EllieYaYa/article/details/84579528

本文深入探讨了二叉树的基本概念、存储方式、遍历方法及二叉查找树的实现，特别介绍了红黑树的定义、性质、复杂度分析及其实现的基本思路，包括插入、删除操作的调整策略。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

因为从看到写笔记，中间隔了好久，木有激情啊啊啊，但是立flag了丫，你看flag对我这样的人多有用。

二叉树

树啥的，差不多是不管看什么书都很不想看的一个章节了。

树的基本概念

节点：树结构中的每个元素都称作节点。
节点的高度：节点到叶子节点的最长路径
节点的深度：根节点到该节点所经历的边的个数
节点的层数：节点深度+1
树的高度：根节点的高度

二叉树的基本概念

二叉树：最多两个子结点。左子节点、右子节点
满二叉树：除了叶子节点外，每个节点都有左右两个子结点。
完全二叉树：最后一层的叶子节点都靠左排列，除了最后一层，其他层的节点个数都要达到最大。

二叉树的存储

链式存储

基于链表进行存储。每个节点三个字段，存储数据、左右子结点的指针。

顺序存储

基于数组进行存储。根节点存储在i = 1的位置，根节点下标为i，则其左子节点存储在下标为2*i的位置，右子节点存储在下标为2*i+1的位置。

二叉树的遍历

下面的描述都是左子树、右子树，不是左子节点、右子节点。
前序遍历：对树中的任意节点来说，先打印当前节点，再打印左子树，最后打印右子树。
中序遍历：对树中的任意节点来说，先打印左子树，再打印当前节点，最后打印右子树。
后序遍历：对树中的任意节点来说，先打印右子树，再打印当前节点，最后打印左子树。

二叉查找树

为了实现快速查找，支持快速查找、插入、删除数据。
要求：在树中的任意一个节点，其左子树的每个节点的值小于该节点，右子树节点的值大于该节点。

实现

二叉查找树的插入、查找、删除、前序遍历、中序遍历、后序遍历，按层遍历的实现如下

public class BinSearchTree<T extends Comparable<T>> {
    static class Node<T> {
        T val;
        Node<T> left;
        Node<T> right;
        Node(T value) {
            val = value;
        }

        public Node(T value, Node left, Node right) {
            this.val = value;
            this.left = left;
            this.right = right;
        }

        @Override
        public String toString() {
            return String.valueOf(val);
        }
    }

    private Node root;
    BinSearchTree(T value) {
        root = new Node(value);
    }

    public void insert(T value) {
        Node<T> node = new Node(value);

        if (root == null) {
            root = node;
            return;
        }

        Node<T> p = root;
        while(p != null) {
            if (value.compareTo(p.val) > 0) {
                if (p.right == null) {
                    p.right = node;
                    return;
                }
                p = p.right;
            } else {
                if (p.left == null) {
                    p.left = node;
                    return;
                }
                p = p.left;
            }
        }
    }

    public Node<T> find(T value) {
        Node<T> p = root;
        while(p != null) {
            if (value.compareTo(p.val) < 0) {
                p = p.left;
            } else if (value.compareTo(p.val) > 0) {
                p = p.right;
            } else {
                return p;
            }
        }
        return null;
    }

    public void delete(T value) {
        Node<T> p = root;
        Node<T> pp = null;
        while (p != null && p.val != value) {
            pp = p;
            if (value.compareTo(p.val) > 0) {
                p = p.right;
            } else {
                p = p.left;
            }
        }

        if (p == null) {
            return;
        }

        if (p.left != null && p.right != null) {
            Node<T> minP = p.right;
            Node<T> minPP = p;
            while (minP.left != null) {
                minPP = minP;
                minP = minP.left;
            }
            p.val = minP.val;
            p = minP;
            pp = minPP;
        }

        Node<T> child;
        if (p.left != null) {
            child = p.left;
        } else if (p.right != null) {
            child = p.right;
        } else {
            child = null;
        }

        if (pp == null) {
            root = child;
        } else if (pp.left == p) {
            pp.left = child;
        } else if (pp.right == p) {
            pp.right = child;
        }
    }

    Node<T> getRoot() {
        return root;
    }

    public void preOder(Node<T> root) {
        if (root == null)
            return;

        System.out.print(root + " ");
        preOder(root.left);
        preOder(root.right);
    }

    public  void inOder(Node<T> root) {
        if (root == null)
            return;

        inOder(root.left);
        System.out.print(root + " ");
        inOder(root.right);
    }

    public void postOder(Node<T> root) {
        if (root == null)
            return;

        postOder(root.right);
        postOder(root.left);
        System.out.print(root + " ");
    }

    public void layerOder(Node<T> root) {
        Queue<Node<T>> queue = new LinkedList<Node<T>>();
        queue.add(root);

        while (!queue.isEmpty()) {
            Node<T> curNode = queue.poll();
            System.out.print(curNode + " ");

            if (curNode.left != null) {
                queue.add(curNode.left);
            }
            if (curNode.right != null) {
                queue.add(curNode.right);
            }
        }
    }
}