常见算法合集[java源码+持续更新中...]

一、引子

本文搜集从各种资源上搜集高频面试算法，慢慢填充...每个算法都亲测可运行，原理有注释。Talk is cheap,show me the code! 走你~

二、常见算法

2.1 判断单向链表是否有环

package study.algorithm.interview;

/**
 * 判断单向链表是否有环? <p>Q1:判断是否有环？ isCycle </> <p>Q2：环长？ count </> <p>Q3: 相遇点？ p1.data </> <p>Q4：入环点？ 头结点到入环点距离为D，入环点到相遇点距离为S1，相遇点再次回到入环点距离为S2.
 * 相遇时p1走了：D+s1,p2走了D+s1+n(s1+s2),n表示被套的圈数。 由于P2速度是P1两倍，D+s1+n(s1+s2)=2（D+s1）--》D=(n-1)(s1+s2)+s2， 即：从相遇点开始，环绕n-1圈，再次回到入环点距离。
 * 最终：只需要一个指针从头结点开始，一个指针从相遇点开始，步长都=1，这次相遇的点即为入环节点</>
 * 时间复杂度：O（n）
 * 空间复杂度：O（1）,2个指针
 *
 * @author denny
 * @date 2019/9/4 上午10:07
 */
public class LinkedListIsCycle {

    /**
     * 判断是否有环： 1.有环返回相遇点 2.无环返回空
     *
     * @param head 头结点
     * @return
     */
    private static Node isCycle(Node head) {
        Node p1 = head;
        Node p2 = head;
        // 前进次数
        int count = 0;
        while (p2 != null && p2.next != null) {
            // P1每次前进1步
            p1 = p1.next;
            // p2每次前进2步
            p2 = p2.next.next;
            count++;
            if (p1 == p2) {
                System.out.println("1.环长=速度差*前进次数=（2-1）*前进次数=count=" + count);
                System.out.println("2.相遇点=" + p1.data);
                return p1;
            }
        }
        return null;
    }

    /**
     * 获取环入口
     *
     * @param head 头结点
     * @return
     */
    private static Node getCycleIn(Node head) {
        // 是否有环
        Node touch = isCycle(head);
        Node p1 = head;

        // 有环，只需要一个指针从头结点开始，一个指针从相遇点开始，步长都=1，这次相遇的点即为入环节点
        if (touch != null) {
            while (touch != null && p1 != null) {
                touch = touch.next;
                p1 = p1.next;
                if (p1 == touch) {
                    return p1;
                }
            }
        }
        return null;
    }

    public static void main(String[] args) {
        Node node1 = new Node(5);
        Node node2 = new Node(3);
        Node node3 = new Node(7);
        Node node4 = new Node(2);
        Node node5 = new Node(6);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        node5.next = node2;
        Node in = getCycleIn(node1);
        System.out.println(in != null ? "有环返回入口：" + in.data : "无环");
    }

    /**
     * 链表节点
     */
    private static class Node {
        int data;
        Node next;

        public Node(int data) {
            this.data = data;
        }
    }

}

2.2 最小栈的实现

package study.algorithm.interview;

import java.util.Stack;

/**
 * 求最小栈：实现入栈、出栈、取最小值。
 * 时间复杂度都是O（1），最坏情况空间复杂度是O（n）
 *
 * @author denny
 * @date 2019/9/4 下午2:37
 */
public class MinStack {

    private Stack<Integer> mainStack = new Stack<>();
    private Stack<Integer> minStack = new Stack<>();

    /**
     * 入栈
     *
     * @param element
     */
    private void push(int element) {
        mainStack.push(element);
        //如果最小栈为空，或者新元素<=栈顶最小值，则入最小栈
        if (minStack.empty() || element <= minStack.peek()) {
            minStack.push(element);
        }
    }

    /**
     * 出栈
     *
     * @return
     */
    private Integer pop() {
        // 如果主栈栈顶元素和最小栈元素相等，最小栈出栈
        if (mainStack.peek().equals(minStack.peek())) {
            minStack.pop();
        }
        // 主栈出栈
        return mainStack.pop();
    }

    /**
     * 取最小值
     *
     * @return
     * @throws Exception
     */
    private Integer getMin() {
        return minStack.peek();
    }

    public static void main(String[] args) {
        MinStack stack = new MinStack();
        stack.push(3);
        stack.push(2);
        stack.push(4);
        stack.push(1);
        stack.push(5);
        //主栈：32415 最小栈：321
        System.out.println("min=" + stack.getMin());
        stack.pop();
        stack.pop();
        System.out.println("min=" + stack.getMin());
    }
}

2.3 求2个整数的最大公约数

package study.algorithm.interview;

