import java.util.ArrayList;
import java.util.Collections;public class Main {public static void main(String[] args) {System.out.println("Pride and Prejudice");ArrayList<String> words = new ArrayList<>();if(FileOperation.readFile("pride-and-prejudice.txt", words)) {System.out.println("Total words: " + words.size());// Collections.sort(words);// Test BSTlong startTime = System.nanoTime();BST<String, Integer> bst = new BST<>();for (String word : words) {if (bst.contains(word))bst.set(word, bst.get(word) + 1);elsebst.add(word, 1);}for(String word: words)bst.contains(word);long endTime = System.nanoTime();double time = (endTime - startTime) / 1000000000.0;System.out.println("BST: " + time + " s");// Test AVL TreestartTime = System.nanoTime();AVLTree<String, Integer> avl = new AVLTree<>();for (String word : words) {if (avl.contains(word))avl.set(word, avl.get(word) + 1);elseavl.add(word, 1);}for(String word: words)avl.contains(word);endTime = System.nanoTime();time = (endTime - startTime) / 1000000000.0;System.out.println("AVL: " + time + " s");}System.out.println();}
}

import java.util.ArrayList;public class AVLTree<K extends Comparable<K>, V> {private class Node{public K key;public V value;public Node left, right;public int height;public Node(K key, V value){this.key = key;this.value = value;left = null;right = null;height = 1;}}private Node root;private int size;public AVLTree(){root = null;size = 0;}public int getSize(){return size;}public boolean isEmpty(){return size == 0;}// 判断该二叉树是否是一棵二分搜索树public boolean isBST(){ArrayList<K> keys = new ArrayList<>();inOrder(root, keys);for(int i = 1 ; i < keys.size() ; i ++)if(keys.get(i - 1).compareTo(keys.get(i)) > 0)return false;return true;}private void inOrder(Node node, ArrayList<K> keys){if(node == null)return;inOrder(node.left, keys);keys.add(node.key);inOrder(node.right, keys);}// 判断该二叉树是否是一棵平衡二叉树public boolean isBalanced(){return isBalanced(root);}// 判断以Node为根的二叉树是否是一棵平衡二叉树，递归算法private boolean isBalanced(Node node){if(node == null)return true;int balanceFactor = getBalanceFactor(node);if(Math.abs(balanceFactor) > 1)return false;return isBalanced(node.left) && isBalanced(node.right);}// 获得节点node的高度private int getHeight(Node node){if(node == null)return 0;return node.height;}// 获得节点node的平衡因子private int getBalanceFactor(Node node){if(node == null)return 0;return getHeight(node.left) - getHeight(node.right);}// 对节点y进行向右旋转操作，返回旋转后新的根节点x//        y                              x//       / \                           /   \//      x   T4     向右旋转 (y)        z     y//     / \       - - - - - - - ->    / \   / \//    z   T3                       T1  T2 T3 T4//   / \// T1   T2private Node rightRotate(Node y) {Node x = y.left;Node T3 = x.right;// 向右旋转过程x.right = y;y.left = T3;// 更新heighty.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;return x;}// 对节点y进行向左旋转操作，返回旋转后新的根节点x//    y                             x//  /  \                          /   \// T1   x      向左旋转 (y)       y     z//     / \   - - - - - - - ->   / \   / \//   T2  z                     T1 T2 T3 T4//      / \//     T3 T4private Node leftRotate(Node y) {Node x = y.right;Node T2 = x.left;// 向左旋转过程x.left = y;y.right = T2;// 更新heighty.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;return x;}// 向二分搜索树中添加新的元素(key, value)public void add(K key, V value){root = add(root, key, value);}// 向以node为根的二分搜索树中插入元素(key, value)，递归算法// 返回插入新节点后二分搜索树的根private Node add(Node node, K key, V value){if(node == null){size ++;return new Node(key, value);}if(key.compareTo(node.key) < 0)node.left = add(node.left, key, value);else if(key.compareTo(node.key) > 0)node.right = add(node.right, key, value);else // key.compareTo(node.key) == 0node.value = value;// 更新heightnode.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));// 计算平衡因子int balanceFactor = getBalanceFactor(node);// 平衡维护// LLif (balanceFactor > 1 && getBalanceFactor(node.left) >= 0)return rightRotate(node);// RRif (balanceFactor < -1 && getBalanceFactor(node.right) <= 0)return leftRotate(node);// LRif (balanceFactor > 1 && getBalanceFactor(node.left) < 0) {node.left = leftRotate(node.left);return rightRotate(node);}// RLif (balanceFactor < -1 && getBalanceFactor(node.right) > 0) {node.right = rightRotate(node.right);return leftRotate(node);}return node;}// 返回以node为根节点的二分搜索树中，key所在的节点private Node getNode(Node node, K key){if(node == null)return null;if(key.equals(node.key))return node;else if(key.compareTo(node.key) < 0)return getNode(node.left, key);else // if(key.compareTo(node.key) > 0)return getNode(node.right, key);}public boolean contains(K key){return getNode(root, key) != null;}public V get(K key){Node node = getNode(root, key);return node == null ? null : node.value;}public void set(K key, V newValue){Node node = getNode(root, key);if(node == null)throw new IllegalArgumentException(key + " doesn't exist!");node.value = newValue;}// 返回以node为根的二分搜索树的最小值所在的节点private Node minimum(Node node){if(node.left == null)return node;return minimum(node.left);}// 从二分搜索树中删除键为key的节点public V remove(K key){Node node = getNode(root, key);if(node != null){root = remove(root, key);return node.value;}return null;}private Node remove(Node node, K key){if( node == null )return null;Node retNode;if( key.compareTo(node.key) < 0 ){node.left = remove(node.left , key);// return node;retNode = node;}else if(key.compareTo(node.key) > 0 ){node.right = remove(node.right, key);// return node;retNode = node;}else{   // key.compareTo(node.key) == 0// 待删除节点左子树为空的情况if(node.left == null){Node rightNode = node.right;node.right = null;size --;// return rightNode;retNode = rightNode;}// 待删除节点右子树为空的情况else if(node.right == null){Node leftNode = node.left;node.left = null;size --;// return leftNode;retNode = leftNode;}// 待删除节点左右子树均不为空的情况else{// 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点// 用这个节点顶替待删除节点的位置Node successor = minimum(node.right);//successor.right = removeMin(node.right);successor.right = remove(node.right, successor.key);successor.left = node.left;node.left = node.right = null;// return successor;retNode = successor;}}if(retNode == null)return null;// 更新heightretNode.height = 1 + Math.max(getHeight(retNode.left), getHeight(retNode.right));// 计算平衡因子int balanceFactor = getBalanceFactor(retNode);// 平衡维护// LLif (balanceFactor > 1 && getBalanceFactor(retNode.left) >= 0)return rightRotate(retNode);// RRif (balanceFactor < -1 && getBalanceFactor(retNode.right) <= 0)return leftRotate(retNode);// LRif (balanceFactor > 1 && getBalanceFactor(retNode.left) < 0) {retNode.left = leftRotate(retNode.left);return rightRotate(retNode);}// RLif (balanceFactor < -1 && getBalanceFactor(retNode.right) > 0) {retNode.right = rightRotate(retNode.right);return leftRotate(retNode);}return retNode;}}

public int[] intersect(int[] nums1, int[] nums2) {AVLTree<Integer, Integer> map = new AVLTree<>();for(int num: nums1){if(!map.contains(num))map.add(num, 1);elsemap.add(num, map.get(num) + 1);}ArrayList<Integer> res = new ArrayList<>();for(int num: nums2){if(map.contains(num)){res.add(num);map.add(num, map.get(num) - 1);if(map.get(num) == 0)map.remove(num);}}int[] ret = new int[res.size()];for(int i = 0 ; i < res.size() ; i ++)ret[i] = res.get(i);return ret;}

public int uniqueMorseRepresentations(String[] words) {String[] codes = {".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."};AVLTree<String, Object> set = new AVLTree<>();for(String word: words){StringBuilder res = new StringBuilder();for(int i = 0 ; i < word.length() ; i ++)res.append(codes[word.charAt(i) - 'a']);set.add(res.toString(), null);}return set.getSize();}

public interface Map<K, V> {void add(K key, V value);boolean contains(K key);V get(K key);void set(K key, V newValue);V remove(K key);int getSize();boolean isEmpty();
}

public class AVLMap<K extends Comparable<K>, V> implements Map<K, V> {private AVLTree<K, V> avl;public AVLMap(){avl = new AVLTree<>();}@Overridepublic int getSize(){return avl.getSize();}@Overridepublic boolean isEmpty(){return avl.isEmpty();}@Overridepublic void add(K key, V value){avl.add(key, value);}@Overridepublic boolean contains(K key){return avl.contains(key);}@Overridepublic V get(K key){return avl.get(key);}@Overridepublic void set(K key, V newValue){avl.set(key, newValue);}@Overridepublic V remove(K key){return avl.remove(key);}
}

public interface Set<E> {void add(E e);boolean contains(E e);void remove(E e);int getSize();boolean isEmpty();
}

public class AVLSet<E extends Comparable<E>> implements Set<E> {private AVLTree<E, Object> avl;public AVLSet(){avl = new AVLTree<>();}@Overridepublic int getSize(){return avl.getSize();}@Overridepublic boolean isEmpty(){return avl.isEmpty();}@Overridepublic void add(E e){avl.add(e, null);}@Overridepublic boolean contains(E e){return avl.contains(e);}@Overridepublic void remove(E e){avl.remove(e);}
}

public int[] intersection(int[] nums1, int[] nums2) {AVLSet<Integer> set = new AVLSet<>();for(int num: nums1)set.add(num);ArrayList<Integer> list = new ArrayList<>();for(int num: nums2){if(set.contains(num)){list.add(num);set.remove(num);}}int[] res = new int[list.size()];for(int i = 0 ; i < list.size() ; i ++)res[i] = list.get(i);return res;}

public int[] intersect(int[] nums1, int[] nums2) {AVLMap<Integer, Integer> map = new AVLMap<>();for(int num: nums1){if(!map.contains(num))map.add(num, 1);elsemap.add(num, map.get(num) + 1);}ArrayList<Integer> res = new ArrayList<>();for(int num: nums2){if(map.contains(num)){res.add(num);map.add(num, map.get(num) - 1);if(map.get(num) == 0)map.remove(num);}}int[] ret = new int[res.size()];for(int i = 0 ; i < res.size() ; i ++)ret[i] = res.get(i);return ret;}