20172313 2018-2019-1 《程序设计与数据结构》实验二报告

时间 2019-11-08

标签程序设计与数据结构实验报告栏目软件设计繁體版

原文原文链接

20172313 2018-2019-1 《程序设计与数据结构》实验一报告

课程：《程序设计与数据结构》
班级： 1723
姓名：余坤澎
学号：20172313
实验教师：王志强
实验日期：2018年9月26日
必修/选修：必修html

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）进行源码分析，并在实验报告中体现分析结果。

2. 实验过程及结果

实验一

getRight方法只须要新定义一个LinkedBinaryTree类，令它的根结点等于原树的右子树的结点便可。注意：首先要判断原树的根结点是否为空，若空，则抛出异常。

public LinkedBinaryTree<T> getRight()
    {
        if(root == null)
            throw new EmptyCollectionException("Get right operation failed. The tree is empty.");

        LinkedBinaryTree<T> result = new LinkedBinaryTree<>();
        result.root = root.getRight();
        return result;
    }

contains方法调用findNode方法便可。当findNode返回值不为空时，该方法返回true，即存在，不然不存在。

public boolean contains(T targetElement)
    {

        if(findNode(targetElement,root) != null)
            return true;
        else
            return false;
    }

在这里toString我使用的是原先学习的按照树的形状打印树的方法。

public String toString() {
        UnorderedListADT<BinaryTreeNode> nodes =
                new ArrayUnorderedList<BinaryTreeNode>();
        UnorderedListADT<Integer> levelList =
                new ArrayUnorderedList<Integer>();
        BinaryTreeNode current;
        String result = "";
        int printDepth = this.getHeight();
        int possibleNodes = (int)Math.pow(2, printDepth + 1);
        int countNodes = 0;
        nodes.addToRear(root);
        Integer currentLevel = 0;
        Integer previousLevel = -1;
        levelList.addToRear(currentLevel);

        while (countNodes < possibleNodes)
        {
            countNodes = countNodes + 1;
            current = nodes.removeFirst();
            currentLevel = levelList.removeFirst();
            if (currentLevel > previousLevel)
            {
                result = result + "\n\n";
                previousLevel = currentLevel;
                for (int j = 0; j < ((Math.pow(2, (printDepth - currentLevel))) - 1); j++)
                    result = result + " ";
            }
            else
            {
                for (int i = 0; i < ((Math.pow(2, (printDepth - currentLevel + 1)) - 1)) ; i++)
                {
                    result = result + " ";
                }
            }
            if (current != null)
            {
                result = result + (current.getElement()).toString();
                nodes.addToRear(current.getLeft());
                levelList.addToRear(currentLevel + 1);
                nodes.addToRear(current.getRight());
                levelList.addToRear(currentLevel + 1);
            }
            else {
                nodes.addToRear(null);
                levelList.addToRear(currentLevel + 1);
                nodes.addToRear(null);
                levelList.addToRear(currentLevel + 1);
                result = result + " ";
            }
        }
        return result;
    }

preorder,postorder方法参考书上inorder方法便可。（在这里只列举preorder方法的代码）

public Iterator<T> iteratorPreOrder()
    {
        ArrayUnorderedList<T> tempList = new ArrayUnorderedList<T>();
        preOrder(root, tempList);

        return new TreeIterator(tempList.iterator());
    }

protected void preOrder(BinaryTreeNode<T> node,
                            ArrayUnorderedList<T> tempList)
    {
        if (node != null)
        {
            tempList.addToRear(node.getElement());
            preOrder(node.getLeft(), tempList);
            preOrder(node.getRight(), tempList);
        }
    }

全部方法实现以后，编写驱动类对LinkedBinaryTree进行测试。

实验二

