Dictionary tree leetcode seven hundred and forty-five

 class TrieTree {
            // A prefix , A suffix 
            private Node root1;// The root node , No value 
            private Node root2;
            // Internal node class 
            private class Node{
                private Node childs[];// The following is marked as 26 Letters , Store the next node 
                private  boolean isLeaf;// Is it a leaf node 
                private List<Integer> idxs;// Pass the word index of this node 
                public Node(){
                    childs=new Node[26];
                    isLeaf=false;
                    idxs=new ArrayList<>();
                }
                public boolean contains(char key){
                    return childs[key-'a']!=null;
                }
                public Node get(char key){
                    return childs[key-'a']==null?null:childs[key-'a'];
                }
                public void put(char key,Node n){
                    childs[key-'a']=n;
                }
            }
            public TrieTree(){
                root1=new Node();
                root2=new Node();
            }
            // Add string 
            public void put(String word,int idx){
                put(root1,root2,word,idx);
            }
            private void put(Node root1,Node root2,String word,int idx){
                char[] chs=word.toCharArray();
                int n=chs.length;
                Node cur2=root2;
                Node cur1=root1;
                for (int i = 0; i < n; i++) {
                    // If one of these characters is not included , Create a new node 
                    if(!cur1.contains(chs[i])){
                        cur1.put(chs[i],new Node());
                    }
                    if(!cur2.contains(chs[n-1-i])){
                        cur2.put(chs[n-1-i],new Node());
                    }
                    cur1=cur1.get(chs[i]);// If it contains, continue to look for the next character 
                    cur2=cur2.get(chs[n-1-i]);
                    // For a word , If it passes through a node , Then record to this node 
                    // When looking for a prefix , The last node records all word indexes with this prefix 
                    cur1.idxs.add(idx);
                    cur2.idxs.add(idx);
                }
                // Reach the end of the word 
                cur1.isLeaf=true;
                cur2.isLeaf=true;
            }

            List<Integer> search(Node root,String pre,int idx){
                // To the end 
                if(idx==pre.length())
                    return root.idxs;
                char c=pre.charAt(idx);
                if(root.get(c)!=null)
                    return search(root.get(c),pre,idx+1);
                else return null;

            }
        }


        TrieTree t;
        public WordFilter(String[] words) {
            t=new TrieTree();
            for(int i=0;i<words.length;i++){
                t.put(words[i],i);
            }
        }
        public int f(String a, String b) {
            StringBuilder sb=new StringBuilder(b);
            // Because the index increases from small to large when adding words , Then the node idxs Must be orderly 
            List<Integer> s1=t.search(t.root1,a,0);// have a Prefix 
            List<Integer> s2=t.search(t.root2,sb.reverse().toString(),0);// have b suffix 
            // Look for the largest index that exists in both lists from back to front 
            if(s1!=null&&s2!=null){
                for (int i = s1.size()-1,j=s2.size()-1; i >=0 ; i--) {
                    while(j>=0){
                        if(s2.get(j).equals(s1.get(i)))//Integer Type comparison 
                            return s1.get(i);
                        if(s2.get(j)<s1.get(i))
                            break;
                        j--;
                    }
                }
            }
            return -1;
        }