其他分享
首页 > 其他分享> > Map和Set (搜索树)

Map和Set (搜索树)

作者:互联网

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;
          }

        }
    }
}

 

标签:Map,Set,cur,val,Nodest,搜索,Key,public
来源: https://www.cnblogs.com/lbwboke/p/16678395.html