20172301 《Java軟件結構與數據結構》實驗二報告

時間 2019-12-08

標籤 Java軟件結構與數據結構實驗報告欄目 Java 简体版

原文原文鏈接

20172301 《Java軟件結構與數據結構》實驗二報告

課程：《Java軟件結構與數據結構》
班級： 1723
姓名：郭愷
學號：20172301
實驗教師：王志強老師
實驗日期：2018年11月20日
必修/選修：必修html

一.實驗內容

實驗1

實驗2

實驗3

實驗4

實驗5

實驗6

二.實驗過程及結果

實驗1

LinkedBinaryTree由於是以前的程序項目，因此實現起來很容易。java

getRight()方法，首先在LinkedBinaryTree類裏面聲明一個全局變量

protected LinkedBinaryTree<T> left,right;

而後在構造函數裏，添加下面兩行代碼。node

// 建立以指定元素爲根元素的二叉樹，把樹做爲它的左子樹和右子樹
    public LinkedBinaryTree(T element, LinkedBinaryTree<T> left,
                            LinkedBinaryTree<T> right)
    {
        root = new BinaryTreeNode<T>(element);
        root.setLeft(left.root);
        root.setRight(right.root);
        this.left = left;
        this.right = right;
    }

而後直接返回right便可。編程

// 返回此樹的根的右子樹。
    public LinkedBinaryTree<T> getRight()
    {
        return right;
    }

contains方法基於私有方法findAgain實現。只須要判斷在樹裏可否找到目標元素便可。

public boolean contains(T targetElement)
    {
        return findAgain(targetElement, root) != null;
    }

toString方法，這裏爲了讓輸出是一個樹型，我用了以前ExpressionTree的printTree方法。一樣，toString方法能夠考慮使用四種遍歷方式。
preorder方法和postorder方法，實現理念和書上給的中序遍歷同樣。只須要調整一下左右孩子還有結點的順序。

// 執行遞歸先序遍歷。
    protected void preOrder(BinaryTreeNode<T> node, ArrayUnorderedList<T> tempList)
    {
        if (node != null)
        {
            tempList.addToRear(node.getElement());
            preOrder(node.getLeft(), tempList);
            preOrder(node.getRight(), tempList);
        }
    }

// 執行遞歸後序遍歷。
    protected void postOrder(BinaryTreeNode<T> node,
                             ArrayUnorderedList<T> tempList)
    {
        if (node != null)
        {
            postOrder(node.getLeft(), tempList);
            postOrder(node.getRight(), tempList);
            tempList.addToRear(node.getElement());
        }
    }

接下來是測試類和測試結果

實驗2

根據以前上課講的方法，咱們首先要肯定如何推斷出根和根的左右孩子。例如題目中的兩個字符串，中序HDIBEMJNAFCKGL和先序ABDHIEJMNCFGKL。
中序分左右，前後序定根。
這裏，我一開始是沒有什麼思路的，由於我本身推導先序和中序構造樹的時候，並無系統的方法。因此我也在網上找到了一些資料，如何有步驟的去分析先序和中序。
會分爲如下幾個步驟：
- 肯定整棵二叉樹的根節點即先序遍歷中的第一個元素root
- 肯定root在中序遍歷元素的位置，root左邊的元素爲二叉樹的左子樹元素Lchild，右邊爲右子樹元素Rchild
- 在先序遍歷中找到最早出現Lchild中元素的那個元素，爲Lchild的根節點——root的左孩子節點，同理找出Rchild的根節點——root的右孩子節點
- 重複2,3步驟直至二叉樹構建完成;
那麼，咱們沿着這個思路，就能根據先序得知A是樹的根結點。那麼根據中序得知A的左邊是左子樹，A的右邊是右子樹。
同理，根據先序B便是左子樹的根，根據中序得知B的左邊是左子樹的左孩子，B的右邊是左子樹的右孩子。
依次往下，知道左右孩子爲空的時候。這時候便可返回以A爲根的樹。
因此，運用遞歸，分別遞歸實現左子樹和右子樹。
最後，以A爲根結點和遞歸實現的左右子樹，建立一個新樹。
接下來是測試代碼和代碼結果。

