20172327 2018-2019-1 《程序設計與數據結構》實驗二：樹實驗報告

20172327 2018-2019-1 《程序設計與數據結構》實驗二：樹實驗報告

• 課程：《Java軟件結構與數據結構》
• 班級：201723
• 姓名：馬瑞蕃
• 學號：20172327
• 實驗教師：王志強
• 實驗日期：2018年11月7日-2018年11月11日
• 必修/選修：必修

1、實驗內容：

實驗二 樹-1-實現二叉樹

• 參考教材p212,完成鏈樹LinkedBinaryTree的實現（getRight,contains,toString,preorder,postorder）

用JUnit或本身編寫驅動類對本身實現的LinkedBinaryTree進行測試

實驗二 樹-2-中序先序序列構造二叉樹

• 1.基於LinkedBinaryTree，實現基於（中序，先序）序列構造惟一一棵二㕚樹的功能，

• 2.給出中序HDIBEMJNAFCKGL和後序ABDHIEJMNCFGKL,構造出附圖中的樹
  

• 3.用JUnit或本身編寫驅動類對本身實現的功能進行測試

實驗二 樹-3-決策樹

• 1.本身設計並實現一顆決策樹

實驗二 樹-4-表達式樹

• 1.輸入中綴表達式，使用樹將中綴表達式轉換爲後綴表達式，並輸出後綴表達式和計算結果（若是沒有用樹，則爲0分）

實驗二 樹-5-二叉查找樹

• 1.完成PP11.3

實驗二 樹-6-紅黑樹分析

• 參考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-實現二叉樹

• 要實現 LinkedBinaryTree 中的方法，首先要將結點類 BinaryTreeNode 補充完整。在結點類中，須要補充先序遍歷和後序遍歷的函數，因爲這裏用到了迭代器和遞歸的思路，因此直接參考中序遍歷給出的函數便可：

//爲樹的中序遍歷返回一個迭代器
    public Iterator<T> iteratorInOrder() {
        ArrayUnorderedList<T> tempList = new ArrayUnorderedList<T>();
        inOrder(root, tempList);
        return new TreeIterator(tempList.iterator());
    }
    protected void inOrder(BinaryTreeNode<T> node, ArrayUnorderedList<T> tempList) {
        if (node != null) {
            inOrder(node.getLeft(), tempList);
            tempList.addToRear(node.getElement());
            inOrder(node.getRight(), tempList);
        }
    }

• 整左子樹、右子樹和根的訪問順序以及對應方法便可實現另外兩種函數：

//爲樹的前序遍歷返回一個迭代器
    public Iterator<T> iteratorPreOrder() {
        ArrayUnorderedList<T> tempList = new ArrayUnorderedList<T>();
        preOrder(root, tempList);
        return new TreeIterator(tempList.iterator());
    }
    private void preOrder(BinaryTreeNode<T> node, ArrayUnorderedList<T> tempList) {
        if (node != null) {
            tempList.addToRear(node.getElement());
            inOrder(node.getLeft(), tempList);
            inOrder(node.getRight(), tempList);
        }
    }

    @Override
    //爲樹的後序遍歷返回一個迭代器
    public Iterator<T> iteratorPostOrder() {
        ArrayUnorderedList<T> tempList = new ArrayUnorderedList<T>();
        postOrder(root, tempList);
        return new TreeIterator(tempList.iterator());
    }
    private void postOrder(BinaryTreeNode<T> node, ArrayUnorderedList<T> tempList) {
        if (node != null) {
            inOrder(node.getLeft(), tempList);
            inOrder(node.getRight(), tempList);
            tempList.addToRear(node.getElement());
        }
    }

實現告終點類以後，對應地去實現方法類 LinkedBinaryTree，方法類中須要補充的函數有：getRight,contains,isEmpty,toString,preorder,postorder.

• getRight 方法能夠參考給出的 getLeft 方法：

//返回結點的左側子結點
    public LinkedBinaryTree<T> getLeft() {
        return left;
    }
    //返回結點的右側子結點
    public LinkedBinaryTree<T> getRight() {
        return right;
    }

• contains 方法我主要考慮了根爲空、和檢測元素爲空的狀況，並對此作出條件判斷便可：（若是根爲空則會因 node 的初始值返回 false）

public boolean contains(T target) {
        BTNode<T> node = null;
        boolean result = true;
        if(root != null)
            node = root.find(target);

        if(node == null)
            result = false;

        return result;
    }

• isEmpty 方法的實現比較簡單，可是我第一次作的時候，將判斷條件寫成了 root.count() == 0，
  【注意】樹結構不是鏈表，也不是數組，count方法是返回 子樹的結點數，因此開始就默認根結點存在了即count方法的返回值至少爲1，因此固然不能用在isEmpty方法中。
  這裏直接判斷根結點是否爲空便可：