实验一比较容易，全部的代码基本上在之前都实现过，稍加参考就能完成。实验二就比较难了，要使用中序序列和前序序列构造二叉树。设计思路以下：
- ①咱们要肯定根节点的位置，先序遍历的第一个结点就是该二叉树的根。
- ② 肯定根的子树，有中序遍历可知，咱们在中序遍历中找到根结点的位置，左边是它的左孩子，右边是它的右孩子，若是根结点左边或右边为空，那么在该方向上子树为空，若是根结点左边和右边都为空，那么该结点是叶子结点。
- ③对二叉树的左、右子树分别进行步骤①②，直到求出二叉树的结构为止。
该实验的主要难度在于如何使用递归不断对左右子树重复进行①②步骤,可根据传入的序列的数组的索引值进行分割，在中序序列中但凡比根元素索引值小的即为根元素的左结点，大的即为根元素的右结点。按照中序序列分红的两部分元素又能够把前序序列分红两部分，接下来用递归，把新获得的序列数组做为参数，直到造成二叉树的结构。

public void buildTree(T[] inorder, T[] postorder) {
        BinaryTreeNode temp=makeTree(inorder, 0, inorder.length, postorder, 0, postorder.length);
        root = temp;

    }


    public  BinaryTreeNode<T> makeTree(T[] inorder,int startIn,int lenIn,T[] postorder,int startPos,int lenPos){
        if(lenIn<1){
            return null;
        }
        BinaryTreeNode root;
        T rootelement=postorder[startPos];//postorder中的第一个元素就是当前处理的数据段的根节点
        root=new BinaryTreeNode(rootelement);
        int temp;
        boolean isFound=false;
        for(temp=0;temp<lenIn;temp++){
            if(inorder[startIn+temp]==rootelement){
                isFound=true;//此时找到结点
                break;
            }
        }
        if(!isFound)//若是不存在相等的状况就跳出该函数
            return root;
        root.setLeft(makeTree(inorder, startIn, temp, postorder, startPos+1, temp));
        root.setRight(makeTree(inorder, startIn+temp+1, lenIn-temp-1, postorder, startPos+temp+1, lenPos-temp-1));
        return root;
    }

实验三

实验三能够说是最简单的了，有了书上的示例进行参考，对文件进行修改便可，在这里再也不过多赘述。

实验四

这个实验是本次实验中最有难度的一个，虽然原先学习过中缀表达式转后缀表达式求值的问题，但使用树来进行操做仍是第一次。使用后缀表达式进行求值课堂上学习过，书上也有示例代码。这里只列举使用树把中缀表达式变为后缀表达式。设计思路以下：

定义两个列表分别用来操做符和“子树“，注意：这里的操做符列表里只存“+”“-”，至于为何将在下面进行分析。首先把中缀表达式用StringTokenizer方法进行分开，从前到后依次遍历，若是是括号，就把括号里面的内容做为一个新的表达式传入该方法，把返回的结点做为一棵新树的根存进numList。若是遍历到数字，做为一棵新树的element存入numList，若是遍历到“+”“-”，直接存入operLIst中。若是遇到“乘或除”,若是“乘或除”的日后遍历到的是括号，则先把括号里的内容做为一个新的表达式传入该方法，把返回的结点做为“乘号”的右子树的根结点，而后从numList取出最后一个元素做为“乘号”的左子树的根结点。若是“乘或除”的日后遍历到的是数字，则直接做为“乘号”的右子树的根结点，而后从numList取出最后一个元素做为“乘号”的左子树的根结点。
这里的核心思想就是一旦遇到括号就把括号里的内容做为参数传入该方法，因为括号运算的优先级，能够把获得的该结点传入numList，在造成二叉树的过程当中直接取出。一旦遇到“乘或除”就从numList的末尾取出一位元素做为它的左子树，“乘或除”的下一位元素做为它的右子树，而后把这个子树存入numList，这样在保证了运算优先级的同时，也使得造成二叉树的时候顺序不会被打乱，这就是为何操做符列表里只存“+”“-”操做符列表里只存“+”“-”，由于“乘或除”做为子树的根结点都存入到了numList。一直到遍历完成，这时候咱们知道，最早进入numList的运算优先级最高，因此从索引为0处开始取元素，把它们组装成一棵二叉树便可。