/**
 * 求2个整数的最大公约数 <p>1.暴力枚举法：时间复杂度O(min(a,b))</> <p>2.辗转相除法（欧几里得算法）: O(log(max(a,b))),但是取模运算性能较差</> <p>3.更相减损术：避免了取模运算，但性能不稳定，最坏时间复杂度：O（max(a,b)）</>
 * <p>4.更相减损术与位移结合:避免了取模运算，算法稳定，时间复杂度O（log(max(a,b))）</>
 *
 * @author denny
 * @date 2019/9/4 下午3:22
 */
public class GreatestCommonDivisor {

    /**
     * 暴力枚举法
     *
     * @param a
     * @param b
     * @return
     */
    private static int getGCD(int a, int b) {
        int big = a > b ? a : b;
        int small = a < b ? a : b;
        // 能整除，直接返回
        if (big % small == 0) {
            return small;
        }
        // 从较小整数的一半开始~1，试图找到一个整数i，能被a和b同时整除。
        for (int i = small / 2; i > 1; i--) {
            if (small % i == 0 && big % i == 0) {
                return i;
            }
        }
        return 1;
    }

    /**
     * 辗转相除法(欧几里得算法):两个正整数a>b,最大公约数=a/b的余数c和b之间的最大公约数，一直到可以整除为止
     *
     * @param a
     * @param b
     * @return
     */
    private static int getGCD2(int a, int b) {
        int big = a > b ? a : b;
        int small = a < b ? a : b;

        // 能整除，直接返回
        if (big % small == 0) {
            return small;
        }

        return getGCD2(big % small, small);
    }

    /**
     * 更相减损术：两个正整数a>b,最大公约数=a-b和b之间的最大公约数,一直到两个数相等为止。
     *
     * @param a
     * @param b
     * @return
     */
    private static int getGCD3(int a, int b) {
        if (a == b) {
            return a;
        }

        int big = a > b ? a : b;
        int small = a < b ? a : b;

        return getGCD3(big - small, small);
    }

    /**
     * 更相减损术结合位移
     *
     * @param a
     * @param b
     * @return
     */
    private static int getGCD4(int a, int b) {
        if (a == b) {
            return a;
        }
        // 都是偶数,gcd(a,b)=2*gcd(a/2,b/2)=gcd(a>>1,b>>1)<<1
        if ((a & 1) == 0 && (b & 1) == 0) {
            return getGCD4(a >> 1, b >> 1) << 1;
            // a是偶数，b是奇数,gcd(a,b)=gcd(a/2,b)=gcd(a>>1,b)
        } else if ((a & 1) == 0 && (b & 1) == 1) {
            return getGCD4(a >> 1, b);
            // a是奇数，b是偶数
        } else if ((a & 1) == 1 && (b & 1) == 0) {
            return getGCD4(a, b >> 1);
            // 都是奇数
        } else {
            int big = a > b ? a : b;
            int small = a < b ? a : b;
            return getGCD4(big - small, small);
        }

    }

    public static void main(String[] args) {
        System.out.println("最大公约数=" + getGCD4(99, 21));
    }
}

2.4 判断是否是2的整数次幂

package study.algorithm.interview;

/**
 * 判断是否是2的整数次幂：时间复杂度
 * 时间复杂度是O（1）
 *
 * @author denny
 * @date 2019/9/4 下午5:18
 */
public class PowerOf2 {

    /**
     * 判断是否是2的整数次幂： 2的整数次幂转换成二进制（1+n个0）& 二进制-1（n个1）=0
     * @param num
     * @param a
     * @return boolean
     * @author denny
     * @date 2019/9/5 上午11:14
     */
    private static boolean isPowerOf2(int num, int a) {
        return (num & (num - 1)) == 0;
    }

    public static void main(String[] args) {
        System.out.println("是否2的整数次幂=" + isPowerOf2(16, 1));
    }
}

2.5 无序数组排序后的最大相邻差

package study.algorithm.interview;

/**
 * 无序数组排序后的最大相邻差： 使用桶排序思想，每个桶元素遍历一遍即可，不需要再排序，
 * 时间复杂度O（n）
 *
 * @author denny
 * @date 2019/9/4 下午5:38
 */
public class MaxSortedDistance {

    private static class Bucket {
        Integer max;
        Integer min;
    }

