yeskery

树和二叉树

Category：软件开发 Tag：Java 2018-03-30 Views：289

前面介绍的数据结构————线性表、栈和队列都是线性的数据结构，这种数据结构之内的元素只存在一个对一个的关系，存储、处理起来相对简单。本章将要介绍的树则是一种更复杂的数据结构，这种数据结构内的元素存在一个对多个关系，例如，一个父节点可以包含多个子节点。

树也是一种非常常用的数据结构，尤其是二叉树的应用更是广泛，哈夫曼树及哈夫曼编码就是二叉树的重要用途，排序二叉树、平衡二叉树、红黑树再实际编程中都有极为广泛的用途。例如，Java 集合框架的 TreeMap 本质上就是红黑树的实现。

树的概述

作为一种非常常用的数据结构，树与前面介绍的线性表、栈、队列等线性结构不同，它是一种非线性结构。

树的定义和基本术语

计算机世界里的树，是从自然界实际的树抽象而来的，它指的是 N 个有父子关系的节点有限集合。对于这个有限的节点集合而言，它满足如下要求：

  • 当 N=0 时，该节点集合为空，这棵树也被称为空树；
  • 再任意的非空树中，有且仅有一个根（root）节点；
  • 当 N>1 时，除根节点以外的其余节点可分为 M 个互为相交的有限集合 T1、T2……Tm，其中每个集合本身又是一棵树，并称其为根的子树（subtree）。

从上面定义可以发现树的递归特性：一棵树由根和若干颗子树组成，而每个子树又由若干颗更小的子树组成。

树中任一节点可以有 0 或多个子节点，但只能有一个父节点。根节点是一个特例，根节点没有父节点，叶子节点没有子节点。树中每个节点既可以是上一级节点的子节点，也可以是下一级节点的父节点，因此同一个节点可以既是父节点，也是子节点（类似于一个人————他既是他儿子的父亲，又是他父亲的儿子）。

很显然，父子关系是一种非线性的关系，所以树结构是非线性结构。

如果按节点是否包含子节点来分，节点分成以下两种：

  • 普通节点：包含子节点的节点；
  • 叶子节点：没有子节点的节点，因此叶子节点不可作为父节点。

如果按节点是否具有唯一的父节点来分，节点又可以分为如下两种：

  • 根节点：没有父节点的节点，根节点不可作为子节点；
  • 普通节点：具有唯一父节点的节点。

一棵树只能有一个根节点，如果一棵树有了多个根节点，那它已经不再是一棵树，而是多棵树的集合，有时也被称为森林。

与树有关的术语有如下一些：

  • 节点：树的最基本组成单元，常包括一个数据元素及若干指针用于指向其它节点；
  • 节点的度：节点拥有的子数的个数被称为节点的度（degree）；
  • 树的度：树中所有节点的度的最大值就是该树的度；
  • 叶子节点：度为 0 的节点被称叶子节点或终端节点；
  • 分支节点：度不为 0 的节点被称分支节点或非终端节点；
  • 子节点、父节点、兄弟节点：节点的子树的根被称为该节点的子节点，而该节点称做子节点的父节点（parent）。具有相同父节点的子节点之间互称为兄弟节点（sibling）；
  • 节点的层次（level）：节点的层次从根开始算起，根的层次值为 1，其余节点的层次值为父节点的层次值加 1；
  • 树的深度（depth）：树中节点的最大层次值称为树的深度或高度；
  • 有序树与无序树：如果将树中节点的各个子树看成从左到右是有序的（即不能互换），则称该树为有序树，否则称为无序树；
  • 祖先节点（ancestor）：从根到该节点所经分值上的所有节点；
  • 后代节点（descendant）：以某节点为根的子树中任一节点都称为该节点的后代节点；
  • 森林（forest）：森林是 2 颗或 2 颗以上互不相交的树的集合，删去一棵树的根，就得到一个森林。

树的基本操作

如果需要实现一棵树，程序不仅要以合适的方式保存该树的所有节点，还要记录节点与节点之间的父子关系。接下来，还应该为该树实现如下基本操作：

  • 初始化：通常是一个构造器，用于创建一个空的树，或者以指定节点为根来创建树；
  • 为指定节点添加子节点；
  • 判断树是否为空；
  • 返回根节点；
  • 返回指定节点（非根节点）的父节点；
  • 返回指定节点（非叶子节点）的所有子节点；
  • 返回指定节点（非叶子节点）的第 i 个子节点；
  • 返回该树的深度；
  • 返回指定节点的位置。

为了实现树这种数据结构，程序必须能记录节点与节点之间的父子关系，为此有以下两种选择：

  • 父节点表示法：每个子节点都记录它的父节点；
  • 孩子链表示法：每个非叶子节点通过一个链表来记录它所有的子节点。

父节点表示法

通过前面的介绍可以发现：树中除根节点之外的每个节点都有一个父节点。为了记录树中节点与节点之间的父子关系，可以为每个节点增加一个 parent 域，用以记录该节点的父节点。

  1. public class TreeParent<E> {
  2.     public static class Node<T> {
  3.         T data;
  4.         //记录其父节点的位置
  5.         int parent;
  6.         public Node(){
  7.         }
  8.         public Node(T data) {
  9.             this.data = data;
  10.         }
  11.         public Node(T data, int parent) {
  12.             this.data = data;
  13.             this.parent = parent;
  14.         }
  15.         @Override
  16.         public String toString() {
  17.             return "TreeParent$Node[data=" + data + ", parent=" + parent + "]";
  18.         }
  19.     }
  20.     private final int DEFAULT_TREE_SIZE = 100;
  21.     private int treeSize = 0;
  22.     //使用一个Node数组来记录该树里的所有记录
  23.     private Node<E>[] nodes;
  24.     //记录节点数
  25.     private int nodeNums;
  26.     //以指定根节点创建树
  27.     public TreeParent(E data) {
  28.         treeSize = DEFAULT_TREE_SIZE;
  29.         nodes = new Node[treeSize];
  30.         nodes[0] = new Node<>(data, -1);
  31.         nodeNums++;
  32.     }
  33.     //以指定根节点、指定treeSize创建树
  34.     public TreeParent(E data, int treeSize) {
  35.         this.treeSize = treeSize;
  36.         nodes = new Node[treeSize];
  37.         nodes[0] = new Node<>(data, -1);
  38.         nodeNums++;
  39.     }
  40.     //为指定节点添加子节点
  41.     public void addNode(E data, Node parent) {
  42.         for (int i = 0;i < treeSize;i++) {
  43.             //找到数组中第一个为null的元素，该元素保存新节点
  44.             if (nodes[i] == null) {
  45.                 //创建新街点，并用指定的数组元素保存它
  46.                 nodes[i] = new Node(data, pos(parent));
  47.                 nodeNums++;
  48.                 return;
  49.             }
  50.         }
  51.         throw new RuntimeException("该树已满，无法添加新节点");
  52.     }
  53.     //判断树是否为空
  54.     public boolean empty() {
  55.         //根节点是否为null
  56.         return nodes[0] == null;
  57.     }
  58.     //返回根节点
  59.     public Node<E> root() {
  60.         return nodes[0];
  61.     }
  62.     //返回指定节点（非根节点）的父节点
  63.     public Node<E> parent(Node node) {
  64.         //每个节点的parent记录了其父节点的位置
  65.         return nodes[node.parent];
  66.     }
  67.     //返回指定节点（非叶子节点）的所有子节点
  68.     public List<Node<E>> children(Node parent) {
  69.         List<Node<E>> list = new ArrayList<>();
  70.         for (int i = 0;i < treeSize;i++) {
  71.             //如果当前节点的父节点的位置等于parent节点的位置
  72.             if (nodes[i] != null && nodes[i].parent == pos(parent)) {
  73.                 list.add(nodes[i]);
  74.             }
  75.         }
  76.         return list;
  77.     }
  78.     //返回该树的深度
  79.     public int deep() {
  80.         //用于记录节点的最大深度
  81.         int max = 0;
  82.         for (int i = 0;i < treeSize && nodes[i] != null;i++) {
  83.             //初始化本节点的深度
  84.             int def = 1;
  85.             //m记录当前节点的父节点的位置
  86.             int m = nodes[i].parent;
  87.             //如果其父节点存在
  88.             while (m != -1 && nodes[m] != null) {
  89.                 //向上继续搜索父节点
  90.                 m = nodes[m].parent;
  91.                 def++;
  92.             }
  93.             if (max < def) {
  94.                 max = def;
  95.             }
  96.         }
  97.         //返回最大深度
  98.         return max;
  99.     }
  100.     //返回包含指定值的节点
  101.     public int pos(Node node) {
  102.         for (int i = 0;i < treeSize;i++) {
  103.             //如果找到指定节点
  104.             if (nodes[i] == node) {
  105.                 return i;
  106.             }
  107.         }
  108.         return -1;
  109.     }
  110. }

从上面程序的代码中可以看出，定义树节点时增加了一个 parent 域。该 parent 域用于保存该节点的父节点再数组中的位置索引，通过这种方式即可记录树中节点之间的父子关系。

使用这种父节点表示法来存储树时，添加节点时将新节点的 parent 域的值设为其父节点再数组中的索引即可。下面程序简单测试了上面的 TreeParent 类：

  1. public class TreeParentTest {
  2.     public static void main(String[] args) {
  3.         TreeParent<String> tp = new TreeParent<>("root");
  4.         TreeParent.Node root = tp.root();
  5.         System.out.println(root);
  6.         tp.addNode("节点1", root);
  7.         System.out.println("此树的深度：" + tp.deep());
  8.         tp.addNode("节点2", root);
  9.         //获取根节点的所有子节点
  10.         List<TreeParent.Node<String>> nodes = tp.children(root);
  11.         System.out.println("根节点的第一个子节点：" + nodes.get(0));
  12.         //为根节点的第一个子节点新增一个子节点
  13.         tp.addNode("节点3", nodes.get(0));
  14.         System.out.println("此树的深度：" + tp.deep());
  15.     }
  16. }

