20172308 2018-2019-1 实验2 《线性结构》报告
课程：《程序设计与数据结构》
班级： 1723
姓名： 周亚杰
学号：20172308
实验教师：王志强
实验日期：2018年11月5日
必修/选修： 必修
1.实验内容
- (1)树之实现二叉树：完成链树LinkedBinaryTree的实现（getRight,contains,toString,preorder,postorder），并测试
- (2)树之中序先序序列构造二叉树：基于LinkedBinaryTree，实现基于（中序，先序）序列构造唯一一棵二㕚树的功能，并测试
- (3)树之决策树：自己设计并实现一颗决策树
- (4)树之表达式树：输入中缀表达式，使用树将中缀表达式转换为后缀表达式，并输出后缀表达式和计算结果（如果没有用树，则为0分）
- (5)树之二叉查找树：完成PP11.3
- (6)树之红黑树分析：参考相关资料对Java中的红黑树（TreeMap，HashMap）进行源码分析，并在实验报告中体现分析结果
2. 实验过程及结果
- (1)树之实现二叉树：
1.完成链树LinkedBinaryTree的方法：getRight，contains，toString，preorder，postorder
2.对LinkedBinaryTree类进行测试
3.实验结果截图：
- (2)树之中序先序序列构造二叉树：
1.基于LinkedBinaryTree，实现基于（中序，先序）序列构造唯一一棵二㕚树的功能
2.测试LinkedBinaryTree类
3.实验结果截图：
- (3)树之决策树：
1.根据课本背部疼痛诊断设计一颗新的决策树
2.测试新的决策树
4.实验结果截图：
- (4)树之表达式树：
1.利用树设计并实现中缀转后缀表达式类
2.利用树设计并实现后缀表达式计算结果类
3.并输出后缀表达式和计算结果
4.测试中缀转后缀及计算结果类
5.实验结果截图：
- (5)树之二叉查找树：完成PP11.3
1.链表实现的二叉树，设计实现removeMax，findMin，findMax操作
2.测试类
3.实验结果截图：
- (6)树之红黑树分析：
1.参考http://www.cnblogs.com/rocedu/p/7483915.html对Java中的红黑树（TreeMap，HashMap）进行源码分析
2.在实验报告中体现分析结果
3. 实验过程中遇到的问题和解决过程
问题1：实验2.2：利用中序和先序构造出一棵树并输出，其实这个原理明白，但实现代码的时候却不知道从哪里下手
- 问题1解决过程：
构造出树的原理就是：
由先序遍历的特点知道最先访问的是根结点（结点），然后是左右子树
再由中序遍历的结果找到根结点，并得到左右子树
再返回先序遍历，找到根结点左或右子树的结点，再返回中序遍历结果中找到此结点左右子树
如此递归下去......举个栗子：
先序遍历: GDAFEMHZ
中序遍历: ADEFGHMZ
画出树：
第一步，根据先序遍历的特点，我们知道根结点为G
第二步，观察中序遍历ADEFGHMZ。其中root节点G左侧的ADEF必然是root的左子树，G右侧的HMZ必然是root的右子树。
第三步，观察左子树ADEF，左子树的中的根节点必然是大树的root的leftchild。在先序遍历中，大树的root的leftchild位于root之后，所以左子树的根节点为D。
第四步，同样的道理，root的右子树节点HMZ中的根节点也可以通过前序遍历求得。在先序遍历中，一定是先把root和root的所有左子树节点遍历完之后才会遍历右子树，并且遍历的左子树的第一个节点就是左子树的根节点。同理，遍历的右子树的第一个节点就是右子树的根节点。
第五步，观察发现，上面的过程是递归的。先找到当前树的根节点，然后划分为左子树，右子树，然后进入左子树重复上面的过程，然后进入右子树重复上面的过程。最后就可以还原一棵树了。
该步递归的过程可以简洁表达如下：
1 确定根,确定左子树，确定右子树
2 在左子树中递归
3 在右子树中递归
4 打印当前根
然后可以画出这个二叉树的形状：
- 然后是实现代码：
public void buildTree(T[] inorder, T[] postorder) {//调用makeTree方法，即利用递归方法得到树
BinaryTreeNode temp = makeTree(inorder, 0, inorder.length, postorder, 0, postorder.length);
root = temp;这个是调用了makeTree方法，以先序和中序作为形参从而构造出树的方法
下面是具体的makeTree方法实现：
public BinaryTreeNode<T> makeTree(T[] inorder, int startInorder, int lenInorder, T[] preorder, int startPreorder, int lenPreorder) {
if (lenInorder < 1) {//判断中序的字符串长度（即元素个数）小于1，则返回null，即树为空
return null;
}
BinaryTreeNode root;//创建根结点
T rootelement = preorder[startPreorder];//preorder中的第一个元素就是当前处理的数据段的根节点
root = new BinaryTreeNode(rootelement);//把给定的根结点元素放进root
int temp;
boolean isFound = false;
for (temp = 0; temp < lenInorder; temp++) {
if (inorder[startInorder + temp] == rootelement) {
isFound = true;//此时找到结点，即将先序中的第一个元素（根元素）在中序中寻找到相同元素，得到根结点的左右子树
break;
}
}
if (!isFound)//如果不存在相等的情况就跳出该函数
return root;//即没有左右子树
root.setLeft(makeTree(inorder, startInorder, temp, preorder, startPreorder + 1, temp));//递归找到并设置各结点左孩子
root.setRight(makeTree(inorder, startInorder + temp + 1, lenInorder - temp - 1, preorder, startPreorder + temp + 1, lenPreorder - temp - 1));//递归找到并设置各结点右孩子
//每次递归，先序序列中都要往后跳过temp个元素（因为他们都是从中序序列中得知的一个结点的左或右孩子），再加1，即为下一个结点的元素
return root;
}上面的代码实现是参考并理解了余坤澎同学的代码之后进行了细微修改得到的，并作出了代码注释
【参考资料】
余坤澎同学的码云链接
Java实现二叉树先序，中序，后序遍历
二叉树前序、中序、后序遍历相互求法 （原理，程序）
问题2：实验2.3：自己设计一颗决策树
问题2解决过程：
参考课本上的背部疼痛诊断类，在节点处放置问题，根据用户输入的Y或N，对应不同的左右孩子，并返回当前节点的元素（即下一个问题内容）
即达到设计要求
设计想法有两种：
一是改变书上决策树的子树情况，设计其它的问题填充进去
二是直接改变原子树中的节点内容，使问题问题衔接的更紧凑（虽然这一种有点偷懒，但也是要在理解原决策树的结构基础上才能正确更改，否则会出现答非所问的情况）问题3：实验2.4：输入中缀表达式，使用树将中缀表达式转换为后缀表达式，并输出后缀表达式和计算结果
问题3解决过程：
这个实验应该是六个实验里面最不好做的一个，其中最关键的问题是如何将中缀转换成后缀表达式，即如何把中缀里面的操作数和操作符存储在树中，然后输出的树即为后缀表达式
后面的后缀表达式通过课本上的后缀表达式计算出结果即可
首先，第一个问题：如何构造出后缀表达式树
表达式树的特点：树的树叶是操作数（常数或变量），而其他节点为操作符
每次找到“最后计算”的运算符，作为当前根节点，运算符左侧表达式作为左节点，右侧表达式作为右节点，然后递归处理
- 举个栗子：9+（3-1）*3+10/2对应的二叉树的构造过程如下图所示：
此二叉树做后序遍历就得到了后缀表达式
然后，这里就存在一个优先级的问题，也就是存储操作符时，先存储哪个才能保证输出表达式时是正确的
我们知道乘除的运算级要高于加减，所以要先按顺序存储乘除的运算符及其两边的操作数，然后将其作为一个节点放在原来的列表位置，最后再存储加减及其两边的操作数
这一段的代码实现如下：
while (operList.size() > 0) { //第三步，重复第二步，直到操作符取完为止
//第二，取出前两个数字和一个操作符，组成一个新的数字节点
for (int a = 0; a < operList.size(); a++){
if(operList.get(a).equals("*") || operList.get(a).equals("/")){
Node left = numList.remove(a);
Node right = numList.remove(a);
String oper = operList.remove(a);
Node node = new Node(oper, left, right);
numList.add(a, node);
a--;
}
else
time++;
}
Node left = numList.remove(0);
Node right = numList.remove(0);
String oper = operList.remove(0);
Node node = new Node(oper, left, right);
numList.add(0, node); //将新生的节点作为第一个节点，同时以前index=0的节点变为index=1
}通过在一个循环里面判断操作符有没有乘除一级的运算，然后执行上述的相应操作
在for循环外面再按顺序对加减一级的操作符进行相应操作，即可达到转后缀的要求
最后一个，代码的问题：在写代码的时候，会报出下图中的错误
通过debug发现问题所在，是这个for循环的问题，这个循环不能正常结束，会超出范围
那么问题就是，为什么会不能正常结束循环？
这里的变量a是当前乘除一级的操作符在列表中的索引值（这里的操作数和操作符是存储在列表里的）
所以就导致了问题出现：ArrayList没有空位置，删除后的元素会被后面的元素自动补全
所以当一个乘除一级运算很多的中缀表达式，在找到乘除运算符的索引时，对应操作数中的索引值可能已经超出了循环的终止条件count的值（count是操作符的个数）
count是个定值，无法保证对所有的表达式都能正确转换成后缀表达式
经过很多次尝试和思考，才找到了最终的终止条件，那就是上面给出的代码 a < operList.size() 操作符的元素个数会变化，这里用size()方法就解决了
【参考资料】
前缀，中缀，后缀表达式学习笔记(1)
前缀、中缀、后缀表达式和二叉树
二叉树应用——后缀表达式构建表达式树
用二叉树表示表达式
中缀表达式转后缀表达式---栈--二叉树---四则运算
树之红黑树分析结果报告
1.首先要了解一下什么是treeMap和HashMap
Map：在数组中我们是通过数组下标来对其内容索引的，而在Map中我们通过对象来对对象进行索引，用来索引的对象叫做key，其对应的对象叫做value（就是我们平时说的键值对）
- HashMap
HashMap 是基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
官方文档
官方文档如下：
此实现假定哈希函数将元素适当地分布在各桶之间，可为基本操作（get 和 put）提供稳定的性能。迭代 collection 视图所需的时间与 HashMap 实例的“容量”（桶的数量）及其大小（键-值映射关系数）成比例。所以，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。
HashMap 的实例有两个参数影响其性能：初始容量 和加载因子。容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。
通常，默认加载因子 (.75) 在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数 HashMap 类的操作中，包括 get 和 put 操作，都反映了这一点）。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。
如果很多映射关系要存储在 HashMap 实例中，则相对于按需执行自动的 rehash 操作以增大表的容量来说，使用足够大的初始容量创建它将使得映射关系能更有效地存储。
注意，此实现不是同步的。如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须 保持外部同步。（结构上的修改是指添加或删除一个或多个映射关系的任何操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射进行意外的非同步访问，如下所示：
Map m = Collections.synchronizedMap(new HashMap(…));
由所有此类的“collection 视图方法”所返回的迭代器都是快速失败 的：在迭代器创建之后，如果从结构上对映射进行修改，除非通过迭代器本身的 remove 方法，其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不冒在将来不确定的时间发生任意不确定行为的风险。
HashMap中有三个关于红黑树的关键参数
//一个桶的树化阈值
//当桶中元素个数超过这个值时，需要使用红黑树节点替换链表节点
//这个值必须为 8，要不然频繁转换效率也不高
static final int TREEIFY_THRESHOLD = 8;
//一个树的链表还原阈值
//当扩容时，桶中元素个数小于这个值，就会把树形的桶元素 还原（切分）为链表结构
//这个值应该比上面那个小，至少为 6，避免频繁转换
static final int UNTREEIFY_THRESHOLD = 6;
//哈希表的最小树形化容量
//当哈希表中的容量大于这个值时，表中的桶才能进行树形化
//否则桶内元素太多时会扩容，而不是树形化
//为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD
static final int MIN_TREEIFY_CAPACITY = 64;treeifyBin
HashMap中树形化最重要的一个方法treeifyBin() 即树形化。在一个桶中的元素个数超过 TREEIFY_THRESHOLD(默认是8)，就使用红黑树来替换链表。
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//如果hash表为空或者hash表的容量小于MIN_TREEIFY_CAPACITY（64），那么就去新建或者扩容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
//新建一个树形节点，内容和当前链表节点一致
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p; //头节点
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
//之前得到的只是一个链表状的二叉树，下一步格式化红黑树
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
return new TreeNode<>(p.hash, p.key, p.value, next);
}【参考资料】
Java Collections API源码分析
4.感悟
本次实验对树的学习之后运用的检测性很强，只有真正对树的结构和原理熟练掌握才能做好实验
同时也让我知道了我对树的运用还很欠缺，仍然需要继续努力、学习