實驗3

決策樹相對來講比較簡單，由於書上的背部疼痛診斷器給出了一個決策樹的流程。咱們只須要設計一棵新的決策樹便可。
文件裏包含着一些數字，是由於第一個數字是代表你有幾個語句，而後下面的是爲了構建左右子樹。
測試代碼和結果

實驗4

實驗四是輸入中綴表達式，使用樹將中綴表達式轉換爲後綴表達式，並輸出後綴表達式和計算結果。書上有一個ExpresstionTree是關於後綴表達式計算的一個樹。
這個我一開始也沒有什麼思路，可是實際上也就是一個表達式樹，符號做爲根，而後操做數是他的左右子樹。 我參考書上後綴計算的例子，運用一個表達式式棧，注意：這個棧裏面存放的是樹型的。爲了實現的方便，我直接存放的是二叉樹，並無用表達式樹。而後還有一個符號棧。這裏還須要考慮一個優先級的問題，** 優先級高的要在底層。**
具體的實現思路和判斷條件和上學期的差很少，我並無改動多少，主要注意的就是樹的存放和符號左右兩個操做數的順序。我便很少贅述。括號問題將在問題中詳細說明。
代碼測試和結果

實驗5

實驗五是以前的課後項目，已經實現過。二叉查找樹的特色是，左子樹的最左結點是最小值，樹的右子樹的最右結點是最大值，。因此，實現findMin和findMax只要分別查找最左結點和最右結點便可。
測試代碼和結果

實驗6

在看源代碼以前，我以爲有必要學習一下如何去系統的看程序源代碼。這裏作一些摘錄：
第一，找准入口出口，不要直接跳進去看，任何代碼都有觸發點，不管是http request，仍是服務器自動啓動，仍是main函數，仍是其餘的，先從入口開始。
第二，手邊一支筆一張紙，除非你是Jeff，不然你不會記得那麼多跳轉的。一個跳轉就寫下來函數/方法名和參數，讀完一遍，就有了一個sequence diagram雛形。
第三，私有方法掠過，只要記住輸入輸出便可，無需看具體實現數組

紅黑樹遵循如下五點性質：
性質1 結點是紅色或黑色。
性質2 根結點是黑色。
性質3 每一個葉子結點（NIL結點，空結點）是黑色的。
性質4 每一個紅色結點的兩個子結點都是黑色。(從每一個葉子到根的全部路徑上不能有兩個連續的紅色結點)
性質5 從任一結點到其每一個葉子結點的全部路徑都包含相同數目的黑色結點。服務器

TreeMap

首先看一下TreeMap聲明

