算法

二分法查找：

代码块

public static boolean binarySearch(List<Integer> list, Integer matchItem) {
        int size = list.size();
        if (size == 1) {
            return list.get(0).equals(matchItem);
        } if (size == 2) {
            return list.get(0).equals(matchItem) || list.get(1).equals(matchItem);
        }
        int binaryIndex = size/2;
        Integer binaryItem = list.get(binaryIndex);
        if (binaryItem < matchItem) {
            return binarySearch(list.subList(binaryIndex+1 , size), matchItem);
        } else if (binaryItem > matchItem) {
            return binarySearch(list.subList(0 , binaryIndex), matchItem);
        } else {
            return true;
        }
    }

　

 

快速排序：

代码块

public static void quickSort(List<Integer> list, int s, int e) {
        if (s == e) {
            return;
        }
        int start = s;
        int end = e;
        Integer mark = list.get(start);
        int markindex = start;
        boolean markEnd = true;
        while (start != end){
            if (markEnd) {
                Integer endItem = list.get(end);
                if (mark <= endItem) {
                    end--;
                    continue;
                } else {
                    Integer temp = endItem;
                    list.set(end, mark);
                    list.set(markindex, temp);
                    markindex = end;
                    markEnd = false;
                    continue;
                }
            } else {
                Integer startItem = list.get(start);
                if (mark >= startItem) {
                    start++;
                    continue;
                } else {
                    Integer temp = startItem;
                    list.set(start, mark);
                    list.set(markindex, temp);
                    markindex = start;
                    markEnd = true;
                    continue;
                }
            }
        }
        if (markindex == s) {
            quickSort(list, s+1, e);
            return;
        }
        if (markindex == e) {
            quickSort(list, s, e-1);
            return;
        }
        quickSort(list, s, markindex-1);
        quickSort(list, markindex+1, e);
    }

 

 

取余数算法

//常用做法
int value = 999;
int n = 10;
int remainder = value % n;

//高效做法
int remainder = value & (n - 1)

//JDK HashMap 取key在数组中位置采用的就是位移算法
		/**
     * Implements Map.get and related methods.
     *
     * @param hash hash for key
     * @param key the key
     * @return the node, or null if none
     */
    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

　　

布隆过滤器

https://hackernoon.com/probabilistic-data-structures-bloom-filter-5374112a7832

guava实现：https://juejin.im/post/5cc5aa7ce51d456e431adac5

 

 

 

 

匹配w在数组x,y,z是否存在 如果都为1 则可能存在，可能不存在，只要有一个为0，肯定不存在；

使用场景：头条，抖音推荐视频中，如何过滤调用户已经看过的视频了？用户看过的视频通通过布隆过滤器结构保存，新的视频 如果匹配，则用户可能看过，可能没有看过；如果没有匹配上，则用户肯定没有看过，则可以把该视频推荐的用户；可能

会导致有一些视频用户没有看过也过滤掉了，但是概率低，但是推荐的视频用户是肯定没有看过的，满足是场景。