public BinaryTreeNode buildTree(String str) {
      ArrayList<String> operList = new ArrayList<>();
      ArrayList<LinkedBinaryTree> numList = new ArrayList<>();
      StringTokenizer st = new StringTokenizer(str);
      String token;
      while (st.hasMoreTokens()) {
          token = st.nextToken();
          if (token.equals("(")) {
              String str1 = "";
              while (true) {
                  token = st.nextToken();
                  if (!token.equals(")"))
                      str1 += token + " ";
                  else
                      break;
              }
              LinkedBinaryTree temp = new LinkedBinaryTree();
              temp.root = buildTree(str1);
              numList.add(temp);
              token = st.nextToken();
          }
          if (token.equals("+") || token.equals("-")) {
              operList.add(token);
          } else if (token.equals("*") || token.equals("/")) {
              LinkedBinaryTree left = numList.remove(numList.size() - 1);
              String A = token;
              token = st.nextToken();
              if (!token.equals("(")) {
                  LinkedBinaryTree right = new LinkedBinaryTree(token);
                  LinkedBinaryTree node = new LinkedBinaryTree(A, left, right);
                  numList.add(node);
              } else {
                  String str1 = "";
                  while (true) {
                      token = st.nextToken();
                      if (!token.equals(")"))
                          str1 += token + " ";
                      else
                          break;
                  }
                  LinkedBinaryTree temp2 = new LinkedBinaryTree();
                  temp2.root = buildTree(str1);
                  LinkedBinaryTree node1 = new LinkedBinaryTree(A, left, temp2);
                  numList.add(node1);
              }
          } else
              numList.add(new LinkedBinaryTree(token));
      }
      while (operList.size() > 0) {
          LinkedBinaryTree left = numList.remove(0);
          LinkedBinaryTree right = numList.remove(0);
          String oper = operList.remove(0);

          LinkedBinaryTree node2 = new LinkedBinaryTree(oper, left, right);
          numList.add(0, node2);
      }
      node = (numList.get(0)).root;

      return node;
  }

实验五

实验五相较于实验四来讲又简单了一些，因为二叉查找树的最小元素始终位于整棵树左下角最后一个左子树的第一个位置，最大元素始终位于整棵树右下角最后一个右子树的最后一个位置。从根结点进行遍历便可。注意：这里要判断树为空和结点的左右子树是否存在。

public T removeMax() throws EmptyCollectionException
    {
        T result = null;

        if (isEmpty())
            throw new EmptyCollectionException("LinkedBinarySearchTree");
        else
        {
            if (root.right == null)
            {
                result = root.element;
                root = root.left;
            }
            else
            {
                BinaryTreeNode<T> parent = root;
                BinaryTreeNode<T> current = root.right;
                while (current.right != null)
                {
                    parent = current;
                    current = current.right;
                }
                result =  current.element;
                parent.right = current.left;
            }
            modCount--;
        }

        return result;
    }


    public T findMin() throws EmptyCollectionException
    {
        if(isEmpty())
            System.out.println("BinarySearchTree is empty!");

        return findMin(root).getElement();
    }

    private BinaryTreeNode<T> findMin(BinaryTreeNode<T> p) {
        if (p==null)//结束条件
            return null;
        else if (p.left==null)//若是没有左结点,那么t就是最小的
            return p;
        return findMin(p.left);
    }

    public T findMax() throws EmptyCollectionException
    {
        if(isEmpty())
            System.out.println("BinarySearchTree is empty!");

        return findMax(root).getElement();
    }

    private BinaryTreeNode<T> findMax(BinaryTreeNode<T> p){
        if (p==null)//结束条件
            return null;
        else if (p.right==null)
            return p;
        return findMax(p.right);
    }