public class TreeMap<K,V> extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, java.io.Serializable {

構造方法

public TreeMap() {
    comparator = null;
}

無參構造方法，不指定比較器，排序的實現要依賴key.compareTo()方法，所以key必須實現Comparable接口，並覆寫其中的compareTo方法。
public TreeMap(Comparator<? super K> comparator) { this.comparator = comparator; }
採用帶比較器的構造方法，排序依賴該比較器，key能夠不用實現Comparable接口。
public TreeMap(Map<? extends K, ? extends V> m) { comparator = null; putAll(m); }
構造方法一樣不指定比較器，調用putAll方法將Map中的全部元素加入到TreeMap中。
public TreeMap(SortedMap<K, ? extends V> m) { comparator = m.comparator(); try { buildFromSorted(m.size(), m.entrySet().iterator(), null, null); } catch (java.io.IOException | ClassNotFoundException cannotHappen) { } }
將比較器指定爲m的比較器，然後調用buildFromSorted方法，將SortedMap中的元素插入到TreeMap中，根據SortedMap建立的TreeMap，將SortedMap中對應的元素添加到TreeMap中。數據結構

put操做

public V put(K key, V value) {
    //獲得紅黑樹根結點
    Entry<K,V> t = root;
    if (t == null) {
        compare(key, key); // type (and possibly null) check

        // 若是樹爲空，新建紅黑樹根結點
        root = new Entry<>(key, value, null);
        size = 1;
        modCount++;
        return null;
    }

    //若是Map不爲空,找到插入新節點的父節點
    int cmp;
    Entry<K,V> parent;

    Comparator<? super K> cpr = comparator;
    // 若是比較器不爲空
    if (cpr != null) {
        do {
        // 使用 parent 上次循環後的 t 所引用的 Entry
            parent = t;
         // 拿新插入的key和t的key進行比較
            cmp = cpr.compare(key, t.key);
        // 若是新插入的key小於t的key，t等於t的左結點
            if (cmp < 0)
                t = t.left;
        // 若是新插入的key大於t的key，t等於t的右結點
            else if (cmp > 0)
                t = t.right;
            else
        // 若是兩個key相等，新value覆蓋原有的value，並返回原有的value
                return t.setValue(value);
        } while (t != null);
    }

    // 沒有提供比較器
    else {
        if (key == null)
            throw new NullPointerException();
        @SuppressWarnings("unchecked")
            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);
    }
    // 將新插入的結點做爲parent結點的子結點
    Entry<K,V> e = new Entry<>(key, value, parent);
    // 做爲左孩子
    if (cmp < 0)
        parent.left = e;
    // 做爲右孩子
    else
        parent.right = e;
        // 修復紅黑樹
    fixAfterInsertion(e);
    size++;
    modCount++;
    return null;
}

每當程序但願添加新結點時，老是從樹的跟結點開始比較，即將根結點當成當前結點。
- 若是新增結點大於當前結點且當前結點的右子結點存在，則以右子結點做爲當前結點；
- 若是新增結點小於當前結點且當前結點的左子結點存在，則以左子結點做爲當前結點；
- 若是新增結點等於當前結點，則用新增結點覆蓋當前結點，並結束循環，直到找到某個結點的左、右子結點不存在
- 將新增結點添加爲該結點的子結點。若是新結點比該結點大，則添加其爲右子結點；若是新結點比該結點小，則添加其爲左子結點。

HashMap

首先看一下HashMap類的聲明，能夠了解他繼承了什麼類和實現了哪些接口。

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {

<K,V>應該表示的是一種映射關係。app

HashMap 的實例有兩個參數影響其性能：初始容量和加載因子。
容量是哈希表中桶的數量，初始容量只是哈希表在建立時的容量。
加載因子是哈希表在其容量自動增長以前能夠達到多滿的一種尺度。當哈希表中的條目數超出了加載因子與當前容量的乘積時，則要對該哈希表進行 rehash 操做（即重建內部數據結構），從而哈希表將具備大約兩倍的桶數。函數

這裏有兩個比較重要的變量，容量和加載因子。容量的值是2的n次冪，加載因子默認爲0.75。
源碼分析

這裏加載因子爲何默認是0.75呢？

一般，默認加載因子 (0.75) 在時間和空間成本上尋求一種折衷。加載因子太高雖然減小了空間開銷，但同時也增長了查詢成本（在大多數 HashMap 類的操做中，包括 get 和 put 操做，都反映了這一點）。在設置初始容量時應該考慮到映射中所需的條目數及其加載因子，以便最大限度地減小 rehash 操做次數。
若是初始容量大於最大條目數除以加載因子，則不會發生 rehash 操做。
這裏的rehash操做，我以爲相似於數組的擴容。

加載因子就是表示數組鏈表填滿的程度。
加載因子越大,填滿的元素越多,空間利用率高了,但衝突的機會加大了.鏈表長度會愈來愈長,查找效率下降。
加載因子越小,填滿的元素越少,衝突的機會減少了,但空間浪費多了.表中的數據將過於稀疏，不少空間還沒用，就開始擴容了。

所以,必須在 "衝突的機會"與"空間利用率"之間尋找一種平衡與折衷.
若是機器內存足夠，而且想要提升查詢速度的話能夠將加載因子設置小一點；相反若是機器內存緊張，而且對查詢速度沒有什麼要求的話能夠將加載因子設置大一點。不過通常咱們都不用去設置它，讓它取默認值0.75就行了。
　　

構造函數：

// 初始容量（必須是2的n次冪），負載因子
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;
this.threshold = tableSizeFor(initialCapacity);
}