    private static int getMaxSortedDistance(int[] array) {
        //1.求最大值最小值
        int max = array[0];
        int min = array[0];
        for (int i = 0; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
            if (array[i] < min) {
                min = array[i];
            }
        }
        int d = max - min;
        // 如果max=min,所有元素都相等，直接返回0
        if (d == 0) {
            return 0;
        }

        // 2. 初始化桶
        int bucketNum = array.length;
        Bucket[] buckets = new Bucket[bucketNum];
        for (int i = 0; i < bucketNum; i++) {
            buckets[i] = new Bucket();
        }
        // 3.遍历原始数组，确定每个桶的最大值最小值
        for (int i = 0; i < array.length; i++) {
            // 桶下标=当前元素偏移量/跨度  跨度=总偏移量/桶数-1
            int index = (array[i] - min) / (d / (bucketNum - 1));
            if (buckets[index].min == null || buckets[index].min > array[i]) {
                buckets[index].min = array[i];
            }
            if (buckets[index].max == null || buckets[index].max > array[i]) {
                buckets[index].max = array[i];
            }
        }
        // 4.遍历桶，找到最大差值
        int leftMax = buckets[0].max;
        int maxDistance = 0;
        // 从第二个桶开始计算
        for (int i = 1; i < buckets.length; i++) {
            if (buckets[i].min == null) {
                continue;
            }
            // 桶最大差值=右边最小值-左边最大值
            if (buckets[i].min - leftMax > maxDistance) {
                maxDistance = buckets[i].min - leftMax;
            }
            // 更新左边最大值为当前桶max
            leftMax = buckets[i].max;
        }
        return maxDistance;
    }

    public static void main(String[] args) {
        int[] array = new int[] {3, 4, 5, 9, 5, 6, 8, 1, 2};
        System.out.println(getMaxSortedDistance(array));
    }
}

2.6 栈实现队列

package study.algorithm.interview;

import java.util.Stack;

/**
 * 栈实现队列：
 * 时间复杂度：入队O(1) 出队O(1)（均摊时间复杂度）
 *
 * @author denny
 * @date 2019/9/5 上午11:14
 */
public class StackQueue {
    // 入队
    private Stack<Integer> stackIn = new Stack<>();
    // 出队
    private Stack<Integer> stackOut = new Stack<>();

    /**
     * 入队：直接入栈
     *
     * @param element
     */
    private void enQueue(int element) {
        stackIn.push(element);
    }

    /**
     * 出队
     *
     * @return
     */
    private Integer deQueue() {
        // 出队为空
        if (stackOut.isEmpty()) {
            // 如果入队为空，直接返回空
            if (stackIn.isEmpty()) {
                return null;
            }
            // 入队不为空，IN元素全部转移到OUT
            transfer();
        }
        // 出队不为空，直接弹出
        return stackOut.pop();
    }

    /**
     * 入队元素转到出队
     */
    private void transfer() {
        while (!stackIn.isEmpty()) {
            stackOut.push(stackIn.pop());
        }
    }

    public static void main(String[] args) {
        StackQueue stackQueue = new StackQueue();
        stackQueue.enQueue(1);
        stackQueue.enQueue(2);
        stackQueue.enQueue(3);
        System.out.println("出队：" + stackQueue.deQueue());
        System.out.println("出队：" + stackQueue.deQueue());
        stackQueue.enQueue(4);
        System.out.println("出队：" + stackQueue.deQueue());
        System.out.println("出队：" + stackQueue.deQueue());

    }

}

2.7 寻找全排列的下一个数

package study.algorithm.interview;

import com.alibaba.fastjson.JSONObject;

import java.util.Arrays;

/**
 * 寻找全排列的下一个数，又叫字典序算法，时间复杂度为O（n） 全排列：12345->54321
 * 核心原理：
 * 1.最后2位交换行不行？不行再最后3位.....从右往左找相邻array[index]>array[index-1] ，
 * 2.index-1和逆序列，从右往左中第一个比它大的值，交换 因为越往左边，交换后数越大，只有第一个才满足相邻。
 * 例如 12345-》12354   12354-第一步找到54数列，交换3和4-》12453--》12435
 * 12765->15762->15267
 * 时间复杂度：O（n）
 *
 * @author denny
 * @date 2019/9/5 下午2:18
 */
public class FindNextSortedNumber {

    private static int[] findNextSortedNumber(int[] numbers) {
        // 1.找到置换边界：从后向前查看逆序区域，找到逆序区域的第一位
        int index = findTransferPoint(numbers);
        System.out.println("index=" + index);
        // 整个数组逆序，没有更大的数了
        if (index == 0) {
            return null;
        }

        // copy一个新的数组，避免修改入参
        int[] numbersCopy = Arrays.copyOf(numbers, numbers.length);
        // 2.把逆序区域的前一位和逆序区域中大于它的最小数交换位置
        exchangHead(numbersCopy, index);

        // 3.把原来的逆序转为顺序
        reverse(numbersCopy, index);
        return numbersCopy;
    }

    /**
     * 找到置换边界
     *
     * @param numbers
     * @return
     */
    private static int findTransferPoint(int[] numbers) {
        for (int i = numbers.length - 1; i > 0; i--) {
            if (numbers[i] > numbers[i - 1]) {
                return i;
            }
        }
        return 0;
    }

    /**
     * 把逆序区域的前一位和逆序区域中大于它的最小数交换位置
     *
     * @param numbers
     * @param index
     * @return
     */
    private static int[] exchangHead(int[] numbers, int index) {
        // 逆序区域前一位
        int head = numbers[index - 1];
        // 从后往前遍历
        for (int i = numbers.length - 1; i > 0; i--) {
            // 找到第一个大于head的数，和head交换。因为是逆序区域，第一个数就是最小数，所以找到第一个大于head的数，就是比head大的数中的最小数
            if (head < numbers[i]) {
                numbers[index - 1] = numbers[i];
                numbers[i] = head;
                break;
            }
        }
        return numbers;
    }

