华为机试题 二叉查搜索树 判断两序列是否为同一二叉搜索树序列

Posted 2020-07-02 todayjust

描述:	判断两序列是否为同一二叉搜索树序列

输入	开始一个数n，(1<=n<=20) 表示有n个需要判断，n= 0 的时候输入结束。   接下去一行是一个序列，序列长度小于10，包含(0~9)的数字，没有重复数字，根据这个序列可以构造出一颗二叉搜索树。     接下去的n行有n个序列，每个序列格式跟第一个序列一样，请判断这两个序列是否能组成同一颗二叉搜索树。
输出:	如果序列相同则输出YES，否则输出NO
样例输入:	2 567432 543267 576342 0
样例输出:	YES NO

本题思路：根据初始目标序列，构建二叉搜索树，判断每个序列是否相同，设置俩个计数cl和cr， 从根节点开始，分别表示小于或者大于 head.data的次数，就为每个字符串中某个字符在二查搜索树中查找的次数。

看别人更好的思路：假设为完全二叉树，用数组来表示，插入到2i和2i+1的位置。附上一段核心代码

  1 //判断两序列是否为同一二叉搜索树序列
  2 /*
  3 2
  4 567432
  5 543267
  6 576342
  7 如果序列相同则输出YES，否则输出NO
  8  * */
  9 
 10 //本题解决思路，构建目标二叉排序树，对所有测试串，逐一逐位进行比较
 11 //更好的思路： 用数组模拟二叉排序树，构建“全二叉树”不存在的点为-1，对每个比较串，同样构建一个数组，最后俩俩比较数组即可。
 12 /*
 13  void createtree(string s, int c[])
 14 {
 15     int len = s.length();
 16     for (int i = 0; i < len; i++)
 17     {
 18         int temp = s[i] - ‘0‘;
 19         for (int j = 1; j <= 1023;)
 20         {
 21             if (c[j] == -1)
 22             {
 23                 c[j] = temp; break;
 24             }
 25             else if (c[j]>temp)
 26                 j = j * 2;
 27             else
 28             {
 29                 j = j * 2 + 1;
 30             }
 31         }
 32     }
 33 }
 34  */
 35 import java.util.Scanner;
 36 
 37 public class isBinarySortTree {
 38     public static void judge(String[] s, int n) {
 39 
 40         Node head = null;
 41         Node pre = null;
 42         for (int k = 0; k < s[0].length(); k++) {
 43             Node node = new Node(s[0].charAt(k) - ‘0‘);
 44             if (head == null) {
 45                 head = node;
 46             } else {
 47                 pre = head;
 48                 while (true) {
 49                     if (node.data < pre.data) {
 50                         if (pre.l == null) {
 51                             pre.l = node;
 52                             break;
 53                         } else {
 54                             pre = pre.l;
 55                         }
 56                     } else if (node.data == pre.data) {
 57                         break;
 58                     } else {
 59                         if (pre.r == null) {
 60                             pre.r = node;
 61                             break;
 62                         } else {
 63                             pre = pre.r;
 64                         }
 65                     }
 66                 }
 67             }
 68         }
 69 
 70     
 71         for (int i = 1; i <= n; i++) {
 72             int cl = 0, cr = 0;// 记录左右 大于或者小于head的次数，就为左右查找比较的次数
 73             int cll = 0, crr = 0;
 74             int data = 0;
 75             int flag=0;
 76             if ( (s[i].charAt(0) - ‘0‘)!= head.data) {
 77                 System.out.println("NO");
 78                 continue;
 79             }
 80             for (int k = 0; k < s[i].length(); k++) {
 81                 data = s[i].charAt(k) - ‘0‘;
 82                 pre = head;
 83                 if (data == head.data) {
 84                     continue;
 85                 } else if (data < head.data) {
 86                     cl++;
 87                 } else {
 88                     cr++;
 89                 }
 90                 cll = cl;
 91                 crr = cr;
 92                 while (true) {
 93                     if (data < head.data) {
 94                         while (cll >= 0) {
 95                             if (data == pre.data) {
 96                                 break;
 97                             } else if (data < pre.data) {
 98                                 pre = pre.l;
 99 
100                             } else {
101                                 pre = pre.r;
102                             }
103                             cll--;
104                         }
105                         if (cll < 0) {// NO
106                             flag=1;
107                         } 
108                         break;
109                     }
110                     if (data > head.data) {
111                         while (crr >= 0) {
112                             if (data == pre.data) {
113                                 break;
114                             } else if (data > pre.data) {
115                                 pre = pre.r;
116                             } else {
117                                 pre = pre.l;
118                             }
119                             crr--;
120                         }
121                         if (crr < 0) {// NO
122                             flag=1;
123                         } 
124                         break;
125                     }
126                 }
127                 
128 
129             }//每一个串比较结束
130             if(flag==0){
131                 System.out.println("YES");
132             }else{
133                 System.out.println("NO");
134             }
135         }
136 
137     }
138 
139     public static void main(String[] args) {
140         Scanner sc = new Scanner(System.in);
141         int n = sc.nextInt();
142         String s[] = new String[n + 1];
143         int i = 0;
144         while (i <= n) {
145 
146             s[i++] = sc.next();
147         }
148         judge(s, n);
149 
150     }
151 }
152 
153 class Node {
154     int data;
155     Node l = null;
156     Node r = null;
157 
158     Node(int data) {
159         this.data = data;
160     }
161 }