通过上面介绍可以发现，父节点表示法的特点是：每个节点都可以快速找到它的父节点。但如果要找某个节点的所有子节点就比较麻烦，程序要遍历整个节点数组。

子节点链表示法

父节点表示法的思想是让每个节点“记住”它的父节点的索引，这种方式是从父子节点着手；反过来，还有另外一种方式：让父节点“记住”它的所有子节点。在这种方式下，由于每个父节点需要记住多个子节点，因此必须采用“子节点链”表示法。

采用子节点链表示法来记录树时，需要为每个节点维护一个子节点链，通过该子节点链来记录该节点的所有子节点。下面程序示范了这种“子节点表示法”的树：

  1. public class TreeChild<E> {
  2.     private static class SonNode {
  3.         //记录当前节点的位置
  4.         private int pos;
  5.         private SonNode next;
  6.         public SonNode(int pos, SonNode next) {
  7.             this.pos = pos;
  8.             this.next = next;
  9.         }
  10.     }
  11.     public static class Node<T> {
  12.         T data;
  13.         //记录第一个子节点
  14.         SonNode first;
  15.         public Node(T data) {
  16.             this.data = data;
  17.             this.first = null;
  18.         }
  19.         @Override
  20.         public String toString() {
  21.             if (first != null) {
  22.                 return "TreeChild$Node[data=" + data + ", first=" + first.pos + "]";
  23.             } else {
  24.                 return "TreeChild$Node[data=" + data + ", first=-1]";
  25.             }
  26.         }
  27.     }
  28.     private final int DEFAULT_TREE_SIZE = 100;
  29.     private int treeSize = 0;
  30.     //使用一个Node[]数组来记录该树里的所有节点
  31.     private Node<E>[] nodes;
  32.     //记录节点数
  33.     private int nodeNums;
  34.     //以指定根节点创建树
  35.     public TreeChild(E data) {
  36.         treeSize = DEFAULT_TREE_SIZE;
  37.         nodes = new Node[treeSize];
  38.         nodes[0] = new Node<>(data);
  39.         nodeNums++;
  40.     }
  41.     //以指定根节点，指定treeSize创建树
  42.     public TreeChild(E data, int treeSize) {
  43.         this.treeSize = treeSize;
  44.         nodes = new Node[treeSize];
  45.         nodes[0] = new Node<>(data);
  46.         nodeNums++;
  47.     }
  48.     //为指定节点添加子节点
  49.     public void addNode(E data, Node parent) {
  50.         for (int i = 0;i < treeSize;i++) {
  51.             //找到数组中第一个为null的元素，该元素保存新节点
  52.             if (nodes[i] == null) {
  53.                 //创建新节点，并用指定数组元素来保存它
  54.                 nodes[i] = new Node(data);
  55.                 if (parent.first == null) {
  56.                     parent.first = new SonNode(i, null);
  57.                 } else {
  58.                     SonNode next = parent.first;
  59.                     while (next.next != null) {
  60.                         next = next.next;
  61.                     }
  62.                     next.next = new SonNode(i, null);
  63.                 }
  64.                 nodeNums++;
  65.                 return;
  66.             }
  67.         }
  68.         throw new RuntimeException("该树已满，无法添加新节点");
  69.     }
  70.     //判断树是否为空
  71.     public boolean empty() {
  72.         //根节点是否为null
  73.         return nodes[0] == null;
  74.     }
  75.     //返回根节点
  76.     public Node<E> root() {
  77.         return nodes[0];
  78.     }
  79.     //返回指定节点（非叶子节点）的所有子节点
  80.     public List<Node<E>> children(Node parent) {
  81.         List<Node<E>> list = new ArrayList<>();
  82.         //获取parent节点的第一个子节点
  83.         SonNode next = parent.first;
  84.         //沿着孩子链不断搜索下一个孩子节点
  85.         while (next != null) {
  86.             list.add(nodes[next.pos]);
  87.             next = next.next;
  88.         }
  89.         return list;
  90.     }
  91.     //返回指定节点（非叶子节点）的第index个子节点
  92.     public Node<E> child(Node parent, int index) {
  93.         //获取parent节点的第一个子节点
  94.         SonNode next = parent.first;
  95.         //沿着孩子链不断搜索下一个孩子节点
  96.         for (int i = 0;next != null;i++) {
  97.             if (index == i) {
  98.                 return nodes[next.pos];
  99.             }
  100.             next = next.next;
  101.         }
  102.         return null;
  103.     }
  104.     //返回该树的深度
  105.     public int deep() {
  106.         //获取该树的深度
  107.         return deep(root());
  108.     }
  109.     //这是一个递归方法，每颗子树的深度为其所有子树的最大深度+1
  110.     private int deep(Node node) {
  111.         if (node.first == null) {
  112.             return 1;
  113.         } else {
  114.             //记录其所有子树的最大深度
  115.             int max = 0;
  116.             SonNode next = node.first;
  117.             //沿着孩子链不断搜索下一个孩子节点
  118.             while (next != null) {
  119.                 //获取以其子节点为根的子树的深度
  120.                 int tmp = deep(nodes[next.pos]);
  121.                 if (tmp > max) {
  122.                     max = tmp;
  123.                 }
  124.                 next = next.next;
  125.             }
  126.             //最后，返回其所有子树的最大深度+1
  127.             return max + 1;
  128.         }
  129.     }
  130.     //包含指定值的节点
  131.     public int pos(Node node) {
  132.         for (int i = 0;i < treeSize;i++) {
  133.             //找到指定节点
  134.             if (nodes[i] == node) {
  135.                 return i;
  136.             }
  137.         }
  138.         return -1;
  139.     }
  140. }

从上面程序可以看出，定义树节点时增加了一个 first 域。该 first 域用于保存对该节点的子节点链的引用，通过这种方式即可记录树中节点之间的父子关系。

使用这种子节点链表示法来存储树时，添加节点时只需找到指定父节点的子节点链的最后节点，并让它指向新增的节点。下面程序简单测试了上面的 TreeChild 类：

  1. public class TreeChildTest {
  2.     public static void main(String[] args) {
  3.         TreeChild<String> tp = new TreeChild<>("root");
  4.         TreeChild.Node root = tp.root();
  5.         System.out.println("根节点：" + root);
  6.         tp.addNode("节点1", root);
  7.         tp.addNode("节点2", root);
  8.         tp.addNode("节点3", root);
  9.         System.out.println("添加子节点后的根节点：" + root);
  10.         System.out.println("此树的深度：" + tp.deep());
  11.         //获取根节点的所有子节点
  12.         List<TreeChild.Node<String>> nodes = tp.children(root);
  13.         System.out.println("根节点的第一个子节点：" + nodes.get(0));
  14.         //为根节点的第一个子节点新增一个子节点
  15.         tp.addNode("节点4", nodes.get(0));
  16.         System.out.println("根节点的第一个子节点：" + nodes.get(0));
  17.         System.out.println("此树的深度：" + tp.deep());
  18.     }
  19. }

通过上面介绍可知，子节点链表示法的特点是：每个节点都可以快速找到它的所有子节点。但如果要找某个节点的父节点则比较麻烦，程序要遍历整个节点数组。

二叉树

对于普通树来说，由于它需要遵循的规律太少，程序控制起来反而更加复杂，因此限制了它在实际应用中的使用。如果对普通树增加一些限制，让一棵树中最多只能包含 2 个子节点，而且严格区分左子节点、右子节点（左、右子节点的位置不能交换），这棵树就变成了二叉树。

二叉树的定义和基本概念

二叉树指的是每个节点最多只能有两个子数的有序树。通常左边的子树被称作“左子树”（left subtree），右边的子树被称为“右子树”（right subtree）。由此可见，二叉树依然是树，它是一种特殊的树。

二叉树的每个节点最多只有 2 颗子树（不存在度大于 2 的节点）。二叉树的子树有左、右之分，次序不能颠倒。

树和二叉树两个重要区别：

  • 树中节点的最大度数没有限制，而二叉树节点的最大度数为 2，也就是说二叉树是节点的最大度数为 2 的树；
  • 无序树的节点无左、右之分，而二叉树的节点有左、右之分，也就是说二叉树是有序树。

一颗深度为 k 的二叉树，如果它包含了 2^k-1 个节点，就把这颗二叉树称为满二叉树。满二叉树的特点是每一层上的节点数都是最大节点数，即各层节点数分别为 1、2、4、8、16……2^(k-1)。

一颗有 n 个节点的二叉树，按满二叉树的编号方式对它进行编号，若树中所有节点和满二叉树 1~n 编号完全一致，则称该树为完全二叉树。也就是说，如果一颗二叉树除最后一层外，就其余层的所有节点都是满的，并且最后一层要么是满的，要么仅再右边缺少若干连续的节点，则此二叉树就是完全二叉树。

满二叉树是一种特殊的完全二叉树，当完全二叉树最后一层的所有节点都是满的时，这颗完全二叉树就变成了满二叉树。

