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());
    }
}