实验六

红黑树（Red Black Tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。首先，咱们先来看看它的性质
- 树中的每个结点都储存着一种颜色（红色或黑色，一般使用一个布尔值来实现，值false等价于红色）。
- 根结点为黑色。
- 每一个叶子结点（null）是黑色。（**注意：这里的叶子结点，是指为空(null)的叶子结点！）
- 从树根到树叶的每条路径都包含有一样数目的黑色结点。
- 若是一个结点的颜色为红色，那么它的子结点一定是黑色。
红黑树示意图：
- TreeMap概述：TreeMap是基于红黑树实现的。因为TreeMap实现了java.util.sortMap接口，集合中的映射关系是具备必定顺序的，该映射根据其键的天然顺序进行排序或者根据建立映射时提供的Comparator进行排序，具体取决于使用的构造方法。另外TreeMap中不容许键对象是null。
- TreeMap类：
```
public class TreeMap<K,V>
  extends AbstractMap<K,V>
  implements NavigableMap<K,V>, Cloneable, java.io.Serializable
```
TreeMap 是一个有序的key-value集合，它是经过红黑树实现的。
TreeMap 继承于AbstractMap，因此它是一个Map，即一个key-value集合。
TreeMap 实现了NavigableMap接口，意味着它支持一系列的导航方法。好比返回有序的key集合。
TreeMap 实现了Cloneable接口，意味着它能被克隆。
TreeMap 实现了java.io.Serializable接口，意味着它支持序列化。java

TreeMap经常使用方法：

TreeMap的构造函数

//使用默认构造函数构造TreeMap时，使用java的默认的比较器比较Key的大小，从而对TreeMap进行排序。
public TreeMap() {
  comparator = null;
}
//带比较器的构造函数
public TreeMap(Comparator<? super K> comparator) {
  this.comparator = comparator;
}
//带Map的构造函数，Map会成为TreeMap的子集
ublic TreeMap(Map<? extends K, ? extends V> m) {
  comparator = null;
  putAll(m);
}
//该构造函数会调用putAll()将m中的全部元素添加到TreeMap中。从中，咱们能够看出putAll()就是将m中的key-value逐个的添加到TreeMap中。putAll()源码以下：
public void putAll(Map<? extends K, ? extends V> m) {
  for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
      put(e.getKey(), e.getValue());
}
//带SortedMap的构造函数，SortedMap会成为TreeMap的子集,该构造函数不一样于上一个构造函数，在上一个构造函数中传入的参数是Map，Map不是有序的，因此要逐个添加。而该构造函数的参数是SortedMap是一个有序的Map，咱们经过buildFromSorted()来建立对应的Map。
public TreeMap(SortedMap<K, ? extends V> m) {
  comparator = m.comparator();
  try {
      buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
  } catch (java.io.IOException cannotHappen) {
  } catch (ClassNotFoundException cannotHappen) {
  }
}

V put(K key,V value):将键值对(key,value)添加到TreeMap中

