【无标题】

学习目标：

学习RESTful的基本使用。

二分搜索树的前序遍历

---

学习内容：

通过代码实现了二分搜索树的前序遍历：

public class BST<E extends Comparable<E>> {
    private class Node{
        public E e;
        public Node left,right;
        public Node(E e){
            this.e=e;
            left=null;
            right=null;
        }
    }
    private Node root;
    private int size;
    public BST(){
        root=null;
        size=0;
    }
    public int size(){
        return size;
    }
    public boolean isEmpty(){
        return size==0;
    }
    //向二分搜索树中添加新的元素e
    public void add(E e){
        root = add(root, e);
    }
    //向以node为根的二分搜索树中插入元素E，递归算法
    //返回插入节点后二分搜索树的根
    private Node add(Node node,E e){

        if(node==null){
            size++;
            return new Node(e);
        }
        if(e.compareTo(node.e)<0){
            node.left=add(node.left,e);
        }else if(e.compareTo(node.e)>0)
            node.right = add(node.right, e);
        return node;
    }

    //看二分搜索树中是否包含元素e
    public boolean contains(E e) {
        return contains(root, e);
    }
    //以node为根的二分搜索树中是否包含元素e,递归算法
    private boolean contains(Node node,E e){
        if(node==null)
            return false;
        if(e.compareTo(node.e)==0)
            return true;
        else if(e.compareTo(node.e)<0)
            return contains(node.left, e);
        else
            return contains(node.right, e);
    }
    //二分搜索树的前序遍历
    public void preOrder(){
        preOrder(root);
    }
    //前序遍历以node为根的二分搜索树，递归算法
    private void preOrder(Node node){
        if(node==null)
            return;
        System.out.println(node.e);
        preOrder(node.left);
        preOrder(node.right);
    }
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        generateBSTString(root, 0, res);
        return res.toString();
    }
    //生成以node为根节点，深度为depth的描述二叉树的字符串
    private void generateBSTString(Node node,int depth,StringBuilder res){
        if (node == null) {
            res.append(generateDepthString(depth)+"null\n");
            return;
        }
        res.append(generateDepthString(depth) + node.e + "\n");
        generateBSTString(node.left, depth + 1, res);
        generateBSTString(node.right, depth + 1, res);
    }
    private String generateDepthString(int depth){
        StringBuilder res = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            res.append("--");
        }
        return res.toString();
    }

}

public class Main {
    public static void main(String[] args) {
        BST<Integer> bst = new BST<>();
        int[] nums = {5, 3, 6, 8, 4, 2};
        for(int num:nums)
            bst.add(num);
        System.out.println(bst);
    }
}

实现了RESTFul实验室，并且了解了简单请求与非简单请求，并且学习了JSON序列化相关的知识。

---

学习时间：

12：30-14：00 15：30-21：30

---

学习产出：

初步了解了RESTFul风格的web应用的步骤，其比较复杂，需要日后结合项目进行更好的理解。