//判斷樹是否爲空
    @Override
    public boolean isEmpty() {
        return (root == null);
    }

• toString 方法的思路與以前實現的數據結構（棧、隊列）有些相似，注意這裏要用到遍歷方法，要用到遞歸，因此我用數組迭代類建立對象，以後層序遍歷輸出。我在實現這個方法時出現了不少報錯，藉助IDEA的提示，才成功解決了問題：

//打印樹
    @Override
    public String toString(){
        UnorderedListADT<BinaryTreeNode<T>> nodes = new ArrayUnorderedList<BinaryTreeNode<T>>();
        UnorderedListADT<Integer> levelList = new ArrayUnorderedList<Integer>();

        BinaryTreeNode<T> 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 方法改一下遍歷方式就行：（這三者的遍歷方式都是按子樹進行的，因此框架相同）

@Override
    //爲樹的前序遍歷返回一個迭代器
    public Iterator<T> iteratorPreOrder() {
        ArrayUnorderedList<T> tempList = new ArrayUnorderedList<T>();
        preOrder(root, tempList);
        return new TreeIterator(tempList.iterator());
    }
    private void preOrder(BinaryTreeNode<T> node, ArrayUnorderedList<T> tempList) {
        if (node != null) {
            tempList.addToRear(node.getElement());
            inOrder(node.getLeft(), tempList);
            inOrder(node.getRight(), tempList);
        }
    }

    @Override
    //爲樹的後序遍歷返回一個迭代器
    public Iterator<T> iteratorPostOrder() {
        ArrayUnorderedList<T> tempList = new ArrayUnorderedList<T>();
        postOrder(root, tempList);
        return new TreeIterator(tempList.iterator());
    }
    private void postOrder(BinaryTreeNode<T> node, ArrayUnorderedList<T> tempList) {
        if (node != null) {
            inOrder(node.getLeft(), tempList);
            inOrder(node.getRight(), tempList);
            tempList.addToRear(node.getElement());
        }
    }

連接

樹-2-中序先序序列構造二叉樹

• 步驟：
  （1）肯定樹的根結點；（先序遍歷的第一個結點就是二叉樹的根）
  （2）求解樹的子樹；（找到根在中序遍歷的位置，位置左邊就是二叉樹的左孩子，位置右邊是二叉樹的右孩子，若是根結點左邊或右邊爲空，那麼該方向子樹爲空；若是根節點左邊和右邊都爲空，那麼根節點已經爲葉結點）
  （3）對二叉樹的左、右孩子分別進行步驟（1）（2），直到求出二叉樹的結構爲止。

連接

樹-3-決策樹

• 這個實驗算是最使人愉悅的一個吧！能夠本身設計問題和答案，課本上也有一個示例代碼能夠參考，這樣思路上就比較容易了。
  決策樹須要注意的就是不要搞混左子樹和右子樹的對象，在傳遞元素時能夠參考書中的格式，先定義元素，再定義對應類型的樹，以後再將元素依次實例化並填入構建的子樹，根據回答迭代輸出問題，直到只剩下最後一層葉結點，輸出斷定結果便可：

連接

樹-4-表達式樹

• 使用樹來表示算術表達式，我知道一部分，又參考了利用Java實現表達式二叉樹，但仍是沒能實現輸入後綴，輸出中綴的狀況。這裏的表達式結果輸出我理解爲中序輸出，至於輸入我想使用後綴表達式，我繼續查找相關資料，並參考了其中的部分代碼：

public class Original extends LinkedBinaryTree{
    public BinaryTreeNode creatTree(String str){
        StringTokenizer tokenizer = new StringTokenizer(str);
        String token;
        ArrayList<String> operList = new ArrayList<>();

        ArrayList<LinkedBinaryTree> numList = new ArrayList<>();
        while (tokenizer.hasMoreTokens()){
            token = tokenizer.nextToken();
            if(token.equals("(")){
                String str1 = "";
                while (true){
                    token = tokenizer.nextToken();
                    if (!token.equals(")"))
                        str1 += token + " ";
                    else break;
                }
                LinkedBinaryTree S = new LinkedBinaryTree();
                S.root = creatTree(str1);
                numList.add(S);
            }
            if(as(token)){
                operList.add(token);
            }else if(md(token)){
                LinkedBinaryTree left = numList.remove(numList.size()-1);
                String A = token;
                token = tokenizer.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 = tokenizer.nextToken();
                        if (!token.equals(")"))
                            str1 += token + " ";
                        else break;
                    }
                    LinkedBinaryTree S = new LinkedBinaryTree();
                    S.root = creatTree(str1);
                    LinkedBinaryTree node = new LinkedBinaryTree(A,left,S);
                    numList.add(node);
                }
            }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 node = new LinkedBinaryTree(oper,left,right);
            numList.add(0,node);
        }
        root = (numList.get(0)).root;

        return root;
    }

    private boolean as(String token){
        return (token.equals("+")||
                token.equals("-"));
    }

    private boolean md(String token){
        return (token.equals("*")||
                token.equals("/"));
    }

    public String Output(){
        String result = "";
        ArrayList<String> list = new ArrayList<>();
        root.postorder(list);
        for(String i : list){
            result += i+" ";
        }
        return result;
    }
}

