04-树4 是否同一棵二叉搜索树

题目

略

解题思路

主要考察的是建树，遍历。

本题只需要建树后对两颗树进行层序遍历，加以判断每层节点是否相等就可以了。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

/**
 * @author Nino
 */

public class Main{
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] arr;
        while ((arr = br.readLine().split(" ")).length != 1) {
            int N = Integer.parseInt(arr[0]);
            int L = Integer.parseInt(arr[1]);
            String stringLine = br.readLine();
            String[] stringArr = stringLine.split(" ");
            int[] initArr = new int[N];
            for (int i = 0; i < N; i++) {
                initArr[i] = Integer.parseInt(stringArr[i]);
            }
            BST bst0 = new BST();
            for (int i : initArr) {
                bst0.addNode(i);
            }
            ArrayList<BST> bsts = new ArrayList<>();
            int[][] arrs = new int[L][N];
            for (int i = 0; i < L; i++) {
                stringLine = br.readLine();
                stringArr = stringLine.split(" ");
                BST bst = new BST();
                for (int j = 0; j < N; j++) {
                    arrs[i][j] = Integer.parseInt(stringArr[j]);
                    bst.addNode(arrs[i][j]);
                }
                bsts.add(bst);
            }
           isSame(bst0, bsts);
        }
        br.close();
    }

    static void isSame(BST bst0, ArrayList<BST> bsts) {
        for (BST bst : bsts) {
            BST.Node root1 = bst0.root;
            BST.Node root2 = bst.root;
            Queue<BST.Node> queue1 = new LinkedList<>();
            Queue<BST.Node> queue2 = new LinkedList<>();
            queue1.add(root1);
            queue2.add(root2);
            boolean breakFlag = false;
            while (!queue1.isEmpty()&&!queue2.isEmpty()) {
                BST.Node node1 = queue1.remove();
                BST.Node node2 = queue2.remove();
                if (node1.value != node2.value) {
                    System.out.println("No");
                    breakFlag = true;
                    break;
                }
                if (node1.left != null && node2.left != null) {
                    queue1.add(node1.left);
                    queue2.add(node2.left);
                } else if (node1.left == null && node2.left == null) {

                } else {
                    System.out.println("No");
                    breakFlag = true;
                    break;
                }

                if (node1.right != null && node2.right != null) {
                    queue1.add(node1.right);
                    queue2.add(node2.right);
                } else if (node1.right == null && node2.right == null) {

                } else {
                    System.out.println("No");
                    breakFlag = true;
                    break;
                }
            }
            if (breakFlag == false) {
                System.out.println("Yes");
            } else {
                continue;
            }
        }
    }
    static class BST{
        class Node{
            int value;
            Node left;
            Node right;

            public Node(int value) {
                this.value = value;
                left = null;
                right = null;
            }
        }
        int size;
        Node root;

        public BST() {
            this.size = 0;
            root = null;
        }

        protected boolean isEmpty() {
            return size == 0;
        }

        protected void addNode(int value) {
            root = addNode(root, value);
            size++;
        }

        private Node addNode(Node node, int value) {
            if (node == null) {
                return new Node(value);
            }
            if (node.value > value) {
                node.left = addNode(node.left, value);
            } else if (node.value < value) {
                node.right = addNode(node.right, value);
            }
            return node;
        }
    }
}