public class BinarySearchTree {static class TreeNode {public int val;public TreeNode left;public TreeNode right;public TreeNode(int val) {this.val = val;}}public TreeNode root;public boolean search(int key){TreeNode cur = root;if(root == null){return false;}while(cur != null){if(cur.val > key){cur = cur.left;} else if (cur.val <key) {cur = cur.right;}else{return true;}}return false;}public boolean insert(int key){TreeNode node = new TreeNode(key);if(root == null){//  如果根就是的话，直接添加了，然后return true；root = node;return true;}TreeNode cur = root;TreeNode parent = cur;//赋值while(cur != null){if(cur.val < key){parent = cur;  //这一步一定要提前cur = cur.right;} else if (cur.val >key) {parent = cur;cur = cur.left;}else{return false;}}if(parent.val < key){   //你就说为什么cur == null了把它小于的话(cur在该添加的位置上面等于了null)parent.right = node;}else{parent.left = node;}return true;}

    public void remove(int val){TreeNode cur = root;//要移除这个节点，首先我要先遍历二叉搜索树找到这个节点TreeNode parent = null;if(root == null){return;}while(cur != null)if(cur.val < val) { parent = cur;cur = cur.right;}else if(cur.val > val){parent = cur;cur = cur.left;}else{//要删除的节点，找到了removeTreeNode(cur,parent);}}private void removeTreeNode(TreeNode cur,TreeNode parent) {if(cur.left == null){if(cur.val > parent.val){//这一步就纯纯的是判读那cur走到了parent的左边还是右边，parent.right = cur.right;//你这一点都不知道，我滴妈你让parent的左边接力还是右边？}else{parent.left = cur.right;}}else if(cur.right == null){       //cur的右边空了if(cur.val > parent.val){//和上面一样parent.right = cur.left;}else{parent.left = cur.left;}}else{    // cur 的两边都不为空TreeNode target = cur.right; //准备TreeNode parentTarget = null;while(target.left != null){parentTarget = target;target = target.left;}cur.val = target.val;if(parentTarget != null){parentTarget.left = target.right;}else{cur.right = target.right;}}}

2.3 模型

比如：

统计文件中每个单词出现的次数，统计结果是每个单词都有与其对应的次数： < 单词，单词出现的次数 >

import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;public class Test {public static void main(String[] args) {Map<String,Integer> map = new TreeMap<>();
//1.put 和 get(Object key) 返回 key 对应的 valuemap.put("zhangsan",18);map.put("zhangsan",20);//会进行更新，key值不会重复map.put("lisi",18);map.put("wangWu",50);//int val = map.get("lihua");返回的是一个空指针异常而不是类型转换异常，很有讲究的//这个时候就可以用这个方法map.getOrDefault("lihua",20);// 没有key的话就相当于一次put，（key是lihua）（val是20）
//3.(keyset):Set<K> keySet() 返回所有 key 的不重复集合Set<String> set = map.keySet();  //经过排序的从大到小for (String s: set) {System.out.print(s + " ");}//或者System.out.println(set);
//4：Set<K> keySet() 返回所有 key 的不重复集合Collection<Integer> collection = map.values();//也是有顺序的，一般都是按照key的进行排序System.out.println(collection);System.out.println("==============");
//5:Set<Map.Entry<K, V>> entrySet() 返回所有的 key-value 映射关系Set<Map.Entry<String,Integer>> entries = map.entrySet();for (Map.Entry<String,Integer> entry:entries) {System.out.println("key:" + entry.getKey() + " val:" + entry.getValue());}//或者直接打印也行System.out.println(entries);System.out.println("===========");}

       1.  哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间（我是数组我要连续(*^▽^*)）

      2.  哈希函数计算出来的地址能均匀分布在整个空间中

      3.哈希函数应该比较简单

// key-value 模型
public class HashBucket {public static class Node {private int val;private int key;public Node next;//这里一定要注意，你如果在这里上来就构造了一个根节点的public Node(int key, int val) {this.key = key;this.val = val;}}private static final double LOAD_FACTOR = 0.75;//负载因子//根本不需要根节点，我底层是数组进行实现的，要你没有用//public Node root;public Node[] array = new Node[5];    //我这个就是HsahMap的底层实现，开散列：数组 + 链表private int usedSize;   //一般只要一个数据结构底层运用了数组，一般都会有usedSize去记录有效元素public boolean search(int key) {   //这个要判断val吗？int index = key % array.length;Node cur = array[index];//   我直接计算出这个key应该在的位置，然后在数组的这个位置进行查找while (cur != null) {if (cur.key == key) {return true;}cur = cur.next;}return false;}public void put(int key, int val) {int index = key % array.length;Node cur = array[index];while (cur != null) {  // 先遍历一遍这个链表，判读这个key在不在里面，如果在的话，就更新val值if (cur.key == key) {cur.val = val;}cur = cur.next;}//走到这里说明不在这里，直接进行头插Node node = new Node(key,val);node.next = array[index];array[index] = node;usedSize++;if(usedSize * 1.0/ array.length > LOAD_FACTOR){  //这里要乘  1.0revise(array);}}private void revise(Node[] array) {  //这里要是有参数的话，下面的array，一定要加this啊！！！！！！！！！！！//首先让数字进行扩容//最后再返回数组Node[] tmpArray = Arrays.copyOf(array,2*array.length);//先遍历一遍原来的数组，再在每个数组元素上遍历链表for (int i = 0; i < array.length; i++) {Node cur = array[i];while(cur != null){//计算出新的下标，再进行头插int newIndex = cur.key % tmpArray.length;//这个节点就是cur其实没必要再多定义了/*Node node = new Node(cur.key,cur.val);node.next = tmpArray[newIndex];tmpArray[newIndex] = node;cur = cur.next;
*///你们是一样的道理Node curNext = cur.next;cur.next = tmpArray[newIndex];tmpArray[newIndex] = cur;cur =curNext;}}array = tmpArray;//   这里一定要this啊！！！！！！！！！！！！！//  除非上面没有参数}public int get(int key){int index = key % array.length;Node cur = array[index];//   我直接计算出这个key应该在的位置，然后在数组的这个位置进行查找while (cur != null) {if (cur.key == key) {return cur.val;}cur = cur.next;}return -1;}
}

public class Test {public static void main(String[] args) {HashBucket hashBucket = new HashBucket();hashBucket.put(1,1);hashBucket.put(2,2);hashBucket.put(3,3);hashBucket.put(4,4);hashBucket.put(5,5);//就这里i = 1下标出问题了System.out.println("===============");System.out.println(hashBucket.get(1));System.out.println(hashBucket.get(2));System.out.println(hashBucket.get(5));System.out.println(hashBucket.get(9));}
}

class Person{String name;public Person(String name) {this.name = name;}//一定要重写equals方法，因为我要看看你一开始在不在里面，相同名字的lihua@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Person person = (Person) o;return Objects.equals(name, person.name);}//这个也是@Overridepublic int hashCode() {return Objects.hash(name);}
}public class HashBucket1 <K,V>{public class Node<K,V>{  //为什么不能是静态的？（静态的不依赖于类，所以说我根本不知道K,V是谁？private K key;private V val;private Node<K,V> next;//这里一定要注意，你如果在这里上来就构造了一个根节点的public Node( K key, V val) {this.key = key;this.val = val;}}private Node[] array ;private static final double LOAD_FACTOR = 0.75;//负载因子public HashBucket1() {this.array = new Node[10];}private int usedSize;public void put(K key, V val){int hash = key.hashCode();//还能是负的？int index = Math.abs(hash % array.length);Node<K,V> cur = array[index];//先找一遍看有没有，没有直接头插法while(cur != null){if(cur.key.equals(key)){   //所以说这个key一定要重写equals方法cur.val = val;return;}cur = cur.next;}// 到这里就肯定没有了，没有直接头插法Node<K,V> node = new Node<>(key,val);node.next = array[index];array[index] = node;usedSize++;// 判断负载因子大不大if(usedSize*1.0 / array.length > LOAD_FACTOR){revise();}}private void revise() {Node<K,V> [] tmpArray = Arrays.copyOf(array,2*array.length);for (int i = 0; i < array.length; i++) {Node<K,V> cur = array[i];while(cur != null){Node<K,V> curNext = cur.next;//找到新下标直接进行插入int newIndex = Math.abs(cur.hashCode() % tmpArray.length);cur.next = tmpArray[newIndex];tmpArray[newIndex] = cur;cur = curNext;}}this.array = tmpArray;}public V get(K key){int index = key.hashCode() % array.length;Node<K,V> cur = array[index];while(cur != null){if(cur.key == key){return cur.val;}cur = cur.next;}return null;}public boolean search(K key){int index = key.hashCode() % array.length;Node<K,V> cur = array[index];while(cur != null){if(cur.key == key){return true;}cur = cur.next;}return false;}
}

public class TestHashBucket1 {public static void main(String[] args) {Person person = new Person("zhangSan");Person person1 = new Person("zhangSan");Person person2 = new Person("zhangSan");HashBucket1<Person,Integer> hashBucket1= new HashBucket1();//这个key一定要重写equals方法（不然俺咋判断，我写的哈希表里面有没有这个元素hashBucket1.put(person,18);hashBucket1.put(person1,18);hashBucket1.put(person2,18);System.out.println("============");}
}

class Solution {public int singleNumber(int[] nums) {Set<Integer> set = new HashSet<>();
//一边进去，相同的出来for(int i = 0; i < nums.length; i++){if(set.contains(nums[i])){set.remove(nums[i]);}else{set.add(nums[i]);}}
//如果包含就是你了（只出现过一次）for(int i = 0; i < nums.length; i++){if(set.contains(nums[i])){return nums[i];}}return -1;}
}

import java.util.Map;
class Solution {public Node copyRandomList(Node head) {Node cur = head;Map<Node,Node> map = new HashMap<>();while(cur != null){Node node = new Node(cur.val);map.put(cur,node);   //帮下面的链接上，通过HashMapcur = cur.next;//node = node.next;       这样写肯定不对，因为我每次都要new一个Node对象，就链接不上了}cur = head;while(cur != null){map.get(cur).random = map.get(cur.random);map.get(cur).next = map.get(cur.next);cur = cur.next;}return map.get(head);}
}

class Solution {public int numJewelsInStones(String jewels, String stones) {Set<Character> set = new HashSet<>();for(int i = 0; i<jewels.length(); i++){set.add(jewels.charAt(i));   //    是add而不是put}int count = 0;for(int i = 0; i<stones.length(); i++){char ch = stones.charAt(i);if(set.contains(ch)){count++;}}return count;}
}

 public static void find(String s1,String act){Set<Character> set = new HashSet<>();for (char ch: act.toUpperCase().toCharArray()) {set.add(ch);}Set<Character> set2 = new HashSet<>();for (char ch: s1.toUpperCase().toCharArray()) {if(! set.contains(ch)){set2.add(ch);}}for (Object o:set2.toArray()) {System.out.println(o);}}public static void main(String[] args) {String s1 = "abc def 7 abc";String s2 = "abc";find(s1,s2);}

public  List<String> topKFrequent(String[] words, int k) {// 一个哈希表，统计所有单词出现的个数Map<String,Integer> map = new HashMap<>();for(String word : words){if( !map.containsKey(word)){map.put(word,1);}else{int count =  map.get(word);map.put(word,++count);}}//建立小根堆，重写比较方法//  这里的Entry<>记得前面加上Map，因为他是Map里面的内部类，所有的都要加PriorityQueue<Map.Entry<String,Integer>> minHeap = new PriorityQueue<>(new Comparator<Map.Entry<String, Integer>>() {@Overridepublic int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {if((o1.getValue() - o2.getValue()) == 0 ){return o2.getKey().compareTo(o1.getKey());}return o2.getValue() - o1.getValue();}});for (Map.Entry<String,Integer> entry : map.entrySet()) {Map.Entry<String,Integer> top =  minHeap.peek();if(minHeap.size() <= k){minHeap.offer(entry);}else{//   如果你俩的出现的频率相同，让字母的ASCII码值进行比较大的进来if(top.getValue().equals(entry.getValue())){if(top.getKey().compareTo(entry.getKey()) > 0){minHeap.poll();minHeap.offer(entry);}}else{// 下一个元素的val大，让下一个元素进来if(entry.getValue().compareTo(top.getValue()) > 0){minHeap.poll();minHeap.offer(entry);}}}}List<String> ret = new ArrayList<>();for (int i = 0; i < k; i++) {Map.Entry<String,Integer> top = minHeap.poll();ret.add(top.getKey());}Collections.reverse(ret);return ret;}