综上所述，二叉树大致有如下几个性质：

  • 二叉树第 i 层上的节点数目至多为 2^(i-1)（i >= 1）；
  • 深度为 k 的二叉树至多有 2^k-1 个节点。满二叉树的每层节点的数量依次是1、2、4、8……因此深度为 k 满二叉树包含的节点数为公比为 2 的等比数列的前 k 项总和，即 2^k-1；
  • 再任何一颗二叉树中，如果其叶子节点的数量为 n0，度为 2 的子节点数量为 n2，则 n0=n2+1；
  • 具有 n 个节点的完全二叉树的深度为 log(2)(n+1)；
  • 对一颗有 n 个节点的完全二叉树的节点按层自左向右编号，则对任一编号为 i（n >= i >= 1）的节点有下列性质：
    • 当 i==1 时，节点 i 是二叉树的根；若 i>1，则节点的节点是 i/2；
    • 若 2i<=n，则节点 i 有左孩子，左孩子的编号是 2i，否则，节点无左孩子，并且叶子节点；
    • 若 2i+1<=n，则节点 i 有右孩子，右孩子的编号是 2i+1；否则，节点无右孩子。
  • 对一颗有 n 个节点的完全二叉树的节点按层自左向右编号，1~n/2 范围的节点都是有孩子节点的非叶子节点，其余的节点全部都是叶子节点。编号为 n/2 的节点可能只有左子节点，也可能既有左子节点，又有右子节点。

二叉树的基本操作

二叉树记录其节点之间的父子关系更加简单，因为二叉树中的每个节点最多只能保存 2 个子节点。接下来，程序也需要为二叉树实现如下基本操作：

  • 初始化：通常是一个构造器，用于创建一个空的树，或者以指定节点为根来创建二叉树；
  • 为指定节点添加子节点；
  • 判断二叉树是否为空；
  • 返回根节点；
  • 返回指定节点（非根节点）的父节点；
  • 返回指定节点（非叶子节点）的左子节点；
  • 返回指定节点（非叶子节点）的右子节点；
  • 返回该二叉树的深度；
  • 返回指定节点的位置。

要实现二叉树这种数据结构，有以下 3 种选择：

  • 顺序存储：采用数组来记录二叉树的所有节点；
  • 二叉链表存储：每个节点保留一个 left、right 域，分别指向其左、右子节点；
  • 三叉链表存储：每个节点保留一个 left、right、parent 域，分别指向其左、右子节点和父节点。

二叉树的顺序存储

顺序存储指的是充分利用满二叉树的特性————每层的节点树分别为 1、2、4、8……2^(i-1)，一颗深度为 i 的二叉树最多只能包含 2^i-1 个节点，因此只要定义一个长度为 2^i-1 的数组即可存储这颗二叉树。

对于普通二叉树（不是满的二叉树），那些空出来的节点对应的数组元素留空就可以了。由此可见，二叉树采用顺序存储会造成一定的空间浪费。

当使用数组来村粗二叉树的所有节点时可能为产生一定的空间浪费，如果该二叉树是完全二叉树，就不会有任何空间浪费；但如果该二叉树的所有节点都只有右子节点，那么就会产生相当大的空间浪费了。

掌握上面的理论之后，可以使用如下代码来实现一个顺序存储的二叉树：

  1. public class ArrayBinTree<T> {
  2.     //使用数组来记录该树的所有节点
  3.     private Object[] datas;
  4.     private final int DEFAULT_DEEP = 8;
  5.     //保存该树的深度
  6.     private int deep;
  7.     private int arraySize;
  8.     //以默认的深度创建二叉树
  9.     public ArrayBinTree() {
  10.         this.deep = DEFAULT_DEEP;
  11.         this.arraySize = (int)Math.pow(2, deep) - 1;
  12.         datas = new Object[arraySize];
  13.     }
  14.     //以指定深度创建二叉树
  15.     public ArrayBinTree(int deep) {
  16.         this.deep = deep;
  17.         this.arraySize = (int)Math.pow(2, deep) - 1;
  18.         datas = new Object[arraySize];
  19.     }
  20.     //以指定深度创建、指定根节点创建二叉树
  21.     public ArrayBinTree(int deep, T data) {
  22.         this.deep = deep;
  23.         this.arraySize = (int)Math.pow(2, deep) - 1;
  24.         datas = new Object[arraySize];
  25.         datas[0] = data;
  26.     }
  27.     /**
  28.      * 为指定节点添加子节点
  29.      * @param index 需要添加子节点的父节点索引
  30.      * @param data 新子节点的数据
  31.      * @param left 是否为左节点
  32.      */
  33.     public void add(int index, T data, boolean left) {
  34.         if (datas[index] == null) {
  35.             throw new RuntimeException(index + "处节点为空，无法添加子节点");
  36.         }
  37.         if (2 * index + 1 >= arraySize) {
  38.             throw new RuntimeException("树底层数组已满，树越界异常");
  39.         }
  40.         //添加左子节点
  41.         if (left) {
  42.             datas[2 * index + 1] = data;
  43.         } else {
  44.             datas[2 * index + 2] = data;
  45.         }
  46.     }
  47.     //判断二叉树是否为空
  48.     public boolean empty() {
  49.         //根据根源是判断二叉树是否为空
  50.         return datas[0] == null;
  51.     }
  52.     //返回根节点
  53.     public T root() {
  54.         return (T)datas[0];
  55.     }
  56.     //返回指定节点（非根节点）的父节点
  57.     public T parent(int index) {
  58.         return (T)datas[(index - 1) / 2];
  59.     }
  60.     //返回指定节点（非叶子节点）的左子节点，当左子节点不存在时返回null
  61.     public T left(int index) {
  62.         if (2 * index + 1 >= arraySize) {
  63.             throw new RuntimeException("该节点为叶子节点，无子节点");
  64.         }
  65.         return (T)datas[index * 2 + 1];
  66.     }
  67.     //返回指定节点（非叶子节点）的右子节点，当右子节点不存在时返回null
  68.     public T right(int index) {
  69.         if (2 * index + 1 >= arraySize) {
  70.             throw new RuntimeException("该节点为叶子节点，无子节点");
  71.         }
  72.         return (T)datas[index * 2 + 2];
  73.     }
  74.     //返回该二叉树的深度
  75.     public int deep(int index) {
  76.         return deep;
  77.     }
  78.     //返回指定节点的位置
  79.     public int pos(T data) {
  80.         //该循环实际上就是按广度遍历来搜索每个节点
  81.         for (int i = 0;i < arraySize;i++) {
  82.             if (datas[i].equals(data)) {
  83.                 return i;
  84.             }
  85.         }
  86.         return -1;
  87.     }
  88.     @Override
  89.     public String toString() {
  90.         return java.util.Arrays.toString(datas);
  91.     }
  92. }

从上面介绍可以看出，顺序存储二叉树的思想就是将树中不同的节点存入数组的不同位置。比如，根节点，永远使用数组的第一个元素来保存；第 2 层的第 2 个节点，永远使用数组的第 3 个元素来保存；第 3 层最右边的节点，永远使用数组的第 7 个元素来保存……依次类推。

对于这种顺序存储的二叉树，不管是遍历树中节点，还是查找树中节点，都可以非常高效地完成，唯一的缺点是空间浪费很大。例如下面的测试成语，虽然只为该二叉树保存了 4 个节点，一样需要使用长度为 15 的数组。

  1. public class ArrayBinTreeTest {
  2.     public static void main(String[] args) {
  3.         ArrayBinTree<String> binTree = new ArrayBinTree<>(4, "根");
  4.         binTree.add(0, "第二层右子节点", false);
  5.         binTree.add(2, "第三层右子节点", false);
  6.         binTree.add(6, "第四层右子节点", false);
  7.         System.out.println(binTree);
  8.     }
  9. }

上面程序中的二叉树只有 4 个节点，它们都是每层最右边的节点，因此程序依然需要长度为 15 的数组来保存该二叉树，而且底层数组最后一个数组元素也有值。运行上面程序，可以看到如下输出：

  1. [根, null, 第二层右子节点, null, null, null, 第三层右子节点, null, null, null, null, null, null, null, 第四层右子节点]

二叉树的二叉链表存储

二叉链表存储的思想是让每个节点都能“记住”它的左、右两个子节点。为每个节点增加 left、right 两个指针，分别引用该节点的左、右两个子节点。

二叉链表存储的二叉树的节点大致有如下定义：

  1. class Node {
  2.     T data;
  3.     Node left;
  4.     Node right;
  5. }