我發現其中還有一個指針類,HashMap使用了數組，鏈表和紅黑樹，多種實現。

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;

    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;  // 哈希值
        this.key = key;     // 鍵
        this.value = value;  // 值
        this.next = next;    // 下一個
    }

    public final K getKey()        { return key; }
    public final V getValue()      { return value; }
    public final String toString() { return key + "=" + value; }

    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }

    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }


    // 判斷兩個Node是否相等    
    // 若兩個Node的「key」和「value」都相等，則返回true。    
    // 不然，返回false    
    public final boolean equals(Object o) {
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

next，是用來處理衝突的。HashMap原本就是一個數組，若是數組中某一個索引起生了衝突，那麼就會造成鏈表。而鏈表到必定程度的時候，就會造成紅黑樹。

put操做

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}


final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
    // resize()方法是從新調整HashMap的大小
        n = (tab = resize()).length;
    // 若不爲null，計算該key的哈希值，而後將其添加到該哈希值對應的鏈表中
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
            //若是是紅黑樹結點
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

儘管明白一些基本操做，但仍是沒有理解大多數代碼。

三. 實驗過程當中遇到的問題和解決過程

問題1：實驗二基於（中序，先序）序列構造惟一一棵二㕚樹的功能，出現了ArrayIndexOutOfBoundsException異常，簡單來講就是數組爲空。
如圖
問題1解決方案：
- 首先，找到問題出現的行數，而後設置斷點進行調試。
- 根據我以上實驗二的思路，我根據先序判斷出來的根結點，把中序分紅了兩個數組，分別是中序左子樹和中序右子樹，同理，把先序也分紅兩個數組，分別是先序左子樹和先序右子樹。
- 根據調試發現，在新建了子樹的中序和先序數組以後，我並無把原來數組的值導入到新的數組當中。因此致使運行時拋出了數組空的異常。
  如圖
- 那我只須要使用一個循環遍歷原數組的操做，把元素賦值進新的數組。即，以根結點爲分界線，分別存入左右子樹當中。小於根結點對應索引的元素全在左子樹，大於根結點的全在右子樹。
```
for (int y = 0; y < in.length; y++) {   
// 把原數組的數存入新的數組當中
    if (y < x) {
        inLeft[y] = in[y];
        preLeft[y] = pre[y + 1];
    } 
    else if (y > x) {
        inRight[y - x - 1] = in[y];
        preRight[y - x - 1] = pre[y];
    }
}
```
問題2：實驗四樹的輸出格式不對，從而致使後綴表達式輸出格式不正確。
如圖
問題2解決方案：
- 實現二叉樹中綴轉後綴以後，卻發現後序遍歷輸出樹的時候出來的後綴表達式格式不對。
- 一樣是通過調試發現，在符號入棧的時候，轉化爲LinkedBinaryTree類型存儲的時候，並以LinkedBinaryTree類型爲根結點的時候，會根據其toString方法，變成，\n\n + \n\n \n\n，因此輸出樹的時候前面會多出不少行。
  如圖
- 個人解決辦法是，把操做數棧改爲String類型的，以String類型的符號做爲根結點，這樣，結果能夠正常輸出。
  如圖