    /**
     * 逆序
     *
     * @param num
     * @param index
     * @return
     */
    private static int[] reverse(int[] num, int index) {
        for (int i = index, j = num.length - 1; i < j; i++, j--) {
            int temp = num[i];
            num[i] = num[j];
            num[j] = temp;
        }
        return num;
    }

    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 5, 4};

        numbers = findNextSortedNumber(numbers);
        System.out.println(JSONObject.toJSONString(numbers));

    }
}

2.8 删除整数的k个数字，使得留下的数字最小

package study.algorithm.interview;

/**
 * 删除整数的k个数字，使得留下的数字最小
 * 时间复杂度：O（n）
 *
 * @author denny
 * @date 2019/9/5 下午4:43
 */
public class removeKDigits {

    /**
     * 删除整数的k个数字，使得留下的数字最小
     *
     * @param num
     * @param k
     * @return
     */
    private static String removeKDigits(String num, int k) {
        // 新长度
        int newLength = num.length() - k;
        // 创建栈，接收所有数字
        char[] stack = new char[num.length()];
        int top = 0;
        // 遍历，一开始先入栈第一个数字。第一轮循环先给stack入栈一个数，且top++,往后循环，top-1才是栈顶
        for (int i = 0; i < num.length(); ++i) {
            // 当前数字
            char c = num.charAt(i);
            // 当栈顶数字 > 当前数字时，栈顶数字出栈，只要没删除够K个就一直往左边删除
            while (top > 0 && stack[top - 1] > c && k > 0) {
                // 这里top-1，就是出栈，忽略top
                top -= 1;
                k -= 1;
            }
            // 后一个数字入栈
            stack[top++] = c;
        }
        // 找到栈中第一个非0数字的位置，以此构建新的字符串0000123->123
        int offset = 0;
        while (offset < newLength && stack[offset] == '0') {
            offset++;
        }
        return offset == newLength ? "0" : new String(stack, offset, newLength - offset);
    }

    public static void main(String[] args) {
        System.out.println(removeKDigits("1593212", 3));
        System.out.println(removeKDigits("10", 2));
    }
}

2.9 大整数相加求和

package study.algorithm.interview;

/**
 * 大整数相加求和：可优化点：int -21-21亿，9位数妥妥的计算。拆分大整数每9位数一个元素，分别求和。效率可极大提升。
 * 时间复杂度：O（n）
 *
 * @author denny
 * @date 2019/9/5 下午5:50
 */
public class BigNumberSum {
    private static String bigNumberSum(String bigA, String bigB) {
        // 1.把2个大整数用数组逆序存储，数组长度等于较大整数位数+1
        int maxLength = bigA.length() > bigB.length() ? bigA.length() : bigB.length();
        int[] arrayA = new int[maxLength + 1];
        for (int i = 0; i < bigA.length(); i++) {
            arrayA[i] = bigA.charAt(bigA.length() - 1 - i) - '0';
        }
        int[] arrayB = new int[maxLength + 1];
        for (int i = 0; i < bigB.length(); i++) {
            arrayB[i] = bigB.charAt(bigB.length() - 1 - i) - '0';
        }
        // 2. 构建result数组
        int[] result = new int[maxLength + 1];

        // 3. 遍历数组，按位相加
        for (int i = 0; i < result.length; i++) {
            int temp = result[i];
            temp += arrayA[i];
            temp += arrayB[i];
            //是否进位
            if (temp >= 10) {
                temp = temp - 10;
                result[i + 1] = 1;
            }
            result[i] = temp;
        }

        //4.转成数组
        StringBuilder stringBuilder = new StringBuilder();
        // 是否找到大整数的最高有效位
        boolean findFirst = false;
        // 倒序遍历，即从最高位开始找非零数，找到一个就可以开始append了
        for (int i = result.length - 1; i >= 0; i--) {
            if (!findFirst) {
                if (result[i] == 0) {
                    continue;
                }
                findFirst = true;
            }
            stringBuilder.append(result[i]);
        }
        return stringBuilder.toString();

    }

    public static void main(String[] args) {
        System.out.println(bigNumberSum("4534647452342423", "986568568789664"));
    }
}

2.10 求解金矿问题

package study.algorithm.interview;

/**
 * 求金矿最优收益（动态规划）
 * 时间复杂度：O(n*w)n为人数 w为金矿数
 * 空间复杂度：O（n）
 *
 * @author denny
 * @date 2019/9/6 下午4:21
 */
public class GetMaxGold {