public V put(K key, V value) {//插入或设置元素，返回原始value值（若是插入返回null）
      Entry<K,V> t = root;
      if (t == null) {//根元素为空时直接创建根元素
          root = new Entry<K,V>(key, value, null);
          size = 1;
          modCount++;
          return null;
      }
      int cmp;
      Entry<K,V> parent;
      // split comparator and comparable paths
      Comparator<? super K> cpr = comparator;
      if (cpr != null) {//存在比较器
          do {//循环查找父元素
              parent = t;//设置父元素
              cmp = cpr.compare(key, t.key);
              if (cmp < 0)
                  t = t.left;//继续查找左边元素
              else if (cmp > 0)
                  t = t.right;//继续查找右边元素
              else
                  return t.setValue(value);//相等直接进行value设置
          } while (t != null);
      }
      else {//不存在比较器，按compareTo方法查找
          if (key == null)
              throw new NullPointerException();
          Comparable<? super K> k = (Comparable<? super K>) key;
          do {
              parent = t;
              cmp = k.compareTo(t.key);
              if (cmp < 0)
                  t = t.left;
              else if (cmp > 0)
                  t = t.right;
              else
                  return t.setValue(value);
          } while (t != null);
      }
      Entry<K,V> e = new Entry<K,V>(key, value, parent);
      if (cmp < 0)
          parent.left = e;
      else
          parent.right = e;
      fixAfterInsertion(e);
      size++;
      modCount++;
      return null;
  }
  private void fixAfterInsertion(Entry<K,V> x) {//插入数据后的树形变化处理
      x.color = RED;//插入元素默认颜色为红色
      while (x != null && x != root && x.parent.color == RED) {//当父节点的颜色为红色时，须要进行变化
          if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {//若是父元素为其父的左节点
              Entry<K,V> y = rightOf(parentOf(parentOf(x)));//取右节点（叔节点）
              if (colorOf(y) == RED) {//颜色为红
                  setColor(parentOf(x), BLACK);//父节点设置为黑色
                  setColor(y, BLACK);//右节点设置为黑色
                  setColor(parentOf(parentOf(x)), RED);//父元素的父元素设置为红色
                  x = parentOf(parentOf(x));//x设置为父元素的父元素，继续进行断定
              } else {//叔节点不可能为黑色，故下面为无叔节点状况，必然须要进行旋转
                  if (x == rightOf(parentOf(x))) {//若是当前元素为其父的右节点
                      x = parentOf(x);//x设置为父元素，继续进行断定
                      rotateLeft(x);//进行左旋操做
                  }
                  setColor(parentOf(x), BLACK);//父节点设置为黑色
                  setColor(parentOf(parentOf(x)), RED);//父元素的父元素设置为红色
                  rotateRight(parentOf(parentOf(x)));//进行右旋操做
              }
          } else {//父元素为其父的右节点
              Entry<K,V> y = leftOf(parentOf(parentOf(x)));//取左节点（叔节点）
              if (colorOf(y) == RED) {//颜色为红
                  setColor(parentOf(x), BLACK);
                  setColor(y, BLACK);
                  setColor(parentOf(parentOf(x)), RED);
                  x = parentOf(parentOf(x));//x设置为父元素的父元素，继续进行断定
              } else {//叔节点不可能为黑色，故下面为无叔节点状况，必然须要进行旋转
                  if (x == leftOf(parentOf(x))) {//若是当前元素为其父的左节点
                      x = parentOf(x);//x设置为父元素，继续进行断定
                      rotateRight(x);//进行右旋操做
                  }
                  setColor(parentOf(x), BLACK);
                  setColor(parentOf(parentOf(x)), RED);
                  rotateLeft(parentOf(parentOf(x)));//进行左旋操做
              }
          }
      }
      root.color = BLACK;//根节点设置为黑色
  }

按照key值进行查找

final Entry<K,V> getEntry(Object key) {//根据key值查找元素方法；final方法不容许被子类重写
        // Offload comparator-based version for sake of performance
        if (comparator != null)//存在比较器，按比较器进行比较查找
            return getEntryUsingComparator(key);
        if (key == null)//key值为null抛空指针异常
            throw new NullPointerException();
        Comparable<? super K> k = (Comparable<? super K>) key;
        Entry<K,V> p = root;
        while (p != null) {//从root开始循环查找，一直到叶子节点
            int cmp = k.compareTo(p.key);//采用key的compareTo方法进行比较
            if (cmp < 0)//小于继续查找左边
                p = p.left;
            else if (cmp > 0)//大于继续查找右边
                p = p.right;
            else
                return p;//等于返回当前元素
        }
        return null;
    }

删除操做

