Experiment 4. Binary Tree

T1 构建二叉搜索树并实现相关的功能

（未按书上的写，按自己的想法来实现的）

package Experiment4;

import org.w3c.dom.ls.LSOutput;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;


public class test1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入树的节点个数");
        int num = sc.nextInt();
        TreeNode root = new TreeNode();
        for(int i=0;i<num;i++){
            if(i==0){
                root.val = sc.nextInt();
            }else{
                root.addNode(root,sc.nextInt());
            }
        }

        System.out.print("前序遍历开始: ");
        root.preOrder(root);
        System.out.println();
        System.out.print("中序遍历开始: ");
        root.inOrder(root);
        System.out.println();
        System.out.print("后序遍历开始: ");
        root.postOrder(root);
        System.out.println();
        System.out.println("叶子节点的个数为: "+root.countLeaves(root));
        System.out.println("节点的个数为: "+root.countNodes(root));
        System.out.println("树的高度为: "+root.heightCount(root));
    }
}
class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(){}
    TreeNode(int val,TreeNode left,TreeNode right){
        this.val = val;
        this.left = left;
        this.right = right;
    }
    TreeNode(int val){
        this.val = val;
    }
    //-----------------------------按二叉搜索树去添加节点
    public TreeNode addNode(TreeNode root,int val){
        if(root==null)  root = new TreeNode(val);
        if(val<root.val) root.left = addNode(root.left,val);
        if(val>root.val) root.right = addNode(root.right,val);
        return root;
    }
    //前序的递归遍历方式
    public void preOrder(TreeNode node){
        if(node==null) return;
        System.out.print(node.val+" ");
        if(node.left!=null)  preOrder(node.left);
        if(node.right!=null)  preOrder(node.right);
    }
    //中序的递归的遍历方式
    public void inOrder(TreeNode node){
        if(node==null) return;
        if(node.left!=null) inOrder(node.left);
        System.out.print(node.val+" ");
        if(node.right!=null) inOrder(node.right);
    }
    //后序的递归的遍历方式
    public void postOrder(TreeNode node){
        if(node==null) return;
        if(node.left!=null) postOrder(node.left);
        if(node.right!=null) postOrder(node.right);
        System.out.print(node.val+" ");
    }
    //计算节点的个数  采用的层序遍历的迭代法
    public int countNodes(TreeNode root){
        Queue<TreeNode> que = new LinkedList<>();
        int count = 0;
        if(root!=null) que.offer(root);
        while(!que.isEmpty()){
            int len = que.size();
            count +=len;
            while(len>0) {
                TreeNode node = que.poll();
                if (node.left != null) que.offer(node.left);
                if (node.right != null) que.offer(node.right);
                len--;
            }
        }
        return count;
    }
    //计算叶子节点的个数同样使用层序法的迭代
    public int countLeaves(TreeNode root){
        Queue<TreeNode> que = new LinkedList<>();
        int count = 0;
        if(root!=null) que.offer(root);
        while(!que.isEmpty()){
            int len = que.size();
            while(len>0) {
                TreeNode node = que.poll();
                if(node.left==null&&node.right==null) count++;    //判断为叶子节点的方式
                if (node.left != null) que.offer(node.left);
                if (node.right != null) que.offer(node.right);
                len--;
            }
        }
        return count;
    }
    //计算树的高度同样使用层序法的迭代    树的高度和深度是一样的
    public int heightCount(TreeNode root){
        Queue<TreeNode> que = new LinkedList<>();
        int height = -1;
        if(root!=null) que.offer(root);
        while(!que.isEmpty()){
            int len = que.size();
            height++;
            while(len>0) {
                TreeNode node = que.poll();
                if (node.left != null) que.offer(node.left);
                if (node.right != null) que.offer(node.right);
                len--;
            }
        }
        return height;
    }
}

命令行内容

请输入树的节点个数
8
3 1 4 6 9 7 5 2
前序遍历开始: 3 1 2 4 6 5 9 7 
中序遍历开始: 1 2 3 4 5 6 7 9 
后序遍历开始: 2 1 5 7 9 6 4 3 
叶子节点的个数为: 3
节点的个数为: 8
树的高度为: 4 (该高度是从0开始计数的)

---

T2

package Experiment4;

import java.util.LinkedList;
import java.util.Queue;

