20172325 2017-2018-2 《程序设计与数据结构》实验二报告

课程：《程序设计与数据结构》
班级： 1723
姓名：邓煜坤
学号：20172325
实验教师：王志强
实验日期：2018年11月11日
必修/选修：必修

1.实验内容

实验一：实现二叉树
参考教材p212,完成链树LinkedBinaryTree的实现（getRight,contains,toString,preorder,postorder）
用JUnit或自己编写驱动类对自己实现的LinkedBinaryTree进行测试
实验二：中序先序序列构造二叉树
基于LinkedBinaryTree，实现基于（中序，先序）序列构造唯一一棵二㕚树的功能，比如给出中序HDIBEMJNAFCKGL和后序ABDHIEJMNCFGKL,构造出附图中的树
用JUnit或自己编写驱动类对自己实现的功能进行测试
实验三：决策树
自己设计并实现一颗决策树
实验四：表达式树
输入中缀表达式，使用树将中缀表达式转换为后缀表达式，并输出后缀表达式和计算结果（如果没有用树，则为0分）
实验五：二叉查找树
完成PP11.3
实验六：红黑树分析
参考http://www.cnblogs.com/rocedu/p/7483915.html对Java中的红黑树（TreeMap，HashMap）进行源码分析，并在实验报告中体现分析结果。
（C:\Program Files\Java\jdk-11.0.1\lib\src\java.base\java\util）

实验过程及结果

2. 实验过程及结果

实验一过程：
实验二过程：
实验三过程：
实验四过程：
实验五过程：
实验六过程：
红黑树的特性：
（1）每个结点或者是黑色，或者是红色。
（2）根结点是黑色。
（3）每个叶结点（NIL）是黑色。【注意：这里叶结点，是指为空(NIL或NULL)的叶结点！】
（4）如果一个结点是红色的，则它的子节点必须是黑色的。
（5）从一个结点到该结点的子孙结点的所有路径上包含相同数目的黑结点。

两个类的源码比较长，我只针对其中的几个方法进行了分析

containsValue类：

public boolean containsValue(Object value) {
        Node<K,V>[] tab; V v;
        if ((tab = table) != null && size > 0) {
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                    if ((v = e.value) == value ||
                        (value != null && value.equals(v)))
                        return true;
                }
            }
        }
        return false;
    }

firstEntry()和getFirstEntry()方法：

public Map.Entry<K,V> firstEntry() {
    return exportEntry(getFirstEntry());
}
final Entry<K,V> getFirstEntry() {
    Entry<K,V> p = root;
    if (p != null)
        while (p.left != null)
            p = p.left;
    return p;
}

remove方法

private void deleteEntry(Entry<K,V> p) {
modCount++;
    size--;

if (p.left != null && p.right != null) {
        Entry<K,V> s = successor (p);
        p.key = s.key;
        p.value = s.value;
        p = s;
    } 

// Start fixup at replacement node, if it exists.
    Entry<K,V> replacement = (p.left != null ? p.left : p.right);
    if (replacement != null) {
        // Link replacement to parent
        replacement.parent = p.parent;
        if (p.parent == null)
            root = replacement;
        else if (p == p.parent.left)
            p.parent.left  = replacement;
        else
            p.parent.right = replacement;
        p.left = p.right = p.parent = null;
        if (p.color == BLACK)
            fixAfterDeletion(replacement);
} else if (p.parent == null) { 
        root = null;
} else { 
        if (p.color == BLACK)
            fixAfterDeletion(p);
        if (p.parent != null) {
            if (p == p.parent.left)
                p.parent.left = null;
            else if (p == p.parent.right)
                p.parent.right = null;
            p.parent = null;
        }
    }
}

HashMap方法：

public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
   throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
   initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
   throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
this.loadFactor = loadFactor;
threshold = initialCapacity;
init();
}
public HashMap(int initialCapacity) {
   this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
   this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}