blic V remove(Object key) {
        Entry<K,V> p = getEntry(key);//先找到须要删除的元素
        if (p == null)
            return null;
 
        V oldValue = p.value;
        deleteEntry(p);
        return oldValue;
    }
 
    private void deleteEntry(Entry<K,V> p) {
        modCount++;
        size--;
        // If strictly internal, copy successor's element to p and then make p
        // point to successor.
        if (p.left != null && p.right != null) {//若是有两个孩子
            Entry<K,V> s = successor (p);//查找下一元素
            p.key = s.key;
            p.value = s.value;//p的数据替换为该元素数据
            p = s;//将p指向该元素，做为原始元素（被删除元素）
        } // p has 2 children
 
        // 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;
 
            // Null out links so they are OK to use by fixAfterDeletion.
            p.left = p.right = p.parent = null;//原始元素链接清空
 
            // Fix replacement
            if (p.color == BLACK)//删除元素为黑色，须要进行删除后树形变化操做
                fixAfterDeletion(replacement);
        } else if (p.parent == null) { // return if we are the only node.
            root = null;//根节点的删除
        } else { //  No children. Use self as phantom replacement and unlink.
            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;
            }
        }
    } 
    private void fixAfterDeletion(Entry<K,V> x) {//删除数据后的树形变化处理
        while (x != root && colorOf(x) == BLACK) {//当前节点为黑（替换元素不可能为黑，只有删除自身的状况）
            if (x == leftOf(parentOf(x))) {//左节点
                Entry<K,V> sib = rightOf(parentOf(x));//取父亲的右节点（兄节点）
 
                if (colorOf(sib) == RED) {//颜色为红
                    setColor(sib, BLACK);
                    setColor(parentOf(x), RED);//着色
                    rotateLeft(parentOf(x));//按父左旋
                    sib = rightOf(parentOf(x));//指向左旋后的父亲的右节点（为黑）
                }
                //颜色为黑
                if (colorOf(leftOf(sib))  == BLACK &&
                    colorOf(rightOf(sib)) == BLACK) {//两个孩子均为黑（实际只可能为无孩子状况）
                    setColor(sib, RED);//着色
                    x = parentOf(x);//x指向父节点继续判断
                } else {
                    if (colorOf(rightOf(sib)) == BLACK) {//右节点为黑（实际只可能为无右孩子）
                        setColor(leftOf(sib), BLACK);
                        setColor(sib, RED);//着色
                        rotateRight(sib);//按兄右旋
                        sib = rightOf(parentOf(x));//指向右旋后的父亲的右节点
                    }
                    setColor(sib, colorOf(parentOf(x)));
                    setColor(parentOf(x), BLACK);
                    setColor(rightOf(sib), BLACK);//着色
                    rotateLeft(parentOf(x));//按父左旋
                    x = root;//结束循环
                }
            } else { // symmetric//右节点
                Entry<K,V> sib = leftOf(parentOf(x));//取父亲的左节点（兄节点）
 
                if (colorOf(sib) == RED) {//颜色为红
                    setColor(sib, BLACK);
                    setColor(parentOf(x), RED);//着色
                    rotateRight(parentOf(x));//按父右旋
                    sib = leftOf(parentOf(x));//指向右旋后的父亲的左节点（为黑或空）
                }
                //颜色为黑
                if (colorOf(rightOf(sib)) == BLACK &&
                    colorOf(leftOf(sib)) == BLACK) {//两个孩子均为黑
                    setColor(sib, RED);//着色
                    x = parentOf(x);//x指向父节点继续判断
                } else {
                    if (colorOf(leftOf(sib)) == BLACK) {//左节点为黑
                        setColor(rightOf(sib), BLACK);
                        setColor(sib, RED);//着色
                        rotateLeft(sib);//按兄左旋
                        sib = leftOf(parentOf(x));//指向左旋后的父亲的左节点
                    }
                    setColor(sib, colorOf(parentOf(x)));
                    setColor(parentOf(x), BLACK);
                    setColor(leftOf(sib), BLACK);//着色
                    rotateRight(parentOf(x));//按父右旋
                    x = root;//结束循环
                }
            }
        }
        setColor(x, BLACK);//将x置为黑色
    }