    /**
     * 求金矿最优收益
     *
     * @param w 工人数量
     * @param p 金矿开采所需的工人数量
     * @param g 金矿金子储藏量
     * @return
     */
    private static int getMaxGold(int w, int[] p, int[] g) {
        // 构造数组
        int[] results = new int[w + 1];
        // 遍历所有金矿
        for (int i = 1; i < g.length; i++) {
            // 遍历人数：w->1
            for (int j = w; j >= 1; j--) {
                // 如果人数够这个金矿所需的人数，i-1是因为下标从0开始
                if (j >= p[i - 1]) {
                    // 当前人数，最大收益=Max(采用当前矿，不采用当前矿)
                    results[j] = Math.max(results[j], results[j - p[i - 1]] + g[i - 1]);
                }
            }
        }
        // 返回最后一个格子的值
        return results[w];
    }

    public static void main(String[] args) {
        System.out.println(getMaxGold(10, new int[] {5, 5, 3, 4, 3}, new int[] {400, 500, 200, 300, 350}));
    }
}

2.11 寻找缺失的整数

package study.algorithm.interview;

import java.util.ArrayList;
import java.util.List;

/**
 * 无序数组里有99个不重复整数，1-100，缺少一个。如何找到这个缺失的整数？
 *
 * @author denny
 * @date 2019/9/9 上午11:05
 */
public class FindLostNum {
    /**
     * 直接求和然后遍历减去全部元素即可 时间复杂度：O（1） 空间复杂度：
     *
     * @param array
     * @return
     */
    private static int findLostNum(Integer[] array) {
        // 1-100求和
        int sum = ((1 + 100) * 100) / 2;
        for (int a : array) {
            sum -= a;
        }
        return sum;
    }

    /**
     * 一个无序数组里有若干个正整数，范围是1~100，其中98个整数都出现了偶数次。只有2个整数出现了奇数次，求奇数次整数？ 利用异或运算的"相同为0，不同为1"，出现偶数次的偶数异或变0，最后只有奇数次的整数留下。 时间复杂度：O(n) 空间复杂度：O(1)
     *
     * @param array
     * @return
     */
    private static int[] findLostNum2(Integer[] array) {
        // 存储2个出现奇数次的整数
        int result[] = new int[2];
        // 第一次进行整体异或运算
        int xorResult = 0;
        for (int i = 0; i < array.length; i++) {
            xorResult ^= array[i];
        }
        //确定2个整数的不同位，以此来做分组
        int separtor = 1;
        //xorResult=0000 0110B ,A^B=>倒数第二位=1即，倒数第二位不同。一个是0一个是1.=》原数组可拆分成2个，一组倒数第二位是0，一组是1。& 01 、10 倒数第二位为1，separtor左移一位
        while (0 == (xorResult & separtor)) {
            separtor <<= 1;
        }
        //第二次分组进行异或运算
        for (int i = 0; i < array.length; i++) {
            // 按位与 10 ==0一组，一直异或计算，就是那个奇数次整数（因为偶数次整数，异或后=1相互抵消掉了）
            if (0 == (array[i] & separtor)) {
                result[0] ^= array[i];
                // 按位与 10 !=0另一组，一直异或计算，就是那个奇数次整数
            } else {
                result[1] ^= array[i];
            }
        }
        return result;
    }

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        // 除了85，其它赋值
        for (int i = 0; i < 100; i++) {
            list.add(i + 1);
        }
        list.remove(10);
        System.out.println("缺失的数=" + findLostNum(list.toArray(new Integer[99])));

        Integer[] array = new Integer[] {4, 1, 2, 2, 5, 1, 4, 3};
        int[] result = findLostNum2(array);
        System.out.println(result[0] + "," + result[1]);
    }
}

2.12 位图Bitmap的实现

package study.algorithm.interview;

/**
 * 实现一个位图BitMap（海量数据查找、去重存储）
 *
 * @author denny
 * @date 2019/9/9 下午4:04
 */
public class MyBitMap {
    // 64位二进制数据
    private long[] words;
    // Bitmap的位数
    private int size;

    public MyBitMap(int size) {
        this.size = size;
        this.words = new long[getWordIndex(size - 1) + 1];
    }

    /**
     * 判断某一位的状态
     *
     * @param index
     * @return
     */
    public boolean getBit(int index) {
        if (index < 0 || index > size - 1) {
            throw new IndexOutOfBoundsException("index 无效！");
        }
        int wordIndex = getWordIndex(index);
        // 位与:都是1才是1，否则是0.   index对应值为1返回true
        return (words[wordIndex] & (1L << index)) != 0;
    }

    /**
     * 设置bitmap 在index处为1（true）
     *
     * @param index
     */
    public void setBit(int index) {
        if (index < 0 || index > size - 1) {
            throw new IndexOutOfBoundsException("index 无效！");
        }
        int wordIndex = getWordIndex(index);
        // 位或：只要有一个1就是1，2个0才是0 ，因为1L << index就是1，所以|=就是在index位置，赋值1
        words[wordIndex] |= (1L << index);
    }