public class test2 {
    public static void main(String[] args) {
        System.out.println("构建AvlTree");
        /*构建AvlTree*/
        AvlNode root = new AvlNode(6);
        AvlNode newNode = new AvlNode(9);
        AvlNode tmp = root;
        tmp.right = newNode;
        tmp = tmp.right;
        newNode = new AvlNode(7);
        tmp.left = newNode;
        tmp = root;
        newNode = new AvlNode(3);
        tmp.left = newNode;
        tmp = tmp.left;
        AvlNode tmp1 = tmp;
        newNode = new AvlNode(1);
        tmp.left = newNode;
        tmp = tmp.left;
        newNode = new AvlNode(2);
        tmp.right = newNode;
        tmp = tmp1;
        newNode = new AvlNode(4);
        tmp.right = newNode;
        tmp = tmp.right;
        tmp.right = new AvlNode(5);


        System.out.print("前序遍历开始: ");
        root.preOrder(root);
        System.out.println();
        System.out.print("中序遍历开始: ");
        root.inOrder(root);
        System.out.println();
        System.out.print("后序遍历开始: ");
        root.postOrder(root);
        System.out.println();
        System.out.println("叶子节点的个数为: "+root.countLeaves(root));
        System.out.println("节点的个数为: "+root.countNodes(root));
        System.out.println("树的高度为: "+root.heightCount(root));
    }

}
class AvlNode{
    int val;
    AvlNode left;
    AvlNode right;
    int height;
    AvlNode(int val)
    {
        this.val = val;
    }
    AvlNode(){}
    AvlNode(int val,AvlNode left,AvlNode right)
    {
        this.val = val;
        this.left = left;
        this.right = right;
        this.height = 0;
    }
    //前序的递归遍历方式
    public void preOrder(AvlNode node){
        if(node==null) return;
        System.out.print(node.val+" ");
        if(node.left!=null)  preOrder(node.left);
        if(node.right!=null)  preOrder(node.right);
    }
    //中序的递归的遍历方式
    public void inOrder(AvlNode node){
        if(node==null) return;
        if(node.left!=null) inOrder(node.left);
        System.out.print(node.val+" ");
        if(node.right!=null) inOrder(node.right);
    }
    //后序的递归的遍历方式
    public void postOrder(AvlNode node){
        if(node==null) return;
        if(node.left!=null) postOrder(node.left);
        if(node.right!=null) postOrder(node.right);
        System.out.print(node.val+" ");
    }
    //计算节点的个数  采用的层序遍历的迭代法
    public int countNodes(AvlNode root){
        Queue<AvlNode> que = new LinkedList<>();
        int count = 0;
        if(root!=null) que.offer(root);
        while(!que.isEmpty()){
            int len = que.size();
            count +=len;
            while(len>0) {
                AvlNode node = que.poll();
                if (node.left != null) que.offer(node.left);
                if (node.right != null) que.offer(node.right);
                len--;
            }
        }
        return count;
    }
    //计算叶子节点的个数同样使用层序法的迭代
    public int countLeaves(AvlNode root){
        Queue<AvlNode> que = new LinkedList<>();
        int count = 0;
        if(root!=null) que.offer(root);
        while(!que.isEmpty()){
            int len = que.size();
            while(len>0) {
                AvlNode node = que.poll();
                if(node.left==null&&node.right==null) count++;    //判断为叶子节点的方式
                if (node.left != null) que.offer(node.left);
                if (node.right != null) que.offer(node.right);
                len--;
            }
        }
        return count;
    }
    //计算树的高度同样使用层序法的迭代    树的高度和深度是一样的
    public int heightCount(AvlNode root){
        Queue<AvlNode> que = new LinkedList<>();
        int height = -1;
        if(root!=null) que.offer(root);
        while(!que.isEmpty()){
            int len = que.size();
            height++;
            while(len>0) {
                AvlNode node = que.poll();
                if (node.left != null) que.offer(node.left);
                if (node.right != null) que.offer(node.right);
                len--;
            }
        }
        return height;
    }

}

命令行内容：

构建AvlTree
前序遍历开始: 6 3 1 2 4 5 9 7 
中序遍历开始: 1 2 3 4 5 6 7 9 
后序遍历开始: 2 1 5 4 3 7 9 6 
叶子节点的个数为: 3
节点的个数为: 8
树的高度为: 3
 

---

T3

该程序统计单词出现的频率 单词可以换行（有时单词过长需要换行） 开头结尾均可以带空格

大写的和小写的均视为一种单词如 Hello hello为同一单词

 命令行内容：

 

package Experiment4;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Map;
import java.util.TreeMap;

public class test3 {
    public static void main(String[] args) throws IOException {
        //用于读文件
        String fileName ="C:\\Users\\10258\\Desktop\\test5.txt";
        FileReader fileReader = new FileReader(fileName);
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        TreeMap<String,Integer> map = new TreeMap<>();
        String line =bufferedReader.readLine();
        StringBuffer buffer = new StringBuffer();
        //循环的读每一行并将其存汝buffer中
        while (line!=null){
            line.toLowerCase();
            buffer.append(line);
            line = bufferedReader.readLine();
        }

        StringBuffer tmp = new StringBuffer();
        for(int i = 0;i<buffer.length();i++)
        {
            //如果是英文字母就加入tmp中
            if(buffer.charAt(i)>='a'&&buffer.charAt(i)<='z')
            {
                tmp.append(buffer.charAt(i));
            }if(buffer.charAt(i)==' '||i==buffer.length()-1){  //如果遇见后面是空格或者为最后一个字母了就说明前面是一个单词
                if(tmp.toString().equals("")) continue;
                if(!map.containsKey(tmp.toString())){ //第一次出现就创建
                    map.put(tmp.toString(),1);
                }else{
                    map.put(tmp.toString(),map.get(tmp.toString())+1);  //不是第一次出现就+1
                }
                tmp.replace(0,tmp.length(),"");
            }
        }//map的遍历方式
        for(Map.Entry<String,Integer> entry:map.entrySet())
        {
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    }
}