对于这种二叉链表存储的二叉树，如果程序需要为指定节点添加子节点也非常容易，让父节点的 left、right 引用指向新节点即可。下面程序以二叉链表实现了二叉树：

  1. public class TwoLinkBinTree<E> {
  2.     public static class TreeNode {
  3.         Object data;
  4.         TreeNode left;
  5.         TreeNode right;
  6.         public TreeNode() {
  7.         }
  8.         public TreeNode(Object data) {
  9.             this.data = data;
  10.         }
  11.         public TreeNode(Object data, TreeNode left, TreeNode right) {
  12.             this.data = data;
  13.             this.left = left;
  14.             this.right = right;
  15.         }
  16.     }
  17.     private TreeNode root;
  18.     //以默认的构造器创建二叉树
  19.     public TwoLinkBinTree() {
  20.         this.root = new TreeNode();
  21.     }
  22.     //以指定根元素创建二叉树
  23.     public TwoLinkBinTree(E data) {
  24.         this.root = new TreeNode(data);
  25.     }
  27.     /**
  28.      * 为指定节点添加子节点
  29.      * @param parent 需要添加子节点的父节点的索引
  30.      * @param data 新子节点的数据
  31.      * @param isLeft 是否为左节点
  32.      * @return 新增的节点
  33.      */
  34.     public TreeNode addNode(TreeNode parent, E data, boolean isLeft) {
  35.         if (parent == null) {
  36.             throw new RuntimeException(parent + "节点为null，无法添加子节点");
  37.         }
  38.         if (isLeft && parent.left != null) {
  39.             throw new RuntimeException("节点已经有左子节点，无法添加左子节点");
  40.         }
  41.         if (!isLeft && parent.right != null) {
  42.             throw new RuntimeException("节点已经有右子节点，无法添加右子节点");
  43.         }
  44.         TreeNode newNode = new TreeNode(data);
  45.         if (isLeft) {
  46.             //让父节点的left引用指向新节点
  47.             parent.left = newNode;
  48.         } else {
  49.             //让父节点的left引用指向新节点
  50.             parent.right = newNode;
  51.         }
  52.         return newNode;
  53.     }
  54.     //判断二叉树是否为空
  55.     public boolean empty() {
  56.         //根据根源是判断二叉树是否为空
  57.         return root.data == null;
  58.     }
  59.     //返回根节点
  61.     public TreeNode root() {
  62.         if (empty()) {
  63.             throw new RuntimeException("树为空，无法访问根节点");
  64.         }
  65.         return root;
  66.     }
  67.     //返回指定节点（非根节点）的父节点
  68.     public E parent(TreeNode node) {
  69.         //对于二叉树链表存储发，如果要访问指定节点的父节点必须遍历二叉树
  70.         return null;
  71.     }
  72.     //返回指定节点（非叶子节点）的左子节点，当左子节点不存在时返回null
  73.     public E leftChild(TreeNode parent) {
  74.         if (parent == null) {
  75.             throw new RuntimeException(parent + "节点为null，无法添加子节点");
  76.         }
  77.         return parent.left == null ? null : (E)parent.left.data;
  78.     }
  79.     //返回指定节点（非叶子节点）的右子节点，当右子节点不存在时返回null
  80.     public E rightChild(TreeNode parent) {
  81.         if (parent == null) {
  82.             throw new RuntimeException(parent + "节点为null，无法添加子节点");
  83.         }
  84.         return parent.right == null ? null : (E)parent.right.data;
  85.     }
  86.     //返回该二叉树的深度
  87.     public int deep() {
  88.         //获取该树的深度
  89.         return deep(root);
  90.     }
  91.     //这是一个递归方法，每颗子树的深度为其所有子树的最大深度 + 1
  92.     private int deep(TreeNode node) {
  93.         if (node == null) {
  94.             return 0;
  95.         }
  96.         //没有子树
  97.         if (node.left == null && node.right == null) {
  98.             return 1;
  99.         } else {
  100.             int leftDeep = deep(node.left);
  101.             int rightDeep = deep(node.right);
  102.             //记录其所有左、右子树中交大的深度
  103.             int max = leftDeep > rightDeep ? leftDeep : rightDeep;
  104.             //返回其左右子树中较大的深度 + 1
  105.             return max + 1;
  106.         }
  107.     }
  108. }

在上面程序中，二叉树中每个节点保留了 left、right 两个引用，分别指向该节点的左、右两个子节点。通过这种方式即可建立二叉树各节点之间的父子关系，下面程序测试了上面的二叉树：

  1. public class TwoLinkBinTreeTest {
  2.     public static void main(String[] args) {
  3.         TwoLinkBinTree<String> binTree = new TwoLinkBinTree<>("根节点");
  4.         //依次添加节点
  5.         TwoLinkBinTree.TreeNode tn1 = binTree.addNode(binTree.root(), "第二层左节点", true);
  6.         TwoLinkBinTree.TreeNode tn2 = binTree.addNode(binTree.root(), "第二层右节点", false);
  7.         TwoLinkBinTree.TreeNode tn3 = binTree.addNode(tn2, "第三层左节点", true);
  8.         TwoLinkBinTree.TreeNode tn4 = binTree.addNode(tn2, "第三层右节点", false);
  9.         TwoLinkBinTree.TreeNode tn5 = binTree.addNode(tn3, "第四层左节点", true);
  10.         System.out.println("tn2的左子节点：" + binTree.leftChild(tn2));
  11.         System.out.println("tn2的右子节点：" + binTree.rightChild(tn2));
  12.         System.out.println(binTree.deep());
  13.     }
  14. }

对于这种二叉链表的二叉树，因为程序采用链表来记录树中所有节点，所以添加节点没有限制，而且不会像顺序存储那样产生大量的空间浪费。当然，这种二叉链表的存储方式再遍历树节点时效率不高，指定节点访问父节点时也比较困难，程序必须采用遍历二叉树的方式来搜索其父节点。

为了克服二叉链表存储方式中访问父节点不方便的问题，可以将二叉链表拓展成三叉链表。

二叉树的三叉链表存储

三叉链表存储的思想是让每个节点不仅“记住”它的左、右两个子节点，还“记住”它的父节点，因此需要为每个节点增加 left、right 和 parent 3 个指针，分别引用该节点的左、右两个节点和父节点。

二叉链表存储和三叉链表存储都是根据该二叉树的节点特征来划分的。对于二叉链表存储而言，二叉树的每个节点需要 2 个“分叉”，分别记录该节点的左、右 2 个子节点；对于三叉链表存储而言，二叉树的每个节点需要 3 个“分叉”，分别记录该节点的左、右 2 个子节点和父节点。

因此，三叉链表存储的二叉树的节点大致右如下定义：

  1. class Node {
  2.     T data;
  3.     Node left;
  4.     Node right;
  5.     Node parent;
  6. }

对于这种三叉链表存储的二叉树，如果程序需要为指定节点添加子节点也非常容易，除了要维护父节点的 left、right 引用之外，还要维护新增节点的 parent 引用。下面程序以三叉链表实现了二叉树：

  1. public class ThreeLinkBinTree<E> {
  2.     public static class TreeNode {
  3.         Object data;
  4.         TreeNode left;
  5.         TreeNode right;
  6.         TreeNode parent;
  7.         public TreeNode() {
  8.         }
  9.         public TreeNode(Object data) {
  10.             this.data = data;
  11.         }
  12.         public TreeNode(Object data, TreeNode left, TreeNode right, TreeNode parent) {
  13.             this.data = data;
  14.             this.left = left;
  15.             this.right = right;
  16.             this.parent = parent;
  17.         }
  18.     }
  19.     private TreeNode root;
  20.     //以默认的构造器创建二叉树
  21.     public ThreeLinkBinTree() {
  22.         this.root = new TreeNode();
  23.     }
  24.     //以指定根元素创建二叉树
  25.     public ThreeLinkBinTree(E data) {
  26.         this.root = new TreeNode(data);
  27.     }
  29.     /**
  30.      * 为指定节点添加子节点
  31.      * @param parent 需要添加子节点的父节点的索引
  32.      * @param data 新子节点的数据
  33.      * @param isLeft 是否为左节点
  34.      * @return 新增的节点
  35.      */
  36.     public TreeNode addNode(TreeNode parent, E data, boolean isLeft) {
  37.         if (parent == null) {
  38.             throw new RuntimeException(parent + "节点为null，无法添加子节点");
  39.         }
  40.         if (isLeft && parent.left != null) {
  41.             throw new RuntimeException("节点已经有左子节点，无法添加左子节点");
  42.         }
  43.         if (!isLeft && parent.right != null) {
  44.             throw new RuntimeException("节点已经有右子节点，无法添加右子节点");
  45.         }
  46.         TreeNode newNode = new TreeNode(data);
  47.         if (isLeft) {
  48.             //让父节点的left引用指向新节点
  49.             parent.left = newNode;
  50.         } else {
  51.             //让父节点的left引用指向新节点
  52.             parent.right = newNode;
  53.         }
  54.         //让新节点的parent引用到parent节点
  55.         newNode.parent = parent;
  56.         return newNode;
  57.     }
  58.     //判断二叉树是否为空
  59.     public boolean empty() {
  60.         //根据根源是判断二叉树是否为空
  61.         return root.data == null;
  62.     }
  63.     //返回根节点
  65.     public TreeNode root() {
  66.         if (empty()) {
  67.             throw new RuntimeException("树为空，无法访问根节点");
  68.         }
  69.         return root;
  70.     }
  71.     //返回指定节点（非根节点）的父节点
  72.     public E parent(TreeNode node) {
  73.         if (node == null) {
  74.             throw  new RuntimeException(node + "节点为null，无法访问其父节点");
  75.         }
  76.         return (E)node.parent.data;
  77.     }
  78.     //返回指定节点（非叶子节点）的左子节点，当左子节点不存在时返回null
  79.     public E leftChild(TreeNode parent) {
  80.         if (parent == null) {
  81.             throw new RuntimeException(parent + "节点为null，无法添加子节点");
  82.         }
  83.         return parent.left == null ? null : (E)parent.left.data;
  84.     }
  85.     //返回指定节点（非叶子节点）的右子节点，当右子节点不存在时返回null
  86.     public E rightChild(TreeNode parent) {
  87.         if (parent == null) {
  88.             throw new RuntimeException(parent + "节点为null，无法添加子节点");
  89.         }
  90.         return parent.right == null ? null : (E)parent.right.data;
  91.     }
  92.     //返回该二叉树的深度
  93.     public int deep() {
  94.         //获取该树的深度
  95.         return deep(root);
  96.     }
  97.     //这是一个递归方法，每颗子树的深度为其所有子树的最大深度 + 1
  98.     private int deep(TreeNode node) {
  99.         if (node == null) {
  100.             return 0;
  101.         }
  102.         //没有子树
  103.         if (node.left == null && node.right == null) {
  104.             return 1;
  105.         } else {
  106.             int leftDeep = deep(node.left);
  107.             int rightDeep = deep(node.right);
  108.             //记录其所有左、右子树中交大的深度
  109.             int max = leftDeep > rightDeep ? leftDeep : rightDeep;
  110.             //返回其左右子树中较大的深度 + 1
  111.             return max + 1;
  112.         }
  113.     }
  114. }