红黑树具体的添加或删除示意图可参照往期博客
关于 firstEntry() 和 getFirstEntry()都是用于获取第一个结点，那么二者到底有什么区别呢？
- firstEntry() 是对外接口； getFirstEntry() 是内部接口。并且，firstEntry() 是经过 getFirstEntry() 来实现的。那为何外界不能直接调用 getFirstEntry()，而须要画蛇添足的调用 firstEntry() 呢?这么作的目的是：防止用户修改返回的Entry。getFirstEntry()返回的Entry是能够被修改的，可是通过firstEntry()返回的Entry不能被修改，只能够读取Entry的key值和value值。
HashMap类
- Java最基本的数据结构有数组和链表。数组的特色是空间连续（大小固定）、寻址迅速，可是插入和删除时须要移动元素，因此查询快，增长删除慢。链表刚好相反，可动态增长或减小空间以适应新增和删除元素，但查找时只能顺着一个个节点查找，因此增长删除快，查找慢。有没有一种结构综合了数组和链表的优势呢？固然有，那就是哈希表（虽然说是综合优势，但实际上查找确定没有数组快，插入删除没有链表快，一种折中的方式吧）。通常采用拉链法实现哈希表。

HashMap经常使用方法：

put()操做：在使用的时候，咱们必定会想到若是两个key经过hash%Entry[].length获得的index相同，会不会有覆盖的危险？为了解决这个问题，HashMap里面用到链式数据结构的一个概念。上面咱们提到过Entry类里面有一个next属性，做用是指向下一个Entry。打个比方，第一个键值对A进来，经过计算其key的hash获得的index=0，记作:Entry[0] = A。一会后又进来一个键值对B，经过计算其index也等于0，如今怎么办？HashMap会这样作:B.next = A,Entry[0] = B,若是又进来C,index也等于0,那么C.next = B,Entry[0] = C；这样咱们发现index=0的地方其实存取了A,B,C三个键值对,他们经过next这个属性连接在一块儿。因此疑问不用担忧。也就是说数组中存储的是最后插入的元素。

public V put(K key, V value) {
      //若是table数组为空数组{}，进行数组填充（为table分配实际内存空间），入参为threshold，此时threshold为initialCapacity 默认是1<<4(=16)
      if (table == EMPTY_TABLE) {
          inflateTable(threshold);//分配数组空间
      }
     //若是key为null，存储位置为table[0]或table[0]的冲突链上
      if (key == null)
          return putForNullKey(value);
      int hash = hash(key);//对key的hashcode进一步计算，确保散列均匀
      int i = indexFor(hash, table.length);//获取在table中的实际位置
      for (Entry<K,V> e = table[i]; e != null; e = e.next) {
      //若是该对应数据已存在，执行覆盖操做。用新value替换旧value，并返回旧value
          Object k;
          if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
              V oldValue = e.value;
              e.value = value;
              e.recordAccess(this);//调用value的回调函数，其实这个函数也为空实现
              return oldValue;
          }
      }
      modCount++;//保证并发访问时，若HashMap内部结构发生变化，快速响应失败
      addEntry(hash, key, value, i);//新增一个entry
      return null;
  }

inflateTable的源码以下：

private void inflateTable(int toSize) {
      int capacity = roundUpToPowerOf2(toSize);//capacity必定是2的次幂
      threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);//此处为threshold赋值，取capacity*loadFactor和MAXIMUM_CAPACITY+1的最小值，capaticy必定不会超过MAXIMUM_CAPACITY，除非loadFactor大于1
      table = new Entry[capacity];//分配空间
      initHashSeedAsNeeded(capacity);//选择合适的Hash因子
  }