    /**
     * 定位Bitmap某一位对应的word
     *
     * @param index
     * @return
     */
    private int getWordIndex(int index) {
        // 右移6位即除以64
        return index >> 6;
    }

    public static void main(String[] args) {
        MyBitMap bitMap = new MyBitMap(128);
        bitMap.setBit(126);
        bitMap.setBit(88);
        System.out.println(bitMap.getBit(126));
        System.out.println(bitMap.getBit(88));
    }

}

2.13 LRU算法的实现

package study.algorithm.interview;

import study.algorithm.base.Node;

import java.util.HashMap;

/**
 * LRU（Least Recently Used）最近最少使用算法(非线程安全) head（最少使用）<-->*<-->*<-->end(最近使用) 注：JDK中LinkedHashMap实现了LRU哈希链表，构造方法：LinkedHashMap(int
 * initialCapacity容量,float
 * loadFactor负载,boolean accessOrder是否LRU访问顺序，true代表LRU)
 *
 * @author denny
 * @date 2019/9/9 下午6:01
 */
public class LRUCache {

    // 双向链表头节点（最后时间）
    private Node head;
    // 双向链表尾节点（最早时间）
    private Node end;
    // 缓存储存上限
    private int limit;
    // 无序key-value映射。只有put操作才会写hashMap
    private HashMap<String, Node> hashMap;

    public LRUCache(int limit) {
        this.limit = limit;
        hashMap = new HashMap<>();
    }

    /**
     * 插入
     *
     * @param key
     * @param value
     */
    public void put(String key, String value) {
        Node node = hashMap.get(key);
        // key 不存在，插入新节点
        if (node == null) {
            // 达到容量上限
            if (hashMap.size() >= limit) {
                // 移除头结点
                String oldKey = removeNode(head);
                //同步hashMap
                hashMap.remove(oldKey);
            }
            // 构造节点
            node = new Node(key, value);
            // 添加到尾节点
            addNodeToEnd(node);
            // 同步hashmap
            hashMap.put(key, node);
        } else {
            // key存在，刷新key-value
            node.value = value;
            // 刷新被访问节点的位置
            refreshNode(node);
        }
    }

    /**
     * 获取
     *
     * @param key
     * @return
     */
    public String get(String key) {
        Node node = hashMap.get(key);
        if (node == null) {
            return null;
        }
        //刷新节点（提升该节点为尾结点，即最新使用节点）
        refreshNode(node);
        return node.value;
    }

    /**
     * 刷新被访问节点的位置
     *
     * @param node
     */
    private void refreshNode(Node node) {
        // 如果访问的是尾结点，则无须移动节点
        if (node == end) {
            return;
        }
        //移除节点
        removeNode(node);
        //尾部插入节点,代表最新使用
        addNodeToEnd(node);
    }

    /**
     * 移除节点
     *
     * @param node
     * @return
     */
    private String removeNode(Node node) {
        // 如果就一个节点，把头尾节点置空
        if (node == head && node == end) {
            head = null;
            end = null;
        } else if (node == end) {
            // 移除尾结点
            end = end.next;
            end.next = null;
        } else if (node == head) {
            //移除头结点
            head = head.next;
            head.pre = null;
        } else {
            // 移除中间节点
            node.pre.next = node.next;
            node.next.pre = node.pre;
        }
        return node.key;
    }

    /**
     * 尾部插入节点
     *
     * @param node
     */
    private void addNodeToEnd(Node node) {
        if (head == null && end == null) {
            head = node;
            end = node;
        }
        // 添加节点
        end.next = node;
        // pre=之前的end
        node.pre = end;
        // node next不存在
        node.next = null;
        // 新节点为尾结点
        end = node;
    }

    public static void printLRUCache(LRUCache lruCache) {
        for (Node node = lruCache.head; node != null; node = node.next) {
            System.out.println("key=" + node.key + ",value=" + node.value);
        }
        System.out.println("===========================");
    }

    public static void main(String[] args) {
        // 构造一个容量为5的LRU缓存
        LRUCache lruCache = new LRUCache(5);
        lruCache.put("001", "value1");
        lruCache.put("002", "value2");
        lruCache.put("003", "value3");
        lruCache.put("004", "value4");
        lruCache.put("005", "value5");
        // 打印
        System.out.println("1. 插入 5个节点");
        printLRUCache(lruCache);

        // 002到尾结点
        lruCache.get("002");
        // 打印
        System.out.println("2. 002到尾结点");
        printLRUCache(lruCache);

        // 004到尾结点，且value更新
        lruCache.put("004", "value4更新");
        // 打印
        System.out.println("3. 004到尾结点，且value更新");
        printLRUCache(lruCache);

        // 001倍移除，006在尾结点
        lruCache.put("006", "value6");
        // 打印
        System.out.println("4. 超长，001倍移除，006在尾结点");
        printLRUCache(lruCache);
    }

}