从上面的程序可以看出，三叉链表存储方式是对二叉链表的一种改进，通过为树节点增加一个 parent 引用，可以让每个节点都能非常方便地访问其父节点。三叉链表存储的二叉树既可方便地向下访问节点，也可以方便地向上访问节点。

遍历二叉树

遍历二叉树指的是按某种规律依次访问二叉树的每个节点，对二叉树的遍历过程就是将非线性结构的热茶岁的节点排列在一个线性序列上的过程。

如果采用顺序结构来保存二叉树，程序遍历二叉树将非常容易，无需进行任何思考，直接遍历底层数组接口即可。如果采用链表来保存二叉树的节点，则有以下两类遍历方式。

  • 深度优先遍历：这种遍历算法将先访问到树中最深的层次的节点；
  • 广度优先遍历：这种遍历算法将逐层访问每层的节点，先访问根（第一层）节点，然后访问第二层的节点……依次类推。因此，广度优先遍历方法又被称为按层遍历。

对于深度优先的遍历算法而言，它又可分为以下 3 种。

  • 先（前）序遍历二叉树；
  • 中序遍历二叉树；
  • 后序遍历二叉树。

如果 L、D、R 表示左子树、根、右子树，习惯上总是必须先遍历左子树，后遍历右子树，根据遍历根节点的顺序不同，上面 3 种算法可如下表示：

  • DLR：先序遍历；
  • LDR：中序遍历；
  • LRD：后序遍历。

深度遍历的先序遍历、中序遍历、后序遍历这 3 种遍历方式的名称都是针对根节点（D）而言，而处理根节点（D）时就称为先序遍历，其次处理根节点（D）时就称为中序遍历，最后处理根节点（D）时就称为后序遍历。

因为二叉树的定义本身就有“递归性”，所以深度优先遍历时能非常方便地利用递归来遍历每个节点：一颗非空二叉树由树根、左子树和右子树组成，依次遍历这 3 部分，就可以变量整个二叉树。

先序遍历

先序遍历指先处理根节点，其处理顺序如下：

  1. 访问根节点；
  2. 递归遍历左子树；
  3. 递归遍历右子树。

实现先序遍历的方法如下：

  1.     public List<TreeNode> preIterator() {
  2.         return preIterator(root);
  3.     }
  4.     private List<TreeNode> preIterator(TreeNode node) {
  5.         List<TreeNode> list = new ArrayList<>();
  6.         //处理根节点
  7.         list.add(node);
  8.         if (node.left != null) {
  9.             list.addAll(preIterator(node.left));
  10.         }
  11.         if (node.right != null) {
  12.             list.addAll(preIterator(node.right));
  13.         }
  14.         return list;
  15.     }

中序遍历

中序遍历指其次处理根节点，其处理顺序如下：

  1. 递归遍历左子树；
  2. 访问根节点；
  3. 递归遍历右子树。

实现中序遍历的方法如下：

  1.     public List<TreeNode> inIterator() {
  2.         return inIterator(root);
  3.     }
  4.     private List<TreeNode> inIterator(TreeNode node) {
  5.         List<TreeNode> list = new ArrayList<>();
  6.         //递归处理左子树
  7.         if (node.left != null) {
  8.             list.addAll(inIterator(node.left));
  9.         }
  10.         //处理根节点
  11.         list.add(node);
  12.         //递归处理右子树
  13.         if (node.right != null) {
  14.             list.addAll(inIterator(node.right));
  15.         }
  16.         return list;
  17.     }

后序遍历

后序遍历指最后处理根节点。其处理顺序如下：

  1. 递归遍历左子树；
  2. 递归遍历右子树；
  3. 访问根节点。

实现后序遍历的方法如下：

  1.     public List<TreeNode> postIterator() {
  2.         return postIterator(root);
  3.     }
  4.     private List<TreeNode> postIterator(TreeNode node) {
  5.         List<TreeNode> list = new ArrayList<>();
  6.         //递归处理左子树
  7.         if (node.left != null) {
  8.             list.addAll(postIterator(node.left));
  9.         }
  10.         //递归处理右子树
  11.         if (node.right != null) {
  12.             list.addAll(postIterator(node.right));
  13.         }
  14.         //处理根节点
  15.         list.add(node);
  16.         return list;
  17.     }

广度优先（按层）遍历

广度优先遍历又称为按层遍历，整个遍历算法先遍历二叉树的第一层（根节点），再遍历根节点的两个子节点（第二层）……以此类推，逐层遍历二叉树的所有节点。

为了实现广度遍历，可以借助于具有“FIFO”特征的队列来实现，如下所示。

  1. 建立一个队列（先进先出），把树的根节点压入队列；
  2. 从队列中弹出一个节点（第一次弹出的就是根节点），然后把该节点的左、右节点压入队列，如果没有子节点，则说明已经到达叶子节点了；
  3. 用循环重复执行第 2 步，直到队列为空。当队列为空时，说明所有的叶子节点（深度最深的层）都已经经过了队列，也就完成了遍历。

基于上面给定的思想，可以用如下程序来实现广度优先遍历。

  1.     //广度优先遍历
  2.     public List<TreeNode> breadthFirst() {
  3.         Queue<TreeNode> queue = new ArrayDeque<>();
  4.         List<TreeNode> list = new ArrayList<>();
  5.         if (root != null) {
  6.             //将根元素加入队列
  7.             queue.offer(root);
  8.         }
  9.         while (!queue.isEmpty()) {
  10.             //将该队列的“队尾”的元素加入到List中
  11.             list.add(queue.peek());
  12.             TreeNode p = queue.poll();
  13.             //如果左子节点不为null，将它加入队列
  14.             if (p.left != null) {
  15.                 queue.offer(p.left);
  16.             }
  17.             //如果右子节点不为null，将它加入队列
  18.             if (p.right != null) {
  19.                 queue.offer(p.right);
  20.             }
  21.         }
  22.         return list;
  23.     }

从上面的代码可以看出，为了实现二叉树的广度遍历，程序借助一个 Queue 对象，这是从 JDK1.5 提供的一个队列接口。通过这个队列接口，可以非常方便地对二叉树实现广度优先遍历。

森林、树和二叉树的转换

由于二叉树是一种更“确定”（它的每个节点最多只有 2 个子节点）的数据结构，因此不管是存储、增加、删除节点，还是遍历节点，程序都可以更简单、方便地实现。反之，由于树的每个节点具有个数不确定的子节点，因此程序实现起来更复杂。

为了充分利用二叉树的简单易用性，可以将普通树转换为二叉树，以二叉树的形式来保存普通树，当程序需要树时，再将二叉树转换为普通树。

森林其实更简单，如果将一颗普通树的根节点去掉，这棵树就变成了森林。或者可以转换一下思维，森林其实就是有多个根节点的树。

森林、树和二叉树之间的转换

有序树、森林和二叉树之间有一一映射关系，可以进行相互转换。

多叉树向二叉树转换的方法如下：

  1. 加虚线：同一个父节点的相邻兄弟节点之间加虚线；
  2. 抹实线：每节点只保留它与最左子节点的连线，与其它子节点的连线都被抹掉；
  3. 旋改实：虚线改为实线。

多叉树转二叉树的方法关键思想就是：所有子节点只保留子节点，其它节点转为左子节点的右子节点链。

按照这种转换思路，森林也可以转换为二叉树————只要把森林当成一颗根节点被删除的多叉树。

反过来，二叉树也可恢复出对应的多叉树、森林，恢复方法如下：

  1. 加虚线：若某节点 I 是父节点的左子节点，则将该节点 I 的右孩子链的所有节点分别与节点 I 的父节点添加连线；
  2. 抹线：把所有虚线的节点与原父节点的连线抹去；
  3. 整理：虚改实并按层排列。

如果二叉树的根节点有右子节点————右子节点就代表是根节点的兄弟节点，这种情况会转换得到森林。

树的链式存储

根据上面介绍的理论，二叉树可以在多叉树之间进行自由转换，因此可以得到普通树的另外一种保存方式：以二叉树的形式来保存多叉树，实际需要的时候再将二叉树转换为普通树。

至于到底以哪种方式来保存二叉树，完全是自由的。通常会选择使用三叉链表存储来保存二叉树，这样得到的二叉树操作起来更方便，进行二叉树和多叉树之间转换时也更方便。

哈夫曼树

哈夫曼树又被称为最优二叉树，是一类带权路径最短的二叉树。哈夫曼树是二叉树的一种应用，再信息检索中很常用。

哈夫曼树的定义和基本概念

介绍哈夫曼树之前闲来介绍一些相关的概念

  • 节点之间的路径长度：从一个节点到另一个节点之间的分支数量称为两个节点之间的路径长度；
  • 树的路径长度：从根节点到树中每一个节点的路径长度之和。
  • 节点的带权路径长度：从该节点到根节点之间的路径长度与节点上权的乘积；
  • 树的带权路径长度：树中所有叶子节点的带权路径长度之和。

带权路径最小的二叉树被称为哈夫曼树或最优二叉树。

