《高性能mysql》 调优学习笔记

前言：

该学学sql调优了 索引这些之前都没有用过 看过下面这个博客后 发现数据结构真强大！ 计划再把b站课看完

正文

https://blog.youkuaiyun.com/u013967628/article/details/84305511?ops_request_misc=&request_id=&biz_id=102&utm_term=btree%E7%B4%A2%E5%BC%95%E7%9A%84%E6%A6%82%E5%BF%B5%E5%92%8C%E5%BA%94%E7%94%A8&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduweb~default-3-84305511.first_rank_v2_pc_rank_v29&spm=1018.2226.3001.4187

b站课：
https://www.bilibili.com/video/BV1AE41117R5?from=search&seid=2603327896783915882&spm_id_from=333.337.0.0
**正文笔记：

红黑树：

B+数 横向扩展

引擎：







因为只有主索引树，别的辅助数是为了找到主键再去主数找，节省磁盘空间

索引底层算法：

b+数没磁盘io吗
logn





（为什么13去根节点了？？？？）
b树：（一个节点在磁盘的一页 减少磁盘io且层数少了些相对红黑树）

B+树（数据只存储在叶子节点 且双向链表）（父节点上要包括各个字节点最大值）



hashmap底层：

hashmap手写实例：

package 二叉树;

import java.util.Collection;
import java.util.Map;
import java.util.Set;

public class HashMap<K,V> implements Map<K,V> {
    private Entry<K,V>[] table=null;
    private int size=0;
    public HashMap(){
        table=new Entry[16];
    }
    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public boolean containsKey(Object key) {
        return false;
    }

    @Override
    public boolean containsValue(Object value) {
        return false;
    }

    @Override
    public V get(Object key) {
        if(size==0){
            return null;
        }
        int index=hash((K) key);
//            Entry entry=table[index];
//            return (V) entry.getValue(); //没有发生hash存储位置碰撞 这样没用到链表

        Entry entry = getEntry((K)key,index);


        return entry==null?null:(V)entry.getValue();
    }

    private Entry<K,V>getEntry(K k,int index) {
        for (Entry<K,V> e = table[index]; e!=null; e=e.next){
            if(e.hash==index&&(k==e.getKey()||k.equals(e.getKey()))){
                return e;
            }

        }
        return null;
    }


    @Override
    public V put(K key, V value) {
        int index=hash(key);
        Entry entry=table[index];
        if(entry==null){
            table[index]=new Entry<>(key,value,index,null);
            size++;

        }else {
            table[index]=new Entry<>(key,value,index,entry);
        }
        return table[index].getValue();
    }
    private int hash(K k){
        int index=k.hashCode()%(15);
        return Math.abs(index);
    }
    @Override
    public V remove(Object key) {
        return null;
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> m) {

    }

    @Override
    public void clear() {

    }

    @Override
    public Set<K> keySet() {
        return null;
    }

    @Override
    public Collection<V> values() {
        return null;
    }

    @Override
    public Set<Map.Entry<K, V>> entrySet() {
        return null;
    }


    class Entry<K,V> implements Map.Entry<K,V>{
        private K k;
        private V v;
        int hash;
        Entry<K,V> next;

        public Entry(K k, V v, int hash, Entry<K, V> next) {
            this.k = k;
            this.v = v;
            this.hash = hash;
            this.next = next;
        }

        @Override
        public K getKey() {
            return k;
        }

        @Override
        public V getValue() {
            return v;
        }

        @Override
        public V setValue(V value) {
            return null;
        }
    }

    public static void main(String[] args) {
        HashMap<Object,Object> hashMap=new HashMap<>();
        hashMap.put("monkey","123");
        System.out.println(hashMap.get("monkey"));
    }
}
//class test {
//    public static void main(String[] args) {
//        HashMap<Object,Object> hashMap=new HashMap<>();
//        hashMap.put("monkey","123");
//        System.out.println(hashMap.get("monkey"));
//    }
//}