20192303 2020-2021-1 《資料結構與面向物件程式設計》實驗八報告

課程：《程式設計與資料結構》
班級： 1923
姓名： 楊佳寧
學號： 20192303
實驗教師：王志強
實驗日期：2020年12月3日
必修/選修： 必修
一、實驗內容
（一）參考教材PP16.1,完成鏈樹LinkedBinaryTree的實現（getRight,contains,toString,preorder,postorder）
1、用JUnit或自己編寫驅動類對自己實現的LinkedBinaryTree進行測試，提交測試程式碼執行截圖，要全屏，包含自己的學號資訊
2、課下把程式碼推送到程式碼託管平臺
（二）基於LinkedBinaryTree，實現基於（中序，先序）序列構造唯一一棵二㕚樹的功能，比如給出中序HDIBEMJNAFCKGL和後序ABDHIEJMNCFGKL,構造出附圖中的樹
1、用JUnit或自己編寫驅動類對自己實現的功能進行測試，提交測試程式碼執行截圖，要全屏，包含自己的學號資訊
2、課下把程式碼推送到程式碼託管平臺
（三）自己設計並實現一顆決策樹
1、提交測試程式碼執行截圖，要全屏，包含自己的學號資訊
2、課下把程式碼推送到程式碼託管平臺
（四）輸入中綴表示式，使用樹將中綴表示式轉換為字尾表示式，並輸出字尾表示式和計算結果（如果沒有用樹，正常評分。如果用到了樹，即使有小的問題，也酌情給滿分）
1、提交測試程式碼執行截圖，要全屏，包含自己的學號資訊

二、實驗過程及結果
（一）參考教材PP16.1,完成鏈樹LinkedBinaryTree的實現（getRight,contains,toString,preorder,postorder）
1、用JUnit或自己編寫驅動類對自己實現的LinkedBinaryTree進行測試，提交測試程式碼執行截圖，要全屏，包含自己的學號資訊
2、課下把程式碼推送到程式碼託管平臺

1、以下為LinkedBinaryTree的程式碼

import java.util.ArrayList;
import java.util.Arrays;

public class LinkedBinaryTree<T> implements BinaryTree<T>
{
    protected BTNode<T> root;

    public LinkedBinaryTree()
    {
        root = null;
    }


    public LinkedBinaryTree (T element)
    {
        root = new BTNode<T>(element);
    }

    public LinkedBinaryTree (T element, LinkedBinaryTree<T> left, LinkedBinaryTree<T> right) {
        root = new BTNode<T>(element);
        root.setLeft(left.root);
        root.setRight(right.root);
    }

    public T getRootElement() throws EmptyCollectionException {
        if (root == null)
            throw new EmptyCollectionException("Get root operation " + "failed. The tree is empty.");

        return root.getElement();
    }

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

        LinkedBinaryTree<T> result = new LinkedBinaryTree<T>();
        result.root = root.getLeft();

        return result;
    }

    public T find (T target) throws ElementNotFoundException {
        BTNode<T> node = null;

        if (root != null)
            node = root.find(target);

        if (node == null)
            throw new ElementNotFoundException("Find operation failed. " + "No such element in tree.");

        return node.getElement();
    }

    public int size() {
        int result = 0;

        if (root != null)
            result = root.count();

        return result;
    }

    public ArrayList<T> inorder() {
        ArrayList<T> iter = new ArrayList<T>();

        if (root != null)
            root.inorder (iter);

        return iter;
    }

    public ArrayList<T> levelorder() throws EmptyCollectionException {
        LinkedQueue<BTNode<T>> queue = new LinkedQueue<BTNode<T>>();
        ArrayList<T> iter = new ArrayList<T>();

        if (root != null)
        {
            queue.enqueue(root);
            while (!queue.isEmpty())
            {
                BTNode<T> current = queue.dequeue();

                iter.add (current.getElement());

                if (current.getLeft() != null)
                    queue.enqueue(current.getLeft());
                if (current.getRight() != null)
                    queue.enqueue(current.getRight());
            }
        }

        return iter;
    }

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

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

        return result; }

    public boolean contains (T target) {
        if(root.find(target)==null)
            return false;
        else
            return true;
    }

    public boolean isEmpty() {
        if(root!=null)
            return false;
        else
            return true;
    }

    public String toString() {
        return super.toString();
    }

    public ArrayList<T> preorder() {
        ArrayList<T> iter = new ArrayList<T>();

        if (root != null)
            root.preorder (iter);

        return iter;
    }

    public ArrayList<T> postorder() {
        ArrayList<T> iter = new ArrayList<T>();

        if (root != null)
            root.postorder (iter);

        return iter;
    }

    public BTNode build(char[] pre, char[] in){
        if (pre.length == 0 || in.length == 0) {
            return null;
        }
        BTNode<Character> tree = new BTNode<Character>(pre[0]);
        int index = search(0, in.length, in, tree.getElement());
        tree.setLeft(build(Arrays.copyOfRange(pre, 1, index + 1), Arrays.copyOfRange(in, 0, index)));
        tree.setRight(build(Arrays.copyOfRange(pre, index + 1, pre.length),
                Arrays.copyOfRange(in, index + 1, in.length)));
        return tree;
    }

    public int search(int start, int end, char[] inOrders, char data) {
        for (int i = start; i < end; i++) {
            if (data == inOrders[i]) {
                return i;
            }
        }
        return -1;
    }

    public void preOrder(BTNode<T> Tree)
    {
        System.out.print(Tree.getElement()+" ");
        BTNode<T> leftTree = Tree.left;
        if(leftTree != null)
        {
            preOrder(leftTree);
        }
        BTNode<T> rightTree = Tree.right;
        if(rightTree != null)
        {
            preOrder(rightTree);
        }
    }

    public static void inOrder(BTNode tree)
    {
        if(tree == null)
            return;
        else
        {
            inOrder(tree.left);
            System.out.print(tree.print()+" ");
            inOrder(tree.right);
        }
    }
}
 