对于哈夫曼树，有一个很重要的定理：对于具有 n 个叶子节点的哈夫曼树，一共需要 2*n-1 个节点。因为对于二叉树来说，有 3 种类型节点，即度数为 2 的节点、度数为 1 的节点和度数为 0 的叶节点，而哈夫曼树的非叶子节点都是由两个节点合并产生，所以不会出现度数为 1 的节点。而生成的非叶子节点的个数为叶子节点个数 -1，因此 n 个叶子节点的哈夫曼树，一共需要 2*n-1 个节点。

创建哈夫曼树

创建哈夫曼树，可以按如下步骤进行：

  1. 根据给定的 n 个权值｛w1,w2,……,wn｝构造 n 颗二叉树的集合 F = ｛T1,T2,……,Tn｝，F 集合中每颗二叉树都只有一个根节点；
  2. 选取 F 集合中每颗根节点的权值最小的树作为左、右子树以构造一颗新的二叉树，且将新的二叉树的根节点的权值设为左、右子树上根节点的权值之和；
  3. 将新的二叉树加入到 F 集合中，并删除 2 步中被选中的两棵树；
  4. 重复 2 和 3 步直到 F 集合只剩下一棵树，这棵树就是哈夫曼树。

基于上面思想，对指定节点集合创建哈夫曼树，示例如下：

  1. public class HuffmanTree {
  2.     public static class Node<E> {
  3.         E data;
  4.         double weight;
  5.         Node leftChild;
  6.         Node rightChild;
  7.         public Node(E data, double weight) {
  8.             this.data = data;
  9.             this.weight = weight;
  10.         }
  11.         @Override
  12.         public String toString() {
  13.             return "Node[data=" + data + ", weight=" + weight + "]";
  14.         }
  15.     }
  16.     public static void main(String[] args) {
  17.         List<Node> nodes = new ArrayList<>();
  18.         nodes.add(new Node("A", 40.0));
  19.         nodes.add(new Node("B", 8.0));
  20.         nodes.add(new Node("C", 10.0));
  21.         nodes.add(new Node("D", 30.0));
  22.         nodes.add(new Node("E", 10.0));
  23.         nodes.add(new Node("F", 2.0));
  24.         Node root = HuffmanTree.createTree(nodes);
  25.         System.out.println(breadthFirst(root));
  26.     }
  28.     /**
  29.      * 构造哈夫曼树
  30.      * @param nodes 节点集合
  31.      * @return 构造出来的韩服满树的更节点
  32.      */
  33.     private static Node createTree(List<Node> nodes) {
  34.         //只要还有nodes数组中还有两个以上的节点
  35.         while (nodes.size() > 1) {
  36.             quickSort(nodes);
  37.             //获取权值最小的两个节点
  38.             Node left = nodes.get(nodes.size() - 1);
  39.             Node right = nodes.get(nodes.size() - 2);
  40.             //生成新节点，新节点的权值为两个子节点的权值之和
  41.             Node parent = new Node(null, left.weight + right.weight);
  42.             //让新节点作为权值最小的两个节点的父节点
  43.             parent.leftChild = left;
  44.             parent.rightChild = right;
  45.             //删除权值最小的两个节点
  46.             nodes.remove(nodes.size() - 1);
  47.             nodes.remove(nodes.size() - 2);
  48.             //将新生成的父节点添加到集合中
  49.             nodes.add(parent);
  50.         }
  51.         //返回nodes集合中唯一的节点，也就是根节点
  52.         return nodes.get(0);
  53.     }
  54.     //将指定数组的 i 和 j 索引处的元素交换
  55.     private static void swap(List<Node> nodes, int i, int j) {
  56.         Node tmp = nodes.get(i);
  57.         nodes.set(i, nodes.get(j));
  58.         nodes.set(j, tmp);
  59.     }
  60.     //实现快速排序算法，用于对节点进行排序
  61.     private static void subSort(List<Node> nodes, int start, int end) {
  62.         //需要排序
  63.         if (start < end) {
  64.             //以第一个元素作为分界值
  65.             Node base = nodes.get(start);
  66.             //i从左边搜索，搜索大于分界值的元素的索引
  67.             int i = start;
  68.             //j从右边开始搜索，搜索小于分界值的索引
  69.             int j = end + 1;
  70.             while (true) {
  71.                 //找到大于分界值的元素的索引，或者i已经到了end处
  72.                 while (i < end && nodes.get(i).weight >= base.weight) {
  73.                     i++;
  74.                 }
  75.                 //找到小于分界值的元素的索引，或者j已经到了start处
  76.                 while (j > start && nodes.get(j).weight <= base.weight) {
  77.                     j--;
  78.                 }
  79.                 if (i < j) {
  80.                     swap(nodes, i, j);
  81.                 } else {
  82.                     break;
  83.                 }
  84.             }
  85.             swap(nodes, start, j);
  86.             //递归左边子序列
  87.             subSort(nodes, start, j - 1);
  88.             //递归右边子序列
  89.             subSort(nodes, j + 1, end);
  90.         }
  91.     }
  92.     public static void quickSort(List<Node> nodes) {
  93.         subSort(nodes, 0, nodes.size() - 1);
  94.     }
  95.     //广度优先遍历
  96.     public static List<Node> breadthFirst(Node root) {
  97.         Queue<Node> queue = new ArrayDeque<>();
  98.         List<Node> list = new ArrayList<>();
  99.         if (root != null) {
  100.             //将根元素入队列
  101.             queue.offer(root);
  102.         }
  103.         while (!queue.isEmpty()) {
  104.             //将该队列的队尾的元素添加到List中
  105.             list.add(queue.peek());
  106.             Node p = queue.poll();
  107.             //如果左子节点不为null，将它加入队列
  108.             if (p.leftChild != null) {
  109.                 queue.offer(p.leftChild);
  110.             }
  111.             //如果右子节点不为null，将它加入队列
  112.             if (p.rightChild != null) {
  113.                 queue.offer(p.rightChild);
  114.             }
  115.         }
  116.         return list;
  117.     }
  118. }

上面的程序完成了如下事情：

  1. 对 List 集合中所有节点进行排序；
  2. 找出 List 集合中权值最小的两个节点；
  3. 以权值最小的两个节点作为子节点创建新节点；
  4. 从 List 集合中删除权值最小的两个节点，将新节点添加到 List 集合中。

程序采用循环不断地执行上面 1、2、3、4 步，直到 List 集合中只剩下一个节点，最后剩下的这个节点就是哈夫曼树的根节点。

哈夫曼编码

根据哈夫曼树可以解决报文编码问题。假设需要把一个字符串如“abcdabcaba”进行编码，将它转换成唯一的二进制码，但要求转换出来的二进制码最小。

假设每个字符再字符串中出现的频率为 W，其编码长度为 L，编码字符 n 个，则编码后二进制码的长度整为 W1L1 + W2L2 + W3L3 + …… + WnLn，这正好复合哈夫曼树的处理原则。因此可采用哈夫曼树的原理构造二进制编码，并使电文长度最短。

对于“abcdabcaba”字符串，总共只有 a、b、c、d 4 个字符，它们出现的次数分别是 4、3、2、1 次————这相当于它们的权值。于是，将 a、b、c、d 4 个字符以出现次数的权值构造哈夫曼树如下所示：

  1.  ()
  2.  /\
  3. a ()
  4.   /\
  5.  b ()
  6.    /\
  7.   c  d

从哈夫曼树根节点开始，对左子树分配代码“0”，对右子树分配代码“1”，一直到达叶子节点。然后，将从树沿每条路径到达叶子节点的代码排列起来，便得到了每个叶子节点的哈夫曼编码。示例如下：

  1.   ()
  2.  0/\1
  3.  /  \
  4. a    ()
  5. 0   0/\1
  6.     /  \
  7.    b    ()
  8.   10   0/\1
  9.        /  \
  10.       c     d
  11.      110   111

从上面可以看出，a 的哈夫曼编码为 0、b 的哈夫曼编码为 10，c 的哈夫曼编码为 110，d 的哈夫曼编码为 111。然后将“abcdabcaba”这个字符串转换为对应的二进制编码为 0101101110101100100，长度仅为 19。这就是该字符串的最短二进制编码，也被称为哈夫曼编码。

根据上面介绍的规律不难发现，哈夫曼编码有一个规律：假设有 N 个叶子节点需要编码，最终得到的哈夫曼树一定有 N 层，哈夫曼编码的到的二进制码的最大长度为 N-1。

程序将 N 个叶子节点按权值由小到大排列，这些叶子节点对应的哈夫曼编码依次为 0、10、110、1110、……、11…10、11…11（一共有 N-1 位）。

排序二叉树

排序二叉树是一种特殊结构的二叉树，通过它可以非常方便地对树中所有节点依次排序和检索。

排序二叉树要么是一颗空二叉树，要么是具有以下性质的二叉树。

  • 若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
  • 若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
  • 它的左、右子树也分别为排序二叉树。
  1.      10
  2.     /  \
  3.    /    \
  4.   3      18
  5.   /\      /\
  6.  /  \    /  \
  7. 2    4  13  21
  8.       \
  9.        \
  10.         9
  11.         /\
  12.        /  \
  13.       8    9

对于上面的排序二叉树，对排序二叉树，若按中序遍历就可以得到由小到大的有序序列：｛2, 3, 4, 8, 9, 9, 10, 13, 15, 18｝

创建排序二叉树的步骤，就是不断地向排序二叉树添加节点的过程，具体如下：

  1. 以根节点为当前节点开始搜索；
  2. 拿新节点的值和当前节点的值比较；
  3. 如果新节点的值更大，则以当前节点的右子节点作为新的当前节点；如果新节点的值更小，则以当前节点的左子节点作为新的当前节点；
  4. 重复 2、3 两个步骤，直到搜索到合适的叶子节点；
  5. 将新节点添加为第 4 步找到的叶子节点的子节点，如果新节点更大，则添加为右子节点；否则，加为左子节点。