2.14 A*寻路算法

package study.algorithm.interview;

import java.util.ArrayList;
import java.util.List;

/**
 *  A*寻路算法
 * @author denny
 * @date 2019/9/10 下午5:28
 */
public class AStarSearch {

    /**
     * 迷宫地图，1代表障碍物不可走 0代表可走
     */
    private static final int[][] MAZE={
        {0,0,0,0,0,0,0},
        {0,0,0,1,0,0,0},
        {0,0,0,1,0,0,0},
        {0,0,0,1,0,0,0},
        {0,0,0,0,0,0,0}
    };

    static class Grid{
        // X轴坐标
        public int x;
        // Y轴坐标
        public int y;
        // 从起点走到当前格子的成本（一开始，当前格子=起点，往后走一步，下一个格子就是当前格子）
        public int g;
        // 在不考虑障碍情况下，从当前格子走到目标格子的步数
        public int h;
        // f=g+h，从起点到当前格子，再从当前格子走到目标格子的总步数
        public int f;
        public Grid parent;

        public Grid(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public void initGrid(Grid parent,Grid end){
            //标记父格子，用来记录轨迹
            this.parent=parent;
            if(parent!=null){
                this.g = parent.g+1;
            }else {
                this.g=1;
            }
            this.h = Math.abs(this.x-end.x)+Math.abs(this.y-end.y);
            this.f = this.g+this.h;
        }
    }

    /**
     * A*寻路主逻辑
     * @param start 起点
     * @param end 终点
     * @return
     */
    public static Grid aStarSearch(Grid start,Grid end){
        // 可走list
        List<Grid> openList = new ArrayList<>();
        // 已走list
        List<Grid> closeList = new ArrayList<>();
        // 把起点加入openList
        openList.add(start);
        // 可走list不为空，一直循环
        while(openList.size()>0){
            // 在openList中查找F值最小的节点，将其作为当前格子节点
            Grid currentGrid = findMinGird(openList);
            // 将选中格子从openList中移除
            openList.remove(currentGrid);
            // 将选中格子塞进closeList
            closeList.add(currentGrid);
            // 找到所有邻近节点
            List<Grid> neighbors = findNeighbors(currentGrid,openList,closeList);
            for(Grid grid:neighbors){
                // 邻近节点不在可走list中，标记"父节点"，GHF，并放入可走格子list
                if(!openList.contains(grid)){
                    grid.initGrid(currentGrid,end);
                    openList.add(grid);
                }
            }
            // 如果终点在openList中，直接返回终点格子
            for(Grid grid:openList){
                if((grid.x==end.x) && (grid.y==end.y)){
                    return grid;
                }
            }
        }
        // 找不到路径，终点不可达
        return null;
    }

    /**
     * 求当前可走格子的最小f的格子
     * @param openList
     * @return
     */
    private static Grid findMinGird(List<Grid> openList){
        Grid tempGrid = openList.get(0);
        // 遍历求最小f的Grid
        for (Grid grid : openList){
            if(grid.f< tempGrid.f){
                tempGrid =grid;
            }
        }
        return tempGrid;
    }

    /**
     * 查找可以走的格子集合
     * @param grid 当前格子
     * @param openList 可走list
     * @param closeList 已走list
     * @return
     */
    private static ArrayList<Grid> findNeighbors(Grid grid,List<Grid> openList,List<Grid> closeList){
        ArrayList<Grid> grids = new ArrayList<>();
        if(isValidGrid(grid.x,grid.y-1,openList,closeList)){
            grids.add(new Grid(grid.x,grid.y-1));
        }
        if(isValidGrid(grid.x,grid.y+1,openList,closeList)){
            grids.add(new Grid(grid.x,grid.y+1));
        }
        if(isValidGrid(grid.x-1,grid.y,openList,closeList)){
            grids.add(new Grid(grid.x-1,grid.y));
        }
        if(isValidGrid(grid.x+1,grid.y,openList,closeList)){
            grids.add(new Grid(grid.x+1,grid.y));
        }
        return grids;
    }

    /**
     * 非法校验
     * @param x
     * @param y
     * @param openList
     * @param closeList
     * @return
     */
    private static boolean isValidGrid(int x,int y,List<Grid> openList,List<Grid> closeList){
        // 坐标有效校验
        if(x<0 || x>=MAZE.length || y<0 || y>=MAZE[0].length){
            return false;
        }
        // 存在障碍物，非法
        if(MAZE[x][y]==1){
            return false;
        }
        // 已经在openList中，已判断过
        if(containGrid(openList,x,y)){
            return false;
        }
        // 已经在closeList中,已走过
        if(containGrid(closeList,x,y)){
            return false;
        }
        return true;
    }