連接

樹-5-二叉查找樹

• 這個實驗相對容易些，要求實現二叉查找樹中的方法 findMin 和 findMax，這兩種方法無非是找出二叉查找樹中的特殊元素，因此能夠從遍歷方式上考慮。因爲二叉查找樹的最小元素始終位於整棵樹左下角最後一個左子樹的第一個位置，因此就能夠直接返回這個元素的位置，至於怎麼獲取這個元素就可使用以前的遍歷方法，二叉查找樹的最小元素是中序遍歷的第一個元素，然後序遍歷就不必定，其餘的遍歷方式也不行。因而就返回中序遍歷後的第一個元素便可。
  二叉查找樹中最大元素的查找過程同理，仍是採用中序遍歷最保險，須要使用兩次強轉：

//返回二進制搜索中最小值的元素樹.它不會從二進制搜索樹中刪除該節點。若是此樹爲空, 則拋出 EmptyCollectionException。
    // @return 最小值的元素
    // @throws EmptyCollectionException 若是樹是空的
    public T findMin() throws EmptyCollectionException 
    {
        T result = null;

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

            //modCount--;
        }

        return result;

    }

    //返回在二進制文件中具備最高值的元素搜索樹。 它不會從二進制文件中刪除節點搜索樹。 若是此樹爲空, 則拋出 EmptyCollectionException。
    // @return 具備最高值的元素
    // @throws EmptyCollectionException 若是樹是空的
    public T findMax() 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;

    }

連接

樹-6-紅黑樹分析

• 這兩個類的源碼比較長，我只針對其中的幾個方法進行了分析。
• 首先說說紅黑樹：參考 http://www.cnblogs.com/skywang12345/p/3245399.html
  紅黑樹，即 R-B Tree，全稱是Red-Black Tree，它一種特殊的二叉查找樹。紅黑樹的每一個結點上都有存儲位表示結點的顏色，能夠是紅(Red)或黑(Black)。
• 紅黑樹的特性：
  （1）每一個結點或者是黑色，或者是紅色。
  （2）根結點是黑色。
  （3）每一個葉結點（NIL）是黑色。 【注意：這裏葉結點，是指爲空(NIL或NULL)的葉結點！】
  （4）若是一個結點是紅色的，則它的子節點必須是黑色的。
  （5）從一個結點到該結點的子孫結點的全部路徑上包含相同數目的黑結點。
  【注意：特性(3)中的葉結點，是隻爲空(NIL或null)的結點。
  特性(5)，確保沒有一條路徑會比其餘路徑長出倆倍。於是，紅黑樹是相對是接近平衡的二叉樹。】

• 紅黑樹示意圖：
  

• 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接口，意味着它支持序列化。

• 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;
}

firstEntry() 和 getFirstEntry() 都是用於獲取第一個節點。firstEntry() 是對外接口；getFirstEntry() 是內部接口。並且，firstEntry() 是經過 getFirstEntry() 來實現的。

• HashMap類：
  初始容量與加載因子是影響HashMap的兩個重要因素：

public HashMap(int initialCapacity, float loadFactor)

初始容量默認值：

/**
     * The default initial capacity - MUST be a power of two.
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

加載因子默認值：

/**
     * The load factor used when none specified in constructor.
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

• 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;
    }

若是在map中包含對應的特定的鍵值則返回true，不然返回false。

3、實驗過程當中遇到的問題和解決過程

問題出現了好多，但我都解決了，忘截圖了，因此這地我也不知道寫點啥。

4、感悟

經過此次實驗，我發現我對這段時間樹的學習並部紮實，有些基本的仍是記不住，在邏輯推理的過程當中，遇到的麻煩也比較多。此次實驗讓我知道了，最近的不足，也讓我決定抽出更多時間去學習Java。

參考資料

• 《Java程序設計與數據結構教程（第二版）》

• 《Java程序設計與數據結構教程（第二版）》學習指導