inflateTable这个方法用于为主干数组table在内存中分配存储空间，经过roundUpToPowerOf2(toSize)能够确保capacity为大于或等于toSize的最接近toSize的二次幂，roundUpToPowerOf2中的这段处理使得数组长度必定为2的次幂，Integer.highestOneBit是用来获取最左边的bit（其余bit位为0）所表明的数值。在对数组进行空间分配后，会根据hash函数计算散列值。经过hash函数获得散列值后，再经过indexFor进一步处理来获取实际的存储位置。经过以上分析，咱们看到，要获得一个元素的存储位置，须要以下几步：
- ①获取该元素的key值
- ②经过hash方法获得key的散列值，这其中须要用到key的hashcode值。
- ③经过indexFor计算获得存储的下标位置。
最后，获得存储的下标位置后，咱们就能够将元素放入HashMap中，具体经过addEntry实现：

void addEntry(int hash, K key, V value, int bucketIndex) {
      if ((size >= threshold) && (null != table[bucketIndex])) {
          resize(2 * table.length);//当size超过临界阈值threshold，而且即将发生哈希冲突时进行扩容，新容量为旧容量的2倍
          hash = (null != key) ? hash(key) : 0;
          bucketIndex = indexFor(hash, table.length);//扩容后从新计算插入的位置下标
      }

      //把元素放入HashMap的桶的对应位置
      createEntry(hash, key, value, bucketIndex);
  }
//建立元素  
  void createEntry(int hash, K key, V value, int bucketIndex) {  
      Entry<K,V> e = table[bucketIndex];  //获取待插入位置元素
      table[bucketIndex] = new Entry<>(hash, key, value, e);//这里执行连接操做，使得新插入的元素指向原有元素。
//这保证了新插入的元素老是在链表的头  
      size++;//元素个数+1  
  }

3. 实验过程当中遇到的问题和解决过程

问题1：在作第二个实验的时候，递归完成后打印的二叉树个预期的不同。
问题1解决方案：我先是检查了一遍循环，利用循环在中序序列中找到根节点，我debug了一遍，没有在循环这里发现错误。那就是递归存在问题，我从新捋了一遍本身的思路，根据传入的序列的数组的索引值进行分割，在中序序列中但凡比根元素索引值小的即为根元素的左结点，大的即为根元素的右结点。按照中序序列分红的两部分元素又能够把前序序列分红两部分，接下来用递归，把新获得的序列数组做为参数，直到造成二叉树的结构。我又仔细检查了一下本身的代码，发现了问题所在：由于前序序列的第一个是根元素，因此在进行递归传入参数时startpos变量须要加1，加上后，问题就解决了。
问题2：在作第四个实验的时候，始终不能正确的把中缀表达式转换为后缀表达式。
问题2解决方案：我先对循环体进行debug，因为代码中的判断条件和循环条件过多，因此的debug的效果并不理想。我仔细检查了一下生成的后缀表达式，发现排列的顺序是相反的，这就说明从numList弹出的时候顺序是不对的。我又仔细想了一下，先进入numList的优先级是最高的，构造二叉树的时候优先级高的成为左子树。因此numList是从前日后遍历的，这样一来，我就找到了个人问题所在。我误在numList弹出元素的时候把索引值设置成了size（）-1，改为0问题就得以解决了。

其余

此次实验的难度分布的比较不均匀，大致上来讲就是简单的很简单，难的很是难，在一些小地方也浪费了不少时间，致使没有在预想的时间内完成实验，但愿本身能在之后的学习生活中继续努力，不断进步！node

20172313 2018-2019-1 《程序设计与数据结构》实验二报告

20172313 2018-2019-1 《程序设计与数据结构》实验一报告

1.实验内容

2. 实验过程及结果

实验一

实验二

实验三

实验四

实验五

实验六

3. 实验过程当中遇到的问题和解决过程

其余

参考资料