一、数组存储、链式存储与数存储
1，数组存储
优点：通过下标方式访问元素，速度快。对于有序数组，还可以通过二分查找提高检索速度。
缺点：如果检索具体某个值，或者插入值(按一定顺序)会整体移动，效率低
2，链式存储
优点：在一定程度上对数组存储有优化(比如：插入一个数值节点，只需要将插入节点连接到链表中即可，删除效率也很好)。
缺点：在进行检索时，效率仍然较低(比如：检索某个值，需要从头节点开始遍历)
3，树存储
能提高数据存储，读取的效率，比如利用二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也可以保证数据的插入、删除和修改的速度。
二、二叉树
源码：二叉树
1，数的常用术语
- 节点
- 根节点
- 父节点
- 子节点
- 叶子节点 (没有子节点的节点)
- 节点的权(节点值)
- 路径(从 root 节点找到该节点的路线)
- 层
- 子树
- 树的高度(最大层数)
- 森林 :多颗子树构成森林
2，二叉树的概念
- 树有很多种， 每个节点最多只能有两个子节点的一种形式称为二叉树，二叉树的子节点分为左节点和右节点
- 如果该二叉树的所有叶子节点都在最后一层， 并且结点总数= 2^n -1， n 为层数， 则我们称为满二叉树
- 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层， 而且最后一层的叶子节点在左边连续， 倒数第二层的叶子节点在右边连续， 我们称为完全二叉树
3，二叉树的遍历
a)代码思路
- 前序遍历: 先输出父节点， 再遍历左子树和右子树
- 中序遍历: 先遍历左子树， 再输出父节点，再遍历右子树
- 后序遍历: 先遍历左子树， 再遍历右子树，最后输出父节点
b)代码实现
//编号 private int no; //名称 private String name; //左子节点 private Node left; //右子节点 private Node right; /** * 前序遍历 : 根 -> 左 -> 右 */ public void preOrder(){ if (this == null) { return; } if (this != null) { System.out.print(this.no + " "); } if (this.left != null) { this.left.preOrder(); } if (this.right != null) { this.right.preOrder(); } } /** * 中序遍历 : 左 -> 根 -> 右 */ public void midOrder(){ if (this == null) { return; } if (this.left != null) { this.left.midOrder(); } if (this != null) { System.out.print(this.no + " "); } if (this.right != null) { this.right.midOrder(); } } /** * 后序遍历 : 左 -> 右 -> 根 */ public void postOrder(){ if (this == null) { return; } if (this.left != null) { this.left.postOrder(); } if (this.right != null) { this.right.postOrder(); } if (this != null) { System.out.print(this.no + " "); } }
4，二叉树的查找
a)代码思路
- 将二叉树的前、中、后序遍历改为查找即可
- 编码思路：
- 如果查找到目标节点，直接返回，结束递归
- 如果找不到，继续递归执行前（中、后）序查找
b)代码实现
//编号 private int no; //名称 private String name; //左子节点 private Node left; //右子节点 private Node right; /** * 后序查找 */ public Node postSearch(int no) { Node node = null; if (this.left != null) { node = this.left.postSearch(no); } if (node != null) { return node; } if (this.right != null) { node = this.right.postSearch(no); } if (node != null) { return node; } System.out.println("后续查找"); if (this.no == no) { return this; } return node; } /** * 中序查找 */ public Node midSearch(int no) { Node node = null; //先向左找 if (this.left != null ) { node = this.left.midSearch(no); } //找到就返回 if (node != null) { return node; } System.out.println("中序查找~"); //找当前节点，找到返回 if (this.no == no) { return this; } //向右找 if (this.right != null) { node = this.right.midSearch(no); } return node; } /** * 前序查找 */ public Node preSearch(int no){ System.out.println("前序查找~"); if (this.no == no) { return this; } Node node = null; if (this.left != null) { node = this.left.preSearch(no); } if (node != null) { return node; } if (this.right != null) { node = this.right.preSearch(no); } return node; }
5，二叉树的删除
a)删除要求
- 如果删除的节点是叶子节点， 则删除该节点
- 如果删除的节点是非叶子节点， 则删除该子树
b)代码思路
- 先判断根节点 root 是不是待删除的节点，如果是，则删除根节点，否则开始执行递归
- 判断当前节点（this）的左节点是否为待删除的节点，如果是，删除 this.left ，然后返回，结束递归
- 判断当前节点（this）的左节点是否为待删除的节点，如果是，删除 this.right，然后返回，结束递归
- 否则继续执行左递归，左递归执行完后，执行右递归
c)代码实现
/** * 删除节点 */ public void del(int no) { if (this.left != null) { if (this.left.no == no) { this.left = null; return; } else { this.left.del(no); } } if (this.right != null ) { if (this.right.no == no) { this.right = null; return; } else { this.right.del(no); } } }
/** * 删除节点 */ public void del(int no) { if (root == null) { System.out.println("当前二叉树为空!"); return; } if (root.getNo() == no) { root = null; return; } root.del(no); }
三、顺序存储二叉树
源码：顺序存储二叉树
1，顺序存储二叉树与数组的转换
-
基本说明：从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组。
-
要求：
- 二叉树的结点，要求以数组的方式来存放 arr : [1, 2, 3, 4, 5, 6, 7]
- 要求在遍历数组 arr时，仍然可以用前序遍历，中序遍历和后序遍历的方式完成结点的遍历
2，顺序存储二叉树的特点
- 顺序二叉树通常只考虑完全二叉树
- 顺序存储二叉树中第 n 个元素的左子节点对应的数组下标为 2 * n + 1
- 顺序存储二叉树中第 n 个元素的右子节点对应的数组下标为 2 * n + 2
- 顺序存储二叉树中第 n 个元素的父节点对应的数组下标为 (n-1) / 2
- n 的含义： 表示二叉树中的第几个元素（按0开始编号，如上图所示）
3，代码实现
/** * 前序 */ public void preOrder(int index) { if (arr == null || arr.length == 0) { System.out.println("当前数组为空!"); return; } System.out.println(arr[index]); if ((2 * index + 1) < arr.length) { preOrder(2 * index + 1); } if ((2 * index + 2) < arr.length) { preOrder(2 * index + 2); } }
四、线索化二叉树
源码：线索化二叉树
1，原理
通过考察各种二叉链表，无论儿叉树的形态怎样，空链域的个数总是多过非空链域的个数。准确的说，n各结点的二叉链表共同拥有2n个链域，非空链域为n-1个，但当中的空链域却有n+1个。例如以下图所看到的。
可以通过充分利用二叉链表中的空指针域，存放节点在某种遍历方式下的前驱和后继节点的指针。我们把这种指向前驱和后继的指针成为线索，加上线索的二叉链表成为线索链表，对应的二叉树就成为“线索二叉树(Threaded Binary Tree)” 。
2，构建线索化二叉树(中序)
a)思路
在原始二叉树结点基础上，添加字段isLeftThread和isRightThread，从而判定指针域对应的是子节点还是前驱或后续线索
//节点存储结构 static class Node { String data; //数据域 Node left; //左指针域 Node right; //右指针域 boolean isLeftThread = false; //左指针域类型 false：指向子节点、true：前驱或后继线索 boolean isRightThread = false; //右指针域类型 false：指向子节点、true：前驱或后继线索 }
将最终的二叉树构建为如下图所示的线索二叉树
b)代码实现
/** * 中序线索化二叉树 * * @param node 节点 */ public void inThreadOrder(Node node) { if (node == null) { return; } //处理左子树 inThreadOrder(node.left); //左指针为空,将左指针指向前驱节点 if (node.left == null) { node.left = preNode; node.isLeftThread = true; } //前一个节点的后继节点指向当前节点 if (preNode != null && preNode.right == null) { preNode.right = node; preNode.isRightThread = true; } preNode = node; //处理右子树 inThreadOrder(node.right); }
3，遍历线索化二叉树
a)思路
- 找到线索二叉树的最左子节点
- 从左往右遍历各节点while(node!=null){node=node.right...}
- 如果右指针是线索指针直接打印，
- 如果右指针是节点则查找该右子树的最左结点
b)代码实现
/** * 中序遍历线索二叉树，按照后继方式遍历（思路：找到最左子节点开始） * * @param node */ public void inThreadList(Node node) { //1、找中序遍历方式开始的节点 while (node != null && !node.isLeftThread) { node = node.left; } while (node != null) { System.out.print(node.data + ", "); //如果右指针是线索 if (node.isRightThread) { node = node.right; } else { //如果右指针不是线索，找到右子树开始的节点 node = node.right; while (node != null && !node.isLeftThread) { node = node.left; } } } }