7-4 List Leaves (25分) JAVA

8
1 -
- -
0 -
2 7
- -
- -
5 -
4 6

4 1 5

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * @author Ethan
 * @date 2020/6/16
 * List Leaves
 * 思路：
 * 1.对树进行层序遍历，在遍历的过程中记录叶节点。
 * 2.打印记录的叶节点
 */
public class Main1 {
    static int root = -1;
    public static void main(String[] args)throws Exception {
        StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

        Node[] nodes = buildTree(in);

        //层序遍历通过队列实现，LinkedList类具有队列的特性
        LinkedList<Node> queue = new LinkedList();
        if (root!=-1){
            //将根节点加入队列
            queue.add(nodes[root]);
        }

        ArrayList<Integer> leaves = new ArrayList();

        for (int i = 0; i < nodes.length; i++) {
            int n =0;
            //遍历出每个节点
            Node node = queue.poll();
            //如果节点的左右编号相同，说明都是-1，则为叶节点
            if (node.left== node.right){
                leaves.add(node.element);
            }
            //如果左孩子节点不为空，则将左孩子节点加入队列
            if (node.left!=-1){
                queue.add(nodes[node.left]);
            }
            //如果右孩子节点不为空，则将右孩子节点加入队列
            if (node.right!=-1){
                queue.add(nodes[node.right]);
            }
        }

        for (int i = 0; i < leaves.size(); i++) {
            System.out.print(leaves.get(i));
            if (i != leaves.size() - 1) {
                System.out.print(" ");
            }
        }
    }

    static Node[] buildTree(StreamTokenizer in) throws Exception {

        in.nextToken();
        //第一行为树的节点个数
        int n = (int) in.nval;
        Node[] tree = new Node[n];

        int[] check = new int[n];
        for (int i = 0; i < n; i++) {
            //设置标记，先将每个节点标记为 -1
            //当节点编号出现在孩子节点编号时，将标记设为1
            check[i]=-1;
        }
        for (int i = 0; i < n; i++) {
            tree[i] = new Node();
            //节点的输入顺序，即为节点值
            tree[i].element = i;

            in.nextToken();
            //读取左孩子编号
            //ttype = -2时，说明为数字
            if (in.ttype == -2) {
                tree[i].left = (int) in.nval;
                //当节点编号出现在孩子节点编号时，将标记设为1
                check[tree[i].left] = 1;
            } else {
                //当孩子节点编号为 - 时，孩子编号记为 -1
                tree[i].left = -1;
            }

            in.nextToken();
            //读取右孩子编号
            if (in.ttype == -2) {
                tree[i].right = (int) in.nval;
                check[tree[i].right] = tree[i].right;
            } else {
                tree[i].right = -1;
            }
        }

        //找出根节点：未在孩子编号中出现的节点编号为根节点
        for (int i = 0; i < n; i++) {
            if (check[i] == -1) {
                root = i;
                break;
            }
        }

        return tree;
    }
}

class Node {
    public int element;
    public int left;
    public int right;

}