2、執行結果截圖

（二）基於LinkedBinaryTree，實現基於（中序，先序）序列構造唯一一棵二㕚樹的功能，比如給出中序HDIBEMJNAFCKGL和後序ABDHIEJMNCFGKL,構造出附圖中的樹

1、用JUnit或自己編寫驅動類對自己實現的功能進行測試，提交測試程式碼執行截圖，要全屏，包含自己的學號資訊
2、課下把程式碼推送到程式碼託管平臺
實驗結果截圖

（三）自己設計並實現一顆決策樹
1、提交測試程式碼執行截圖，要全屏，包含自己的學號資訊
2、課下把程式碼推送到程式碼託管平臺

決策樹程式碼

import java.util.Scanner;

public class DecisionTree {
    private LinkedBinaryTree<String> tree;

    public DecisionTree(){
        String e1 = "你有選擇困難症嗎？";
        String e2 = "你有強迫症嗎？";
        String e3 = "你會把最喜歡的東西留在最後吃嗎？";
        String e4 = "你會賴床嗎？";
        String e5 = "你喜歡吃蛋糕嗎？";
        String e6 = "你總是在趕ddl嗎？";
        String e7 = "就很棒";
        String e8 = "建議你晚上多學一會兒";
        String e9 = "你是健康的";
        String e10 = "你超甜";
        String e11 = "那沒事兒了";
        String e12 = "小磨蹭無疑了";
        String e13 = "神仙";

        LinkedBinaryTree<String> n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13;
        n8 = new LinkedBinaryTree<String>(e8);
        n9 = new LinkedBinaryTree<String>(e9);
        n4 = new LinkedBinaryTree<String>(e4,n8,n9);
        n10 = new LinkedBinaryTree<String>(e10);
        n11 = new LinkedBinaryTree<String>(e11);
        n5 = new LinkedBinaryTree<String>(e5,n10,n11);
        n12 = new LinkedBinaryTree<String>(e12);
        n13 = new LinkedBinaryTree<String>(e13);
        n6 = new LinkedBinaryTree<String>(e6,n12,n13);
        n7 = new LinkedBinaryTree<String>(e7);
        n2 = new LinkedBinaryTree<String>(e2,n4,n5);
        n3 = new LinkedBinaryTree<String>(e3,n6,n7);

        tree = new LinkedBinaryTree<String>(e1,n2,n3);
    }

    public void diagnose() throws EmptyCollectionException {
        Scanner scan = new Scanner(System.in);
        LinkedBinaryTree<String> current = tree;

        System.out.println("做個心理測試吧");
        while(current.size()>1)
        {
            System.out.println(current.getRootElement());
            if(scan.nextLine().equalsIgnoreCase("Y"))
                current = current.getLeft();
            else
                current = current.getRight();
        }
        System.out.println(current.getRootElement());
    }
}
 

執行結果截圖，符合所期望的決策順序

（四）輸入中綴表示式，使用樹將中綴表示式轉換為字尾表示式，並輸出字尾表示式和計算結果（如果沒有用樹，正常評分。如果用到了樹，即使有小的問題，也酌情給滿分）
1、提交測試程式碼執行截圖，要全屏，包含自己的學號資訊
執行結果截圖

三、其他（感悟、思考等）
這次的實驗考察了我們對樹的結構及其特點的掌握，相較於之前所學內容，樹的難度還是比較大的。其中的許多概念都較為抽象，較難理解。決策樹的實現會容易一些，在理解課本程式碼的基礎上加以改動即可實現。

四、參考資料
《JAVA程式設計與資料結構教程（第二版）》
《JAVA程式設計與資料結構教程（第二版）學習指導》