    /**
     * 是否包含坐标对应的格子
     * @param grids
     * @param x
     * @param y
     * @return
     */
    private static boolean containGrid(List<Grid> grids,int x,int y){
        for(Grid grid:grids){
            if((grid.x==x) && (grid.y==y)){
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Grid start = new Grid(2,1);
        Grid end = new Grid(2,5);
        // 搜索迷宫终点
        Grid resultGrid = aStarSearch(start,end);
        //回溯迷宫路径
        List<Grid> path = new ArrayList<>();
        // 追溯parent
        while(resultGrid!=null){
            path.add(new Grid(resultGrid.x,resultGrid.y));
            resultGrid =resultGrid.parent;
        }
        // 行遍历
        for(int i=0;i<MAZE.length;i++){
            // 列遍历
            for(int j=0;j<MAZE[0].length;j++){
                // 路径打印
                if(containGrid(path,i,j)){
                    System.out.print("*,");
                } else {
                    System.out.print(MAZE[i][j]+",");
                }
            }
            System.out.println();
        }



    }


}

 2.15 红包拆分算法

package study.algorithm.interview;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

/**
 * 红包拆分算法
 * 要求：
 * 1.每个人至少抢到一分钱。
 * 2.所有人抢到金额之和等于红包金额，不能超过，也不能少于。
 * 3.要保证所有人抢到金额的几率相等。
 *
 * @author denny
 * @date 2019/9/11 上午10:37
 */
public class RedPackage {

    /**
     * 拆分红包：二分均值法（每次抢红包的平均值是相等的）
     * 注：除最后一个红包外，其它红包<剩余人均金额的2倍，不算完全自由随机抢红包
     * @param totalAMount    总金额，单位：分
     * @param totalPeopleNum 总人数
     * @return
     */
    public static List<Integer> divideRedPackage(Integer totalAMount, Integer totalPeopleNum) {
        List<Integer> amountList = new ArrayList<>();
        // 余额
        Integer restAmount = totalAMount;
        // 没抢人数
        Integer restPeopleNum = totalPeopleNum;
        Random random = new Random();
        // 遍历totalPeopleNum-1遍，最后一个人直接把余下的红包都给他
        for (int i = 0; i < totalPeopleNum - 1; i++) {
            // [1,剩余人均金额的2倍-1]
            int amount = random.nextInt(restAmount / restPeopleNum * 2 - 1) + 1;
            restAmount -= amount;
            restPeopleNum--;
            amountList.add(amount);
        }
        // 最后一个人，余下的红包都给他
        amountList.add(restAmount);
        return amountList;
    }

    /**
     * 线段切割法：红包金额随机性好 1.当随机切割点出现重复时，再继续随机一个
     *
     * @param totalAmount
     * @param totalPeopleNum
     * @return
     */
    public static List<Integer> divideRedPackage2(Integer totalAmount, Integer totalPeopleNum) {
        // 切割点list
        List<Integer> indexList = new ArrayList<>();
        // 红包list
        List<Integer> amountList = new ArrayList<>();
        Random random = new Random();

        // 构造n-1个切割点
        while (indexList.size() <= totalPeopleNum - 1) {
            // 总金额随机+1分
            int i = random.nextInt(totalAmount - 1) + 1;
            // i不在list中，非重复切割添加到集合
            if (indexList.indexOf(i) < 0) {
                indexList.add(i);
            }
        }
        // 排序.升序排列，从小到大，刚好n-1个切割点把总金额切割成n份。
        Collections.sort(indexList);
        // 上一次index
        int flag = 0;
        // 红包之和
        int fl = 0;
        // 遍历全部切割点
        for (int i = 0; i < indexList.size(); i++) {
            // 当前红包=index-上一次index
            int temp = indexList.get(i) - flag;
            // 记录index
            flag = indexList.get(i);
            // 求和
            fl += temp;
            // 当前红包添加进list
            amountList.add(temp);
        }
        //最后一个红包=总金额-已发红包之和
        amountList.add(totalAmount - fl);
        return amountList;
    }

    public static void main(String[] args) {
        //1.=====二分均值法======
        System.out.println("========二分均值法===========");
        // 把10元红包拆分给10个人
        List<Integer> amountList = divideRedPackage(1000, 10);
        for (Integer amount : amountList) {
            System.out.println("抢到金额：" + new BigDecimal(amount).divide(new BigDecimal(100)));
        }

        System.out.println("===================");
        //2.=====线段切割法======
        System.out.println("========线段切割法===========");
        List<Integer> amountList2 = divideRedPackage2(1000, 10);
        BigDecimal total = BigDecimal.ZERO;
        for (Integer amount : amountList2) {
            total = total.add(new BigDecimal(amount));
            System.out.println("抢到金额：" + new BigDecimal(amount).divide(new BigDecimal(100)));
        }
        System.out.println("总金额=" + total + "分");
    }


}

=====参考=====

书籍：《漫画算法》