1.搜索
1.1概念
Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关.常见的搜索方式有两种
1直接遍历，时间复杂度为O(N),元素多时相对效率低，
2二分查找，时间复杂度为O(logN),搜索的前提必须是有序数列
1.2模型
1 纯Key模型 如 查找字典中的字母， Set模型只存储Key
2 Key--value模型 如 查找字典中某字母出现的次数 Map中存储 Key--value
2 Map的使用
2.1Map的使用
Map是一个接口类，没有继承Collection，该类储存的是<Key,Value>键值对,这里的Key一定是唯一的，不能重复，否则会覆盖
2.2Map.Entry<k,v>的使用
Map.Entry<k,v>是Map内部实现用来存放<k,v>键值映射关系的内部类，
2.3Map的常用方法
boolen containsValue(Object Key) 判断是否包含Value
注意：
1. Map是个接口不能直接实例化对象，如果实例化对象只能实例其实现类TreeMap或者HashMap
2. Map中存放的key是唯一的，value可以重复
3. Map插入时key不能为空会报异常，value可以为空
4. Map中的Key可以全部分离出来，存储到Set中来进行访问(因为Key不能重复)。
5. Map中的value可以全部分离出来，存储在Collection的任何一个子集合中(value可能有重复)。
6. Map中的值不能直接修改，value可以修改，如果修改key需要先删除，在添加
3Set的使用
Set继承了Collection接口类，只储存了Key
注意：
1.Set最大的功能就是对集合中的元素进行去重
2.实现Set接口的常用类有TreeSet和HashSet
3. Set中的Key和Map中的一样都要先删除在添加
（以下为日常代码）
public List<String> topKFrequent(String[] words, int k) {
HashMap<String,Integer> map=new HashMap<>();
//1统计出现的次数
for (String s:words) {
if (map.get(s)==null){
map.put(s,1);
}else {
int val=map.get(s);
map.put(s,val+1);
}
}
//2建立一个小根堆
PriorityQueue<Map.Entry<String,Integer>> Minmap=new PriorityQueue<>(k, new Comparator<Map.Entry<String, Integer>>() {
@Override
public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
//判断前K次 如果频率相同时，字母的顺序排列
if (o1.getValue().compareTo(o2.getValue())==0){
return o1.getKey().compareTo(o2.getKey());
}
return o1.getValue()-o2.getValue();
}
});
//3遍历MAP
for (Map.Entry<String,Integer> entry: map.entrySet()) {
if (Minmap.size()<k){
Minmap.offer(entry);
}else {
Map.Entry<String,Integer> top=Minmap.peek();
//判断频率是否相同如果相同，比较单词小的，单词小的入堆
if (top.getValue().compareTo(entry.getValue())==0){
if (top.getKey().compareTo(entry.getKey())>0){
Minmap.poll();
Minmap.offer(entry);
}else {
if (top.getValue().compareTo(entry.getValue())<0){
Minmap.poll();
Minmap.offer(entry);
}
}
}
}
}
System.out.println(Minmap);
List<String> list=new ArrayList<>();
for (int i = 0; i <k ; i++) {
Map.Entry<String,Integer> top =Minmap.poll();
list.add(top.getKey());
}
Collections.reverse(list);
return list;
public Node copyRandomList(Node head) {
Map<Node,Node> str=new HashMap<>();
Node cur=head;
while (cur!=null){
Node val=new Node(cur.val);
str.put(cur,val);
cur=cur.next;
}
cur=head;
while (cur!=null){
str.get(cur).next=str.get(cur.next);
str.get(cur).random=str.get(cur.random);
cur=cur.next;
}
return cur;
4 搜索树
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树
class Nodest{
public int val;
public Nodest left;
public Nodest right;
public Nodest(int val){
this.val=val;
}
}
public class BinnarySearchTree {
public Nodest root=null;
//查找val是否在二叉搜索树内
public Nodest search(int key){
Nodest cur=root;
while (cur!=null){
if (cur.val>key){
cur=cur.left;
}else if (cur.val<key){
cur=cur.right;
}else {
return cur;
}
}
return null;
}
//插入新val
public boolean insort(int val){
if (root==null){
root=new Nodest(val);
return true;
}
Nodest parent=root;
Nodest cur=root;
while (cur!=null){
if (cur.val>val){
parent=cur;
cur=cur.left;
}else if (cur.val<val){
parent=cur;
cur=cur.right;
}else {
return false;
}
}
if (parent.val>val){
parent.left=new Nodest(val);
}else if (parent.val<val){
parent.right=new Nodest(val);
}
return true;
}
//删除操作
public void delete(int key){
Nodest cur=root;
Nodest parent=null;
while (cur!=null){
if (cur.val ==key){
remove(cur,parent);
break;
}else if (cur.val<key){
parent=cur;
cur=cur.right;
}else {
parent=cur;
cur=cur.left;
}
}
}
public void remove(Nodest cur,Nodest parent){
if (cur.left==null){
if (cur==root){
root=cur.right;
}else if (cur==parent.left){
cur.right=parent.left;
}else {
parent.right=cur.right;
}
}else if (cur.right==null){
if (cur==root){
root=cur.right;
}else if (cur==parent.left){
cur.left=parent.left;
}else {
parent.right=cur.left;
}
}else {
Nodest tap=cur;
Nodest ta=cur.right;
while (ta.left!=null){
tap=ta;
ta=ta.left;
}
cur.val=ta.val;
if (ta==tap.left){
tap.left=ta.right;
}else {
tap.right=ta.right;
}
}
}
}
浙公网安备 33010602011771号