当程序从排序二叉树中删除一个节点之后，为了让它依然保持为排序二叉树，必须对该排序二叉树进行维护。维护颗分为如下几种情况：

  1. 被删除的节点是叶子节点，只需要将它从父节点中删除；
  2. 被删除节点 p 只有左子树，将 p 的左子树 pL 添加成 p 的父节点的左子树即可；被删除节点 p 只有右子树，将 p 的右子树 pR 添加成 p 的父节点的右子树即可；
  3. 若被删除节点 p 的左、右子树均非空，有以下两种做法：
    • 将 pL 设为 p 的父节点 q 的左或右子节点（取决于 p 是其父节点 q 的左、右子节点），将 pR 设为 p 节点的中序前趋节点 s 的右子节点（s 是 pL 最右下的节点，也就是 pL 子树中最大的节点）；
    • 以 p 节点的中序前趋或后继替代 p 所指节点，然后再从原排序二叉树中删去中序前趋或后继节点。（也就是，用大于 p 的最小节点或小于 p 的最大节点代替 p 节点。）

被删除节点只有左子树的情况示例：

  1.     18                            18
  2.   /    \                        /    \
  3.  /      \                      /      \
  4. 12       30(删除该节点)        12       23
  5.  \       /                     \         \
  6.   \     /                       \         \
  7.    14  23                        14        26
  8.    /    \                        /
  9.   /      \                      /
  10.  13       26                   13

被删除节点只有右子树的情况示例：

  1.     18                            18
  2.   /    \                        /    \
  3.  /      \                      /      \
  4. 12(删除) 30                   14       30
  5.  \       /                   /         /
  6.   \     /                   /         /
  7.    14  23                  13        23
  8.    /    \                             \
  9.   /      \                             \
  10.  13       26                            26

被删除节点既有左子节点，又有右子节点的情形。此时采用第 1 种方式进行维护。示例：

  1.     5                             5
  2.   /   \                         /   \
  3.  /     \                       /     \
  4. 3       20(删除)              3       10
  5.        /   \                         /  \
  6.       /     \                       /    \
  7.      10      30                    8      15
  8.      /\                                    \
  9.     /  \                                    \
  10.    8    15                                   30

被删除节点既有左子树，又有右子树的情形。此时采用第 2 种方式进行维护。示例：

  1.     5                             5
  2.   /   \                         /   \
  3.  /     \                       /     \
  4. 3       15(删除)              3       30
  5.        /   \                         /
  6.       /     \                       /
  7.      10      30                    10
  8.      /                            /  \
  9.     /                            /    \
  10.    8                            8      15

掌握上面理论之后，使用如下 Java 程序来实现排序二叉树。实现排序二叉树的删除节点采用上面第 2 种方式进行维护，也就是用被删除节点的左子树中最大节点与被删除节点交换的方式进行维护。

  1. public class SortBinTree<T extends Comparable> {
  2.     static class Node {
  3.         Object data;
  4.         Node parent;
  5.         Node left;
  6.         Node right;
  7.         public Node(Object data, Node parent, Node left, Node right) {
  8.             this.data = data;
  9.             this.parent = parent;
  10.             this.left = left;
  11.             this.right = right;
  12.         }
  13.         @Override
  14.         public String toString() {
  15.             return "[data=" + data + "]";
  16.         }
  17.         @Override
  18.         public boolean equals(Object obj) {
  19.             if (this == obj) {
  20.                 return true;
  21.             }
  22.             if (obj.getClass() == Node.class) {
  23.                 Node target = (Node)obj;
  24.                 return data.equals(target.data)
  25.                         && left == target.left
  26.                         && right == target.right
  27.                         && parent == target.parent;
  28.             }
  29.             return false;
  30.         }
  31.     }
  32.     private Node root;
  33.     //两个构造器用于创建排序二叉树
  34.     public SortBinTree() {
  35.         root = null;
  36.     }
  37.     public SortBinTree(T o) {
  38.         root = new Node(o, null, null, null);
  39.     }
  40.     //添加节点
  41.     public void add(T ele) {
  42.         //如果根节点为null
  43.         if (root == null) {
  44.             root = new Node(ele, null, null, null);
  45.         } else {
  46.             Node current = root;
  47.             Node parent = null;
  48.             int cmp = 0;
  49.             //搜索合适的叶子节点，以该叶子节点为父节点添加新节点
  50.             do {
  51.                 parent = current;
  52.                 cmp = ele.compareTo(current.data);
  53.                 //如果新节点的值大于当前节点的值
  54.                 if (cmp > 0) {
  55.                     //以右子节点作为当前节点
  56.                     current = current.right;
  57.                 } else {
  58.                     //以左子节点作为当前节点
  59.                     current = current.left;
  60.                 }
  61.             } while (current != null);
  62.             //创建新节点
  63.             Node newNode = new Node(ele, parent, null, null);
  64.             //如果新节点的值大于父节点的值
  65.             if (cmp > 0) {
  66.                 //新节点作为父节点的右子节点
  67.                 parent.right = newNode;
  68.                 //如果新节点的值小于父节点的值
  69.             } else {
  70.                 //新节点作为父节点的左子节点
  71.                 parent.left = newNode;
  72.             }
  73.         }
  74.     }
  75.     //删除节点
  76.     public void remove(T ele) {
  77.         //获取要删除的节点
  78.         Node target = getNode(ele);
  79.         if (target == null) {
  80.             return;
  81.         }
  82.         //左、右子树为空
  83.         if (target.left == null && target.right == null) {
  84.             //被删除节点是根节点
  85.             if (target == root) {
  86.                 root = null;
  87.             } else {
  88.                 //被删除节点是父节点的左子节点
  89.                 if (target == target.parent.left) {
  90.                     //将target的父节点的left改为null
  91.                     target.parent.left = null;
  92.                 } else {
  93.                     //将target的父节点的right设为null
  94.                     target.parent.right = null;
  95.                 }
  96.                 target.parent = null;
  97.             }
  98.             //左子树为空，右子树不为空
  99.         } else if (target.left == null && target.right != null) {
  100.             //被删除的是根节点
  101.             if (target == root) {
  102.                 root = target.right;
  103.             } else {
  104.                 //被删除节点是父节点的左子节点
  105.                 if (target == target.parent.left) {
  106.                     //让target的父节点的left指向target的右子树
  107.                     target.parent.left = target.right;
  108.                 } else {
  109.                     //让target的父节点的right指向target的右子树
  110.                     target.parent.right = target.right;
  111.                 }
  112.                 //让target的右子树的parents指向target的parent
  113.                 target.right.parent = target.parent;
  114.             }
  115.             //左子树不为空，右子树为空
  116.         } else if (target.left != null && target.right == null) {
  117.             //被删除节点是根节点
  118.             if (target == root) {
  119.                 root = target.left;
  120.             } else {
  121.                 //被删除节点是父节点的左子节点
  122.                 if (target == target.parent.left) {
  123.                     //让target的父节点的left指向target的左子树
  124.                     target.parent.left = target.left;
  125.                 } else {
  126.                     //让target的父节点的right指向target的左子树
  127.                     target.parent.right = target.left;
  128.                 }
  129.                 //让target的左子树的parent指向target的parent
  130.                 target.left.parent = target.parent;
  131.             }
  132.             //左、右子树都不为空
  133.         } else {
  134.             //leftMaxNode用于保存target节点的左子树中值最大的节点
  135.             Node leftMaxNode = target.left;
  136.             //搜索target节点的左子树中值最大的节点
  137.             while (leftMaxNode.right != null) {
  138.                 leftMaxNode = leftMaxNode.right;
  139.             }
  140.             //从原来的子树中删除leftMaxNode节点
  141.             leftMaxNode.parent.right = null;
  142.             //让leftMaxNode的parent指向target的parent
  143.             leftMaxNode.parent = target.parent;
  144.             //被删除节点是父节点的左子节点
  145.             if (target == target.parent.left) {
  146.                 //让target的父节点的left指向leftMaxNode
  147.                 target.parent.left = leftMaxNode;
  148.             } else {
  149.                 //让target的父节点的right指向leftMaxNode
  150.                 target.parent.right = leftMaxNode;
  151.             }
  152.             leftMaxNode.left = target.left;
  153.             leftMaxNode.right = target.right;
  154.             target.parent = target.left = target.right = null;
  155.         }
  156.     }
  157.     //根据给定的值搜索节点
  158.     public Node getNode(T ele) {
  159.         //从根节点开始搜索
  160.         Node p = root;
  161.         while (p != null) {
  162.             int cmp = ele.compareTo(p.data);
  163.             //如果搜索的值小于当前p节点的值
  164.             if (cmp < 0) {
  165.                 //向左子树搜索
  166.                 p = p.left;
  167.                 //如果搜索的值大于当前p节点的值
  168.             } else if (cmp > 0) {
  169.                 //向右子树搜索
  170.                 p = p.right;
  171.             } else {
  172.                 return p;
  173.             }
  174.         }
  175.         return null;
  176.     }
  177.     //广度遍历优先
  178.     public List<Node> breadthFirst() {
  179.         Queue<Node> queue = new ArrayDeque<>();
  180.         List<Node> list = new ArrayList<>();
  181.         if (root != null) {
  182.             //将根元素入队列
  183.             queue.offer(root);
  184.         }
  185.         while (!queue.isEmpty()) {
  186.             //将该队列的队尾的元素添加到List中
  187.             list.add(queue.peek());
  188.             Node p = queue.poll();
  189.             //如果左子节点不为null，将它加入队列
  190.             if (p.left != null) {
  191.                 queue.offer(p.left);
  192.             }
  193.             //如果右子节点不为null，将它加入队列
  194.             if (p.right != null) {
  195.                 queue.offer(p.right);
  196.             }
  197.         }
  198.         return list;
  199.     }
  200. }