問題3: 實驗四中綴轉後綴的括號問題。

問題3解決方案：

一開始個人括號問題想得很複雜，後來譚鑫同窗告訴我，括號裏其實也是一個表達式，只要遞歸調用一下就能夠了。確實是，若是把括號裏面的當作一個表達式，那麼就和正常的沒有括號的是同樣的啦。
可是後來我仍是完成了本身寫的非遞歸實現，儘管代碼可能有些複雜，可是條例仍是清晰的，而且代碼判斷條件也是不缺乏的。

// 處理括號
        if (tempToken.equals("(")) {
            op.push(tempToken);
            tempToken = stringTokenizer.nextToken();

            while (!tempToken.equals(")")) {
                if (tempToken.equals("+") || tempToken.equals("-")) {
                    if (!op.isEmpty()) {
                        // 棧不空，判斷「(」
                        if (op.peek().equals("("))
                            op.push(tempToken);
                        else {
                            String b = op.pop();
                            operand1 = getOperand(expre);
                            operand2 = getOperand(expre);
                            LinkedBinaryTree a = new LinkedBinaryTree(b, operand2, operand1);
                            expre.push(a);
                            op.push(tempToken);
                        }
                    } else {
                        // 棧爲空，運算符入棧
                        op.push(tempToken);
                    }
                } else if (tempToken.equals("*") || tempToken.equals("/")) {
                    if (!op.isEmpty()) {
                        if (op.peek().equals("*") || op.peek().equals("/")) {
                            String b = op.pop();
                            operand1 = getOperand(expre);
                            operand2 = getOperand(expre);
                            LinkedBinaryTree a = new LinkedBinaryTree(b, operand2, operand1);
                            expre.push(a);
                            op.push(tempToken);
                        } else {
                            op.push(tempToken);
                        }
                    }
                } else {
                    // 操做數入棧
                    LinkedBinaryTree a = new LinkedBinaryTree(tempToken);
                    expre.push(a);
                }
                tempToken = stringTokenizer.nextToken();
            }

            while (true) {
                String b = op.pop();
                if (!b.equals("(")) {
                    operand1 = getOperand(expre);
                    operand2 = getOperand(expre);
                    LinkedBinaryTree a = new LinkedBinaryTree(b, operand2, operand1);
                    expre.push(a);
                } else {
                    // 終止循環
                    break;
                }
            }
        }

這裏我用了兩個while循環，
第一個while循環 ，就是分別把符號入到符號棧裏，把表達樹入到表達式棧裏。若是壓入棧的操做符優先級大於等於棧頂的符號，那麼就會彈出棧頂的符號，而且以彈出的符號爲根和表達式樹彈出的兩個樹，造成一個新的樹，再存放到表達式棧裏。
第二個while循環 ，是把棧裏面括號裏面的樹和操做符所有彈出，此時棧裏面剩下的應該都是優先級相等的，因此咱們只須要把括號裏的造成一棵樹就能夠了。
整體來講確實相對於遞歸來講較爲複雜，之後仍是應該考慮代碼的優化和完整性，不能以實現目的爲目的。

其餘（感悟、思考等）

這周實驗花費了較多的時間。雖說有些項目是以前的做業而且完成了實現。可是對於實驗二和實驗四沒有很清晰系統的思路，致使花費了太多時間去設計。仍是強調代碼的全局性和前瞻性。好比說實驗四，括號的實現若是用遞歸來理解的話確實有事半功倍的效果。但是我卻把本身的思惟侷限在了多個判斷條件上面。儘管實現了，可是從代碼複雜性來講是不夠完美的。一樣的，對於HashMap和TreeMap也只是瞭解到了一些皮毛，可是，咱們能夠從其源代碼上發現本身設計實現代碼時所缺乏的東西，纔能有所收穫。代碼可能類似，但思想不會。