上面程序为排序二叉树提供了一个广度优先的遍历算法，通过该方法可以更好地看出二叉树的内部机构。下面程序测试了上面排序二叉树的添加、删除节点。

  1. public class SortBinTreeTest {
  2.     public static void main(String[] args) {
  3.         SortBinTree<Integer> tree = new SortBinTree<>();
  4.         //添加节点
  5.         tree.add(5);
  6.         tree.add(20);
  7.         tree.add(10);
  8.         tree.add(3);
  9.         tree.add(8);
  10.         tree.add(15);
  11.         tree.add(30);
  12.         System.out.println(tree.breadthFirst());
  13.         //删除节点
  14.         tree.remove(20);
  15.         System.out.println(tree.breadthFirst());
  16.     }
  17. }

运行上面的程序，可以看到如下的结果：

  1. [[data=5], [data=3], [data=20], [data=10], [data=30], [data=8], [data=15]]
  2. [[data=5], [data=3], [data=15], [data=10], [data=30], [data=8]]

采用广度优先法则来遍历排序二叉树得到的不是有序序列，采用中序遍历来遍历排序二叉树时才可以得到有序序列。

红黑树

排序二叉树虽然可以快速检索，但在最坏的情况下，如果插入的节点集本身就是有序的，要么是由小到大排列，要么是由大到小排列，那么最后得到的排序二叉树将变成链表：所有节点只有左节点（如果插入节点集本身是由大到小排列），或者所有节点只有右节点（如果插入节点集合本身由小到大排列）。在这种情况下，排序二叉树就变成了普通链表，其检索效率就会很差。

为了改变排序二叉树存在的不足，Rudolf Bayer 于 1972 年发明了另一种改进后的排序二叉树————红黑树，他将这种排序二叉树称为“对称二叉 B 树”，而红黑树这个名字则由 Leo J. Guibas 和 Robert Sedgewick 于 1978 年首次提出。

红黑树是一个更高效的检索二叉树，因此常常用来实现关联数组。典型地，JDK 提供的集合类 TreeMap 本身就是一个红黑树的实现。

红黑树在原有的排序二叉树上增加了如下几个要求。

  • 性质 1：每个节点要么是红色，要么是黑色；
  • 性质 2：根节点永远是黑色的；
  • 性质 3：所有的叶子节点都是空节点（即 null），并且是黑色的；
  • 性质 4：每个红色节点的两个子节点都是黑色（从每个叶子到根的路径上不会有两个连续的红色节点）；
  • 性质 5：从任一节点到其子树中每个叶子节点的路径都包含相同数量的黑色节点。

上面的性质 3 中指定红黑树的每个叶子节点都是空节点，并且叶子节点都是黑色，但 Java 实现的红黑树将使用 null 来代表空节点，因此遍历红黑树时将看不到黑色的叶子节点，反而每个叶子节点都是红色的。

Java 中实现的红黑树可能是如下的结构：

  1.                         13(黑)
  2.                    /            \
  3.              /                        \
  4.            9(红)                       18(红)
  5.         /        \                  /        \
  6.        /          \              /               \
  7.     5(黑)        10(黑)        16(黑)             25(黑)
  8.     /   \         /   \         / \            /        \
  9.    /     \   null(黑) null(黑) /    \         /           \
  10. null(黑) 8(红)             null(黑) null(黑) 23(红)       30(红)
  11.         /    \                             /  \         /     \
  12.        /      \                           /    \       /       \
  13.     null(黑) null(黑)               null(黑) null(黑) null(黑) null(黑)

根据性质 5，红黑树从根节点到每个根节点到每个叶子节点的路径都包含相同数量的黑色节点，因此从根节点到叶子节点的路径中包含的黑色节点数被称为树的“黑色高度（black-height）”。

性质 4 则保证了从根节点到叶子节点的最长路径的长度不会超过任何其它路径的两倍。加入有一颗黑色高度为 3 的红黑树，从根节点到叶子节点的最短路径长度是 2，该路径上全是黑色节点（黑节点-黑节点-黑节点）。最长路径路径也只可能为 4，在每个黑色节点之间插入一个红色节点（黑节点-红节点-黑节点-红节点-黑节点），性质 4 保证绝不可能插入更多的红色节点。由此可见，红黑树中最长的路径就是一条红黑交替的路径。

由此可以得出结论：对于给定的黑色高度为 N 的红黑树，从根到叶子节点的最短路径长度为 N-1，最长路径长度为 2*(N-1)。

排序二叉树的深度直接影响了检索的性能，正如前面指出的，当插入节点本身就是由小到大排列时，排序二叉树将变成一个链表，这种排序二叉树的检索性能最低：N 个节点的二叉树深度就是 N-1。

红黑树通过上面这种限制来保证它大致是平衡的————因为红黑树的高度不会无限增高，这样能保证红黑树在最坏情况下都是高效的，不会出现普通排序二叉树的情况。

红黑树并不是真正的平衡二叉树，但在实际应用中，红黑树的统计性能要高于平衡二叉树，但极端性能略差。

由于红黑树只是一个特殊的排序二叉树，因此对红黑树的只读操作与普通二叉树上的只读操作完全相同，只是红黑树保持了大致平衡，因此检索性能更好。

但在红黑树进行插入操作和删除操作会导致树不再复合红黑树的特征。因此插入操作和删除操作都需要进行一定的维护，以保证插入节点、删除节点后的树依然是红黑树。

插入操作

插入操作按如下步骤进行。

  1. 排序二叉树的方法插入新节点，并将它设为红色。

    如果设为黑色，就会导致根节点到叶子节点的路径上多一个额外的黑节点，这样将会导致很难调整的。但是设为红色节点后，可能会导致出现两个连续红色节点，再通过颜色调换和树旋转来调整即可。

  2. 进行颜色调换
    这种颜色调用和树旋转就比较复杂了，下面将分情况进行介绍。在介绍中，把新插入的节点定义为 N 节点，把 N 节点的父节点定义为 P 节点，把 P 节点的兄弟节点定义为 U 节点，把 P 节点父节点定义为 G 节点。

    在插入操作中，红黑树的性质 1 和性质 3 永远不会发生改变，因此无需考虑红黑树的这两个特征。

    1. 情形 1：新节点 N 是树的根节点，没有父节点。
      在这种情形下，直接将它设置为黑色以满足性质 2。
    2. 情形 2：新节点的父节点 P 是黑色。
      在这种情况下，新插入的节点是红色的，因此依然满足性质 4。而且因为新节点 N 有两个黑色叶子节点，但是由于新节点 N 是红色，通过它的每个子节点的路径依然保持相同的黑色节点数，因此依然满足性质 5。
    3. 情形 3：如果父节点 P 和父节点的兄弟节点 U 都是红色。
      在这种情况下，程序应该将 P 节点、U 节点都设置为黑色，并将 P 节点的父节点设为红色（用来保持性质 5）。现在，新节点 N 有了一个黑色的父节点 P。由于从 P 节点、U 节点到根节点的任何路径都必须通过 G 节点，这些路径上的黑节点数目没有改变（原来有叶子和 G 节点两个黑色节点，现在有叶子和 P 两个黑色节点）。
      经过上面处理后，红色的 G 节点的父节点也有可能是红色的，这就违反了性质 4，因此还需要对 G 节点递归进行整个过程（把 G 当成新插入的节点进行处理）。
    4. 父节点 P 是红色，而其兄弟节点 U 是黑色或缺少；且新节点 N 是父节点 P 的右子节点，而父节点 P 又是其父节点 G 的左子节点。
      在这种情形下，对新节点和其父节点进行一次左旋转。接着，按情形 5 处理以前的父节点 P（也就是把 P 当成新插入的节点）。这将导致某些路径通过它们以前不通过的新节点 N 或父节点 P 其中之一，但是这两个节点都是红色的，因此不会影响性质 5。
    5. 情形 5：父节点 P 是红色，而其兄弟节点 U 是黑色或缺少；且新节点 N 是其父节点的左子节点，而父节点 P 又是其父节点 G 的左子节点。
      在这种情形下，需要对节点 G 进行依次右旋转。在旋转产生的树中，以前的父节点 P 现在是新节点 N 和节点 G 的父节点。由于以前的节点 G 是黑色（否则父节点 P 就不可能是红色），切换以前的父节点 P 和节点 G 的颜色，使之满足性质 4。性质 5 也仍然保持满足，因为通过这 3 个节点中任何一个的所有路径以前都通过节点 G，现在它们都通过以前的父节点 P。在各自的情形下，这都是 3 个节点中唯一的黑色节点。

删除操作

红黑树的删除操作比插入操作要更复杂一些，实际上也可按如下步骤进行。

  1. 以排序二叉树的方法删除指定节点
  2. 进行颜色调换和树旋转，使之满足红黑树特征。

关于删除节点后要进行的颜色调换和树旋转中各种情况的处理，可以参考插入操作的介绍，此处不再一一列举。

本文转载自：《疯狂Java 突破程序员基本功的16课》第十一章 树和二叉树

评论

Post comment Click Refresh verification code

Tip

The feature is not yet available

Close