诸神缄默不语-个人CSDN博文目录

哦这是我三年前写的，我现在Java语法都快忘光了……
反正之前的博文也发一下好了。这个因为我当年是用有道云笔记而不是直接用CSDN编辑器写的，所以后面有些内容写乱了，因为我现在猛的一看有点看不懂，所以……等我过段时间看懂了再回来把排版重新改一下，酱。

文章目录

Chapter1：算法与数据结构常识
Chapter2：线性数据结构
Chapter3：树
Chapter4：排序算法
- 1. 冒泡排序
- 2. 快速排序
- 3. 堆排序
- 4. 计数排序
- - 4.1 原始版与优化step1
  - 4.2 优化step2
- 5. 桶排序
Chapter5：面试中的算法
- 1. 如何判断链表有环
- - 1.1 方法一：暴力遍历
  - 1.2 方法二：哈希表
  - 1.3 方法三：两个指针
  - 1.4 扩展问题：环的长度
  - 1.5 扩展问题：出入环节点
- 2. 最小栈
- - 2.1 有问题的方法：把栈中的最小元素下标暂存起来
  - 2.2 方法：存储栈中曾经的最小值
- 3. 最大公约数
- - 3.1 方法一：暴力枚举法
  - 3.2 方法二：辗转相除法/欧几里得算法
  - 3.3 方法三：辗转相减法/更相减损法
  - 3.4 方法四：移位运算
- 4. 2的整数次幂
- - 4.1 方法一：暴力枚举法
  - 4.2 方法二
- 5. 无序数组排序后的最大相邻差
- - 5.1 方法一：排序后求解
  - 5.2 方法二：利用计数排序的思想
  - 5.3 方法三：利用桶排序的思想
- 6. 用栈实现队列
- 7. 寻找全排列的下一个数
- 8. 删去k个数字后的最小值
- - 8.1 性能不好的代码
  - 8.2 优化后的代码
- 9. 如何实现大整数相加
- 10. 如何求解金矿问题
- - 10.1 优化前的代码
  - 10.2 优化step1
  - 10.3 优化step2
- 11. 寻找缺失的整数
- - 11.1 解法1
  - 11.2 解法2
  - 11.3 解法3
  - 11.4 问题扩展step1
  - 11.5 问题扩展step2
Chapter6：算法的业务应用
- 1. Bitmap算法/位图算法
- 2. LRU算法
- 3. A星寻路算法
- 4. 红包算法
- - 方法1：二倍均值法
  - 方法2：线段切割法
  - 方法2：线段切割法

Chapter1：算法与数据结构常识

线性结构：数组、链表栈、队列、哈希表
树：二叉树二叉堆
图
时间复杂度
- 基本操作执行次数 $T_{n}$ （ $log_2{n}$ ）
- 渐进时间复杂度
大O表示法（最高阶项）
若存在函数 $f_{(n)}$ ，使得当 $n\to\infty$ 时， $\frac{T_{(n)}}{f_{(n)}}$ 的极限值为不等于0的常数，则称 $f_{(n)}$ 是 $T_{(n)}$ 的同数量级函数。记作 $T_{(n)}=O(f_{(n)})$ ，称为 $O(f_{(n)})$ ， $O$ 为算法的渐进时间复杂度，简称为时间复杂度
空间复杂度 $S_{(n)}=O(f_{(n)})$

空间性质	空间复杂度
常量空间	$O (1)$
线性空间	$O (n)$
二维空间	$O(n^2)$
递归空间

Chapter2：线性数据结构

数组array 顺序存储顺序表
根据下标读取元素的方式：随机读取
读取和更新的时间复杂度： $O (1)$
插入/删除： $O (n)$
读操作多，写操作少
链表随机存储
2.1 单向链表

2.2 双向链表在这里插入图片描述
链表

查找节点：最坏的时间复杂度是 $O (n)$
更新节点： $O (1)$
插入节点：尾部/头部/中间插入 $O (1)$
删除元素：尾部/头部/中间删除 $O (1)$ （Java自动化垃圾回收机制）

物理结构和逻辑结构
栈FILO
- 最早进入的元素存放的位置：栈底bottom
- 最后进入的元素存放的位置：栈顶top
- 入栈push
- 出栈pop
- $O (1)$
- 用于：对历史的回溯——递归、面包屑导航
队列FIFO
- 队列的出口端：队头front
- 队列的入口端：队尾rear
- 入队enque
- 出队deque（循环队列）
- $O (1)$
- 用于：对历史的回放——多线程中争夺公平锁的等待队列、爬虫实现网络抓取
双端队列deque
优先队列谁的优先级最高，谁先出队
散列表/哈希表 Key-Value 本质：数组
- 哈希函数 Key和数组下标进行转换
  取模
  $index=HashCode(Key)\%Array.length$
- 读get、写put（entry）：接近 $O (1)$
- 写操作：哈希冲突
  - 开放寻址法：下一个空档位置 ThreadLocal
  - 链表法：HashMap
- 扩容resize：

Chapter3：树

树tree是n(n≥0)个节点的有限集。当n=0时，称为空树。在任意一个非空树中，有如下特点：
- 有且仅有一个特定的称为根的节点。
- 当n>1时，其余节点可分为m(m>0)个互不相交的有限集，每一个集合的本身又是一个树，并称为根的子树。

根节点root
叶子节点leaf
子树
层级
父节点parent
孩子节点child
兄弟节点sibling
最大层级数：高度或深度

二叉树：每个节点最多有两个孩子节点

左孩子left child
右孩子right child

满二叉树：所有非叶子节点都存在左右孩子，并且所有叶子节点都在同一层级上
完全二叉树：对一个有n个节点的二叉树，按层级顺序编号，则所有节点的编号为从1到n。如果这个树所有节点和同样深度的满二叉树的编号为1到n的节点位置相同，则这个二叉树为完全二叉树
完全二叉树是满二叉树缺最后几个叶子节点

二叉树的存储方式
3.1 链式存储结构
3.2 数组
parent 左孩子2parent+1 右孩子2parent+2
leftChild 父节点(leftChild-1)/2
应用：二叉堆
二叉查找树（排序）
(1)如果左子树不为空，则左子树上所有节点的值均小于根节点的值
(2)如果右子树不为空，则右子树上所有节点的值均大于根节点的值
(3)左、右子树也都是二叉查找树
节点分布相对均衡的二叉查找树：搜索时间复杂度 $O (n)$
自平衡
二叉查找树的深度优先遍历栈
- 前序遍历：根节点、左子树、右子树
- 中序遍历：左子树、根节点、右子树
- 后序遍历：左子树、右子树、根节点
二叉查找树的广度优先遍历队列
二叉堆
- 本质：完全二叉树
- 分类
  (1)最大堆：任何一个父节点的值都大于等于左、右子节点值
  (2)最小堆：任何一个父节点的值都小于等于左、右子节点值
- 根节点：堆顶
- 数组存储
二叉堆的自我调整
- 插入 $O(\log{n})$ ：最后一个位置→上浮
- 删除 $O(\log{n})$ ：（删的是堆顶）最后一个节点临时补到堆顶→下沉
- 构建二叉堆 $O (n)$ ：把无序的完全二叉树调整为二叉堆，本质就是让所有非叶子节点依次“下沉”（从最后一个非叶子节点开始）
优先队列
- 最大优先队列：当前最大的元素优先出队最大堆
- 最小优先队列：当前最小的元素优先出队最小堆

Chapter4：排序算法

分类一

时间复杂度	算法
$O(n^2)$	冒泡、插入、选择、希尔？
$O(n\log{n})$	快速、堆、归并
线性	计数、桶、基数

快速排序最坏时间复杂度是 $O(n^2)$

分类二

稳定性	算法
稳定	值相同的元素在排序后仍然保持着排序前的顺序
不稳定

在这里插入图片描述

1. 冒泡排序

两两交换，最大到最小
稳定排序
优化
- 有序标记：isSorted
- 数列有序区（记录最后一次元素交换的位置）
鸡尾酒排序：双向
（大部分元素已经有序的情况）

2. 快速排序

（交换排序） 平均空间复杂度是 $O(\log{n})$

基准元素的选择
元素的交换
- 双边循环法：左右两个指针（同时比成，则交换）一边与基准元素比一边相靠，最后与基准元素交换

public class Main {
	//递归实现双边循环法的快速排序
	
	public static void quickSort(int[] arr,int startIndex,int endIndex){
		//递归结束条件：startIndex大于或等于endIndex时
		if(startIndex>=endIndex){
			return;
		}
		//得到基准元素位置
		int pivotIndex=partition(arr,startIndex,endIndex);
		//根据基准元素，分成两部分进行递归排序
		quickSort(arr,startIndex,pivotIndex-1);
		quickSort(arr,pivotIndex+1,endIndex);
	}
	
	/*
	 * 分治（双边循环法）
	 * @param arr 待交换的数组
	 * @param startIndex 起始下标
	 * @param endIndex 结束下标
	 * */
	private static int partition(int[] arr,int startIndex,int endIndex){
		//取第1个位置（也可以选择随机位置）的元素作为基准元素
		int pivot=arr[startIndex];
		int left=startIndex;
		int right=endIndex;
		
		while(left!=right){
			//控制right指针比较并左移
			while(left<right&&arr[right]>pivot){
				right--;
			}
			//控制left指针比较并右移
			while(left<right&&arr[left]<=pivot){
				left++;
			}
			//交换left和right指针所指向的元素
			if(left<right){
				int p=arr[left];
				arr[left]=arr[right];
				arr[right]=p;
			}
		}
		
		//pivot和指针重合点交换
		arr[startIndex]=arr[left];
		arr[left]=pivot;
		
		return left;
	}
	
    public static void main(String[] args) {
    	int[] arr=new int[] {4,4,6,5,3,2,8,1};
    	quickSort(arr,0,arr.length-1);
    	System.out.println(Arrays.toString(arr));
    }
}

2.2.2 单边循环法：用mark指针来标示小于基准元素的区域，把小于基准元素的都放到此区域。最后把基准元素放到mark位置

//仅有partition函数变化
private static int partition(int[] arr,int startIndex,int endIndex){
    //取第1个位置（也可以选择随机位置）的元素作为基准元素
    int pivot=arr[startIndex];
    int mark=startIndex;
    
    for(int i=startIndex+1;i<=endIndex;i++){
        if(arr[i]<pivot){
            mark++;
            int p=arr[mark];
            arr[mark]=arr[i];
            arr[i]=p;
        }
    }
    
    arr[startIndex]=arr[mark];
    arr[mark]=pivot;
    return mark;
}

2.2.3 不用递归的方法

//仅有quickSort方法变化
public static void quickSort(int[] arr,int startIndex,int endIndex){
    //用一个集合栈来代替递归的函数栈
    Stack<Map<String,Integer>> quickSortStack=new Stack<Map<String,Integer>>();
    //整个数列的起止下标，以哈希的形式入栈
    Map rootParam=new HashMap();
    rootParam.put("startIndex", startIndex);
    rootParam.put("endIndex", endIndex);
    quickSortStack.push(rootParam);
    
    //循环结束条件：栈为空时
    while(!quickSortStack.isEmpty()){
        //栈顶元素出栈，得到起止下标
        Map<String,Integer> param=quickSortStack.pop();
        //得到基准元素位置
        int pivotIndex=partition(arr,param.get("startIndex"),param.get("endIndex"));
        //根据基准元素分成两部分，把每一部分的起止下标入栈
        if(param.get("startIndex")<pivotIndex-1){
            Map<String,Integer> leftParam=new HashMap<String,Integer>();
            leftParam.put("startIndex", param.get("startIndex"));
            leftParam.put("endIndex", pivotIndex-1);
            quickSortStack.push(leftParam);
        }
        if(pivotIndex+1<param.get("endIndex")){
            Map<String,Integer> rightParam=new HashMap<String,Integer>();
            rightParam.put("startIndex", pivotIndex+1);
            rightParam.put("endIndex", param.get("endIndex"));
            quickSortStack.push(rightParam);
        }
    }
}

3. 堆排序

3.1 把无序数组构建成二叉堆。需要从小到大排序，则构建成最大堆；需要从大到小排序，则构建成最小堆。
3.2 循环删除堆顶元素，替换到二叉堆的末尾，调整堆产生新的堆顶

public class Main {
	/**
	 * “下沉”调整
	 * @param array 待调整的堆
	 * @param parentIndex 要下沉的父节点
	 * @param length 堆的有效大小
	 */
	 public static void downAdjust(int[] array,int parentIndex,int length){
		 //temp保存父节点值，用于最后的赋值
		 int temp=array[parentIndex];
		 int childIndex=2*parentIndex+1;
		 while(childIndex<length){
			 //如果有右孩子，且右孩子大于左孩子的值，则定位到右孩子
			 if(childIndex+1<length&&array[childIndex+1]>array[childIndex]){
				 childIndex++;
			 }
			 //如果父节点大于任何一个孩子的值，则直接跳出
			 if(temp>=array[childIndex])
				 break;
			 //无须真正交换，单向赋值即可
			 array[parentIndex]=array[childIndex];
			 parentIndex=childIndex;
			 childIndex=2*childIndex+1;
		 }
		 array[parentIndex]=temp;
	 }
	 
	 /**
	  * 堆排序（升序）
	  * @param array 待调整的堆
	  */
	 public static void heapSort(int[] array){
		 //1.把无序数组构建成最大堆
		 for(int i=(array.length-2)/2;i>=0;i--){
			 downAdjust(array,i,array.length);
		 }
		 System.out.println(Arrays.toString(array));
		 //2.循环删除堆顶元素，移到集合尾部，调整堆产生新的堆顶
		 for(int i=array.length-1;i>0;i--){
			 //最后1个元素和第1个元素进行交换
			 int temp=array[i];
			 array[i]=array[0];
			 array[0]=temp;
			 //“下沉”调整最大堆
			 downAdjust(array,0,i);
		 }
	 }
	 
	 public static void main(String[] args){
		 int[] arr=new int[] {1,3,2,6,5,7,8,9,10,0};
		 heapSort(arr);
		 System.out.println(Arrays.toString(arr));
	 }
}

堆排序
空间复杂度： $O (1)$
时间复杂度：
第一步：把无序数组构造成二叉堆 $O (n)$
第二步：需要进行 $n - 1$ 次循环。每次循环调用一次downAdjust方法，所以第2步的计算规模是 $(n-1)\times\log{n}$ ，时间复杂度为 $O(n\log{n})$
两个步骤是并列关系，所以整体的时间复杂度是 $O(n\log{n})$

4. 计数排序

4.1 原始版与优化step1

利用数组下标来确定元素的正确位置
(1)随机整数，有取值范围，建立长度为取值范围的数组
(2)遍历序列，每一个元素对应下标的数组元素+1
(3)遍历数组，输出数组元素的下标值（元素值为输出次数）

public static int[] countSort(int[] array){
    //1.得到数列的最大值
    int max=array[0];
    for(int i=1;i<array.length;i++){
        if(array[i]>max){
            max=array[i];
        }
    }
    //2.根据数列最大值确定统计数组的长度
    /* 算法改进step1：用最大值-最小值+1作为数组的长度，
    *  数组的最小值作为偏移量，用于统计整数在统计数组中的下标
    */
    int[] countArray=new int[max+1];
    //3.遍历数列，填充统计数组
    for(int i=0;i<array.length;i++){
        countArray[array[i]]++;
    }
    //4.遍历统计数组，输出结果
    int index=0;
    int[] sortedArray=new int[array.length];
    for(int i=0;i<countArray.length;i++){
        for(int j=0;j<countArray[i];j++){
            sortedArray[index++]=i;
        }
    }
    return sortedArray;
}

public static void main(String[] args){
    int[] array=new int[]{4,4,6,5,3,2,8,1,7,5,6,0,10};
    int[] sortedArray=countSort(array);
    System.out.println(Arrays.toString(sortedArray));
}

4.2 优化step2

要求遵循原表固有顺序（变成稳定排序）

方法：从统计数组的第2个元素开始，每一个元素都加上前面所有元素之和

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XZjeDK0k-1595582632835)(漫画算法3.JPG)]

相加的目的：让统计数组存储的元素值，等于相应整数的最终排序位置的序号
接下来，创建输出数组sortedArray，长度和输入数列一致，然后从后向前遍历输入数列。（下标→位置，统计数组相应-1）

public static int[] countSort(int[] array){
    //1. 得到数列的最大值和最小值，并算出差值
    int max=array[0];
    int min=array[0];
    for(int i=1;i<array.length;i++){
        if(array[i]>max){
            max=array[i];
        }
        if(array[i]<min){
            min=array[i];
        }
    }
    int d=max-min;
    
    //2. 创建统计数组并统计对应元素的个数
    int[] countArray=new int[d+1];
    for(int i=0;i<array.length;i++){
        countArray[array[i]-min]++;
    }
    
    //3. 统计数组做变形，后面的元素等于前面的元素之和
    for(int i=1;i<countArray.length;i++){
        countArray[i]+=countArray[i-1];
    }
    
    //4. 倒序遍历原始数列，从统计数组找到正确位置，输出到结果数组
    int[] sortedArray=new int[array.length];
    for(int i=array.length-1;i>=0;i--){
        sortedArray[countArray[array[i]-min]-1]=array[i];
        countArray[array[i]-min]--;
    }
    
    return sortedArray;
}

public static void main(String[] args) {
    int[] array=new int[]{95,94,91,98,99,90,99,93,91,92};
    int[] sortedArray=countSort(array);
    System.out.println(Arrays.toString(sortedArray));
}

如果原始数列的规模是n，最大和最小整数的差值是m，时间复杂度是 $O (n + m)$ ，空间复杂度（如果不考虑结果数组，只考虑统计数组）是 $O (m)$

5. 桶排序

每一个桶（bucket）代表一个区间范围，里面可以承载一个或多个元素。
步骤
2.1 step1：分桶
2.2 step2：把数列元素放进桶
2.3 step3：对每个桶内部的元素分别进行排序
2.4 step4：遍历桶，输出所有元素

public static double[] bucketSort(double[] array){
    //1. 得到数列的最大值和最小值，并算出差值
    double max=array[0];
    double min=array[0];
    for(int i=1;i<array.length;i++){
        if(array[i]>max){
            max=array[i];
        }
        if(array[i]<min){
            min=array[i];
        }
    }
    double d=max-min;
    
    //2. 初始化桶
    int bucketNum=array.length;
    ArrayList<LinkedList<Double>> bucketList=new ArrayList<LinkedList<Double>>(bucketNum);
    for(int i=0;i<bucketNum;i++){
        bucketList.add(new LinkedList<Double>());
    }
    
    //3. 遍历原始数组，将每个元素放入桶中
    for(int i=0;i<array.length;i++){
        int num=(int)((array[i]-min)*(bucketNum-1)/d);
        bucketList.get(num).add(array[i]);
    }
    
    //4. 对每个桶内部进行排序
    for(int i=0;i<bucketList.size();i++){
        //JDK底层采用了归并排序或归并的优化版本
        Collections.sort(bucketList.get(i));
    }
    
    //5. 输出全部元素
    double[] sortedArray=new double[array.length];
    int index=0;
    for(LinkedList<Double> list:bucketList){
        for(double element:list){
            sortedArray[index]=element;
            index++;
        }
    }
    
    return sortedArray;
}

public static void main(String[] args) {
    double[] array=new double[]{4.12,6.421,0.0023,3.0,2.123,8.122,4.12,10.09};
    double[] sortedArray=bucketSort(array);
    System.out.println(Arrays.toString(sortedArray));
}

桶排序的性能并非绝对稳定。如果元素的分布极不均衡，在极端情况下，第一个桶中有n-1个元素，最后一个桶中有1个元素。此时的时间复杂度将退化为 $O(n\log{n})$ ，而且还白白创建了许多空桶。

Chapter5：面试中的算法

1. 如何判断链表有环

单向链表

1.1 方法一：暴力遍历

方法：依次遍历节点，每遍历一个新节点，就从头检查新节点之前的所有节点，用新节点和之前的所有节点作比较。如果发现新节点和之前的某个节点相同，则说明该节点被遍历过2次，链表有环。
时间复杂度： $O(n^2)$
空间复杂度： $O (1)$

1.2 方法二：哈希表

方法：创建一个以节点ID为Key的HashSet集合，用来存储曾经遍历过的节点。
时间复杂度： $O (n)$
空间复杂度： $O (n)$

1.3 方法三：两个指针

方法：首先创建2个指针p1和p2（在Java里就是两个对象引用），让它们同时指向这个链表的头节点。然后开始一个大循环，在循环体中，让指针p1每次向后移动1个节点，让指针p2每次向后移动2个节点，然后比较两个指针指向的节点是否相同。如果相同，则可以判断出链表有环，如果不同，则继续下一次循环。
原理：追及问题（因为是环形的，所以肯定能追上）
时间复杂度： $O (n)$
空间复杂度： $O (1)$

/*
    * 判断是否有环
    * @param head 链表头节点
    * */
public static boolean isCycle(Node head){
    Node p1=head;
    Node p2=head;
    while(p2!=null&&p2.next!=null){
        p1=p1.next;
        p2=p2.next.next;
        if(p1==p2){
            return true;
        }
    }
    return false;
}

/*
    * 链表节点
    * */
public static class Node{
    int data;
    Node next;
    Node(int data){
        this.data=data;
    }
}

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;
    
    System.out.println(isCycle(node1));
}

1.4 扩展问题：环的长度

方法：当两个指针首次相遇，证明链表有环的时候，让两个指针从相遇点继续循环前进，并统计前进的循环次数，直到两个指针第2次相遇。此时，统计出来的前进次数就是环长。

原理：

指针p1每次走1步，指针p2每次走2步，两者的速度差是1步。当2个指针再次相遇时，p2比p1多走了整整1圈。
因此，环长=每一次速度差×前进次数=前进次数

1.5 扩展问题：出入环节点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sWGTmMQW-1595582632839)(漫画算法5.PNG)]

2. 最小栈

题目：实现一个栈，该栈带有出栈（pop）、入栈（push）、取最小元素（getMin）3个方法。要保证这3个方法的时间复杂度都是 $O (1)$

2.1 有问题的方法：把栈中的最小元素下标暂存起来

问题：这个元素出栈了咋办

2.2 方法：存储栈中曾经的最小值

方法：创建备胎栈B，对每一个入栈的元素，入栈最新的最小值/栈A出栈，按情况让栈B出栈
最坏情况空间复杂度： $O (n)$

public static class MinStack{
    private Stack<Integer> mainStack=new Stack<Integer>();
    private Stack<Integer> minStack=new Stack<Integer>();
    
    /**
        * 入栈操作
        * @param element 入栈的元素
        * */
    public void push(int element){
        mainStack.push(element);
        //如果辅助栈为空，或者新元素小于或等于辅助栈栈顶，则将新元素压入辅助栈
        if(minStack.empty()||element<=minStack.peek()){
            minStack.push(element);
        }
    }
    
    /**
        * 出栈操作
        * */
    public Integer pop(){
        //如果出栈元素和辅助栈栈顶元素值相等，辅助栈出栈
        if(mainStack.peek().equals(minStack.peek())){
            minStack.pop();
        }
        return mainStack.pop();
    }
    
    /**
        * 获取栈的最小元素
        * */
    public int getMin() throws Exception{
        if(mainStack.empty()){
            throw new Exception("stack is empty");
        }
        return minStack.peek();
    }
}

public static void main(String[] args) throws Exception{
    MinStack stack=new MinStack();
    stack.push(4);
    stack.push(9);
    stack.push(7);
    stack.push(3);
    stack.push(8);
    stack.push(5);
    System.out.println(stack.getMin());
    
    stack.pop();
    stack.pop();
    stack.pop();
    System.out.println(stack.getMin());
}

3. 最大公约数

题目：求两个整数的最大公约数

3.1 方法一：暴力枚举法

public static int getGreatestCommonDivisor(int a,int b){
    int big=a>b?a:b;
    int small=a<b?a:b;
    if(big%small==0){
        return small;
    }
    for(int i=small/2;i>1;i--){
        if(small%i==0&&big%i==0){
            return i;
        }
    }
    return 1;
}

public static void main(String[] args){
    System.out.println(getGreatestCommonDivisor(25,5));
    System.out.println(getGreatestCommonDivisor(100,80));
    System.out.println(getGreatestCommonDivisor(27,14));
}

时间复杂度： $O (min (a, b))$

3.2 方法二：辗转相除法/欧几里得算法

秦九韶算法/霍纳算法

定理：两个正整数a和b（a>b），它们的最大公约数等于a除以b的余数c和b之间的最大公约数。

public static int getGrestestCommonDivisorV2(int a,int b){
    int big=a>b?a:b;
    int small=a<b?a:b;
    if(big%small==0){
        return small;
    }
    return getGrestestCommonDivisorV2(big%small,small);
}

public static void main(String[] args){
    System.out.println(getGrestestCommonDivisorV2(25,5));
    System.out.println(getGrestestCommonDivisorV2(100,80));
    System.out.println(getGrestestCommonDivisorV2(27,14));
}

问题：当两个整数较大时，取模运算的性能会比较差。
时间复杂度可以近似为： $O(\log{(max(a,b))})$

3.3 方法三：辗转相减法/更相减损法

定理：两个正整数a和b（a>b），它们的最大公约数等于a-b的差值c和b之间的最大公约数。

public static int getGrestestCommonDivisorV3(int a,int b){
    if(a==b){
        return a;
    }
    int big=a>b?a:b;
    int small=a<b?a:b;
    return getGrestestCommonDivisorV3(big-small,small);
}

public static void main(String[] args){
    System.out.println(getGrestestCommonDivisorV3(25,5));
    System.out.println(getGrestestCommonDivisorV3(100,80));
    System.out.println(getGrestestCommonDivisorV3(27,14));
}

问题：更相减损术是不稳定的算法，运算次数可能极多
最坏时间复杂度为 $O (ma x (a, b))$

3.4 方法四：移位运算

当a和b均为偶数时，gcd(a,b)=2×gcd(a/2,b/2)=2×gcd(a>>1,b>>1)。
当a为奇数，b为偶数时，gcd(a,b)=gcd(a,b/2)=gcd(a,b>>1)。
当a和b均为奇数时，先利用更相减损术运算一次，gcd(a,b)=gcd(b,a-b)，此时a-b必将为偶数，然后又可以继续进行移位运算

public static int gcd(int a,int b){
    if(a==b){
        return a;
    }
    if((a&1)==0&&(b&1)==0){    //都是偶数
        return gcd(a>>1,b>>1)<<1;
    }else if((a&1)==0&&(b&1)!=0){
        return gcd(a>>1,b);
    }else if((a&1)!=0&&(b&1)==0){
        return gcd(a,b>>1);
    }else{
        int big=a>b?a:b;
        int small=a<b?a:b;
        return gcd(big-small,small);
    }
}

public static void main(String[] args){
    System.out.println(gcd(25,5));
    System.out.println(gcd(100,80));
    System.out.println(gcd(27,14));
}

时间复杂度： $O(\log{(max(a,b))})$

4. 2的整数次幂

题目：判断一个正整数是否是2的整数次幂

4.1 方法一：暴力枚举法

public static boolean isPowerOf2(int num){
    int temp=1;
    while(temp<=num){
        if(temp==num){
            return true;
        }
        temp*=2;    //优化：把乘以2的操作改成向左移位
        //temp=temp<<1;
    }
    return false;
}

public static void main(String[] args){
    System.out.println(isPowerOf2(32));
    System.out.println(isPowerOf2(19));
}

时间复杂度： $O(\log{n})$

4.2 方法二

如果一个整数是2的整数次幂，那么当它转化成二进制时，只有最高位是1，其他位都是0。
这样的数一旦减1，它的二进制数字就全部变成了1。
n&(n-1)=0

return (num&num-1)==0;

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

题目：有一个无序整型数组，如何求出该数组排序后的任意两个相邻元素的最大差值？

5.1 方法一：排序后求解

使用时间复杂度为 $O(n\log{n})$ 的排序算法（如快排）给原数组排序，然后遍历求差。
时间复杂度： $O(n\log{n})$
在不改变原数组的情况下，空间复杂度： $O (n)$

5.2 方法二：利用计数排序的思想

利用计数排序的思想，先求出原数组的最大值max与最小值min的区间长度k（k=max-min+1)，以及偏移量d=min。
创建一个长度为k的新数组Array。
遍历原数组，每遍历一个元素，就把新数组Array对应下标的值+1。遍历结束后，Array的一部分元素值变成了1或更高的数值，一部分元素值仍然是0。
遍历新数组Array，统计出Array中最大连续出现0值的次数+1，即为相邻元素最大差值。

问题：数组元素可能差值悬殊

5.3 方法三：利用桶排序的思想

利用桶排序的思想，根据原数组的长度n，创建出n个桶，每一个桶代表一个区间范围。其中第一个桶从原数组的最小值min开始，区间跨度是(max-min)/(n-1)。
遍历原数组，把原数组每一个元素插入到对应的桶中，记录每一个桶的最大和最小值。
遍历所有的桶，统计出每一个桶的最大值，和这个桶右侧非空桶的最小值的差，数值最大的差即为原数组排序后的相邻最大差值。

时间复杂度： $O (n)$

public static int getMaxSortedDistance(int[] array){
    //1. 得到数列的最大值和最小值
    int max=array[0];
    int min=array[0];
    for(int i=1;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++){
        //确定数组元素所归属的桶下标
        int index=((array[i]-min)*(bucketNum-1)/d);
        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;
        }
        leftMax=buckets[i].max;
    }
    
    return maxDistance;
}

/**
    * 桶
    * */
private static class Bucket{
    Integer min;
    Integer max;
}

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

6. 用栈实现队列

两个栈，来来回回倒

static class StackQueue{
    private Stack<Integer> stackA=new Stack<Integer>();
    private Stack<Integer> stackB=new Stack<Integer>();
    
    /**
        * 入队操作
        * @param element 入队的元素
        * */
    public void enQueue(int element){
        stackA.push(element);
    }
    
    /**
        * 出队操作
        * */
    public Integer deQueue(){
        if(stackB.isEmpty()){
            if(stackA.isEmpty()){
                return null;
            }
            transfer();
        }
        return stackB.pop();
    }
    
    /**
        * 栈A元素转移到栈B
        * */
    private void transfer(){
        while(!stackA.isEmpty()){
            stackB.push(stackA.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());
}

入队操作的时间复杂度： $O (1)$
出队操作，如果涉及元素迁移，时间复杂度为 $O (n)$ ；如果不用迁移，时间复杂度为 $O (1)$

均摊时间复杂度
需要元素迁移的出队操作只有少数情况，并且不可能连续出现，其后的大多数出队操作都不需要元素迁移。
所以把时间均摊到每一次出队操作上面，其时间复杂度是 $O (1)$ 。

7. 寻找全排列的下一个数

题目：给出一个正整数，找出这个正整数所有数字全排列的下一个数。

方法：

从后向前查看逆序区域，找到逆序区域的前一位，也就是数字置换的边界。
让逆序区域的前一位和逆序区域中大于它的最小的数字交换位置。
把原来的逆序区域转为顺序状态。

//为方便数字的交换，入参和返回值的类型都采用了整型数组
public static int[] findNearestNumber(int[] numbers){
    //1. 从后向前查看逆序区域，找到逆序区域的前一位，也就是数字置换的边界
    int index=findTransferPoint(numbers);
    //如果数字置换边界是0，说明整个数组已经逆序，无法得到更大的相同数字组成的整数，返回null
    if(index==0){
        return null;
    }
    
    //2. 把逆序区域的前一位和逆序区域中刚刚大于它的数字交换位置
    //复制并入参，避免直接修改入参
    int[] numbersCopy=Arrays.copyOf(numbers, numbers.length);
    exchangeHead(numbersCopy,index);
    
    //3. 把原来的逆序区域转为顺序
    reverse(numbersCopy,index);
    return numbersCopy;
}

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

private static int[] exchangeHead(int[] numbers,int index){
    int head=numbers[index-1];
    for(int i=numbers.length-1;i>0;i--){
        if(head<numbers[i]){
            numbers[index-1]=numbers[i];
            numbers[i]=head;
            break;
        }
    }
    return numbers;
}

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,4,5};
    //打印12345 之后的10个全排列整数
    for(int i=0;i<10;i++){
        numbers=findNearestNumber(numbers);
        outputNumbers(numbers);
    }
}

//输出数组
private static void outputNumbers(int[] numbers){
    for(int i:numbers){
        System.out.print(i);
    }
    System.out.println();
}

解法名：字典序算法
时间复杂度： $O (n)$

8. 删去k个数字后的最小值

问题：给出一个整数，从该整数中去掉k个数字，要求剩下的数字形成的新整数尽可能小。（给出的整数的大小可以超过long类型的数字范围）

每一次删掉比右边数字大的数字（第一个顺序的最后一个元素）
依次求得局部最优解，最终得到全局最优解的思想，叫做贪心算法

8.1 性能不好的代码

/**
    * 删除整数的k个数字，获得删除后的最小值
    * @param num 原整数
    * @param k 删除数量
    * */
public static String removeKDigits(String num,int k){
    String numNew=num;
    for(int i=0;i<k;i++){
        boolean hasCut=false;
        //从左向右遍历，找到比自己右侧数字大的数字并删除
        for(int j=0;j<numNew.length()-1;j++){
            if(numNew.charAt(j)>numNew.charAt(j+1)){
                numNew=numNew.substring(0,j)+numNew.substring(j+1,numNew.length());
                hasCut=true;
                break;
            }
        }
        //如果没有找到要删除的数字，则删除最后一个数字
        if(!hasCut){
            numNew=numNew.substring(0,numNew.length()-1);
        }
        //清除整数左侧的数字0
        numNew=removeZero(numNew);
    }
    //如果整数的所有数字都被删除了，直接返回0
    if(numNew.length()==0){
        return "0";
    }
    return numNew;
}

private static String removeZero(String num){
    for(int i=0;i<num.length()-1;i++){
        if(num.charAt(0)!='0'){
            break;
        }
        num=num.substring(1,num.length());
    }
    return num;
}

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

时间复杂度： $O (kn)$
缺点：

每次内层循环都需要从头开始遍历所有数字（应该停留在上一次删除的位置继续）
subString方法的时间复杂度是 $O (n)$ ，性能不高

8.2 优化后的代码

/**
    * 删除整数的k个数字，获得删除后的最小值
    * @param num 原整数
    * @param k 删除数量
    * */
public static String removeKDigits(String num,int k){
    //新整数的最终长度=原整数长度-k
    int newLength=num.length()-k;
    //创建一个栈，用于接收所有的数字
    char[] stack=new char[num.length()];
    int top=0;
    for(int i=0;i<num.length();++i){
        //遍历当前数字
        char c=num.charAt(i);
        //当栈顶数字大于遍历到的当前数字时，栈顶数字出栈（相当于删除数字）
        while(top>0&&stack[top-1]>c&&k>0){
            top-=1;
            k-=1;
        }
        //遍历到的当前数字入栈
        stack[top++]=c;
    }
    //找到栈中第1个非零数字的位置，以此构建新的整数字符串
    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("30200",1));
    System.out.println(removeKDigits("10",2));
    System.out.println(removeKDigits("541270936",3));
}

时间复杂度： $O (n)$
空间复杂度： $O (n)$

9. 如何实现大整数相加

数组存储，数位相加（类似于列竖式）

/**
    * 大整数求和
    * @param bigNumberA 大整数A
    * @param bigNumberB 大整数B
    * */
public static String bigNumberSum(String bigNumberA,String bigNumberB){
    //1. 把两个大整数用数组逆序存储，数组长度等于较大整数位数+1
    int maxLength=bigNumberA.length()>bigNumberB.length()?bigNumberA.length():bigNumberB.length();
    int[] arrayA=new int[maxLength+1];
    for(int i=0;i<bigNumberA.length();i++){
        arrayA[i]=bigNumberA.charAt(bigNumberA.length()-1-i)-'0';
    }
    int[] arrayB=new int[maxLength+1];
    for(int i=0;i<bigNumberB.length();i++){
        arrayB[i]=bigNumberB.charAt(bigNumberB.length()-1-i)-'0';
    }
    
    //2. 构建result数组，数组长度等于较大整数位数+1
    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. 把result数组再次逆序并转成String
    StringBuilder sb=new StringBuilder();
    //是否找到大整数的最高有效位
    boolean findFirst=false;
    for(int i=result.length-1;i>=0;i--){
        if(!findFirst){
            if(result[i]==0){
                continue;
            }
            findFirst=true;
        }
        sb.append(result[i]);
    }
    return sb.toString();
}

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

时间复杂度： $O (n)$

优化：不需要把原整数拆分得这么细，只需要拆分到可以被直接计算的地步就可以了。
int最多可以有10位整数，为防溢出，可以把大整数的每9位作为一个元素，进行加法运算。

10. 如何求解金矿问题

题目：有位国王拥有5座金矿，每座金矿的黄金储量不同，需要参与挖掘的工人人数也不同。例如有的金矿储量是500kg黄金，需要5个工人来挖掘；有的金矿储量是200kg黄金，需要3个工人来挖掘……
如果参与挖矿的工人的总数是10。每座金矿要么全挖，要么不挖，不能派出一半人挖取一半的金矿。要求用程序求出，要想得到尽可能多的黄金，应该选择挖取哪几座金矿？

标签：动态规划 背包问题

最优子结构
边界
状态转移方程式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZbTIVYdJ-1595582632843)(漫画算法6.png)]

10.1 优化前的代码

/**
    * 获得金矿最优收益
    * @param w 工人数量
    * @param n 可选金矿数量
    * @param p 金矿开采所需的工人数量
    * @param g 金矿储量
    * */
public static int getBestGoldMining(int w,int n,int[] p,int[] g){
    if(w==0||n==0){
        return 0;
    }
    if(w<p[n-1]){
        return getBestGoldMining(w,n-1,p,g);
    }
    return Math.max(getBestGoldMining(w,n-1,p,g), getBestGoldMining(w-p[n-1],n-1,p,g)+g[n-1]);
}

public static void main(String[] args){
    int w=10;
    int[] p={5,5,3,4,3};
    int[] g={400,500,200,300,350};
    System.out.println("最优收益："+getBestGoldMining(w,g.length,p,g));
}

时间复杂度： $O(2^n)$
问题：递归做了很多重复计算

10.2 优化step1

自底向上求解
以金矿为行，工人人数为列，逐一求解表格

/**
    * 获得金矿最优收益
    * @param w 工人数量
    * @param p 金矿开采所需的工人数量
    * @param g 金矿储量
    * */
public static int getBestGoldMiningV2(int w,int[] p,int[] g){
    //创建表格
    int[][] resultTable=new int[g.length+1][w+1];
    //填充表格
    for(int i=1;i<=g.length;i++){
        for(int j=1;j<=w;j++){
            if(j<p[i-1]){
                resultTable[i][j]=resultTable[i-1][j];
            }else{
                resultTable[i][j]=Math.max(resultTable[i-1][j], resultTable[i-1][j-p[i-1]]+g[i-1]);
            }
        }
    }
    //返回最后一个格子的值
    return resultTable[g.length][w];
}

时间复杂度： $O (n w)$

10.3 优化step2

在程序中并不需要保存整个表格，无论金矿有多少座，我们只保存1行的数据即可。在计算下一行时，要从右向左统计，把旧的数据一个一个替换掉。

/**
    * 获得金矿最优收益
    * @param w 工人数量
    * @param p 金矿开采所需的工人数量
    * @param g 金矿储量
    * */
public static int getBestGoldMiningV3(int w,int[] p,int[] g){
    //创建当前结果
    int[] results=new int[w+1];
    //填充一维数组
    for(int i=1;i<=g.length;i++){
        for(int j=w;j>=1;j--){
            if(j>=p[i-1]){
                results[j]=Math.max(results[j], results[j-p[i-1]]+g[i-1]);
            }
        }
    }
    //返回最后1个格子的值
    return results[w];
}

空间复杂度： $O (n)$

11. 寻找缺失的整数

问题：在1个无序数组里有99个不重复的正整数，范围是1 ~ 100，唯独缺少1个1~100中的整数。如何找出这个缺失的整数？

11.1 解法1

创建一个以1~100为Key的哈希表，遍历数组删除元素对应的Key，最后剩下的Key就是缺失的整数。
时间复杂度： $O (n)$
空间复杂度： $O (n)$

11.2 解法2

先把数组元素排序，然后遍历，如果发现两个相邻元素并不连续，说明缺少的就是这两个元素之间的整数
时间复杂度： $O(n\log{n})$
空间复杂度： $O (1)$

11.3 解法3

先算出1~100的累加和，然后再依次减去数组里的所有元素，最后的差值就是所缺少的整数
时间复杂度： $O (n)$
空间复杂度： $O (1)$

11.4 问题扩展step1

题目：一个无序数组里有若干个正整数，范围是1~100，其中99个整数都出现了偶数次，只有1个整数出现了奇数次，如何找到这个出现奇数次的整数？

异或运算 同0异1
把数组里所有元素依次进行异或运算，最后得到的就是那个整数
时间复杂度： $O (n)$
空间复杂度： $O (1)$

11.5 问题扩展step2

问题：……如果数组里有2个整数出现了奇数次，其他整数出现偶数次，如何找出这两个整数呢？

分治法
如果把数组分成两部分，保证每一部分都包含1个出现奇数次的整数，这样就与上一题的情况一样了
首先把数组元素依次进行异或运算，最后结果中肯定至少有1个二进制位是1，就用这个位置把数组分成两份，就能把这两个要找的整数分开

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uOYZlpjp-1595582632846)(漫画算法7.png)]

时间复杂度： $O (n)$
空间复杂度： $O (1)$

public static int[] findLostNum(int[] array){
    //用于存储2个出现奇数次的整数
    int result[]=new int[2];
    //第1次进行整体异或运算
    int xorResult=0;
    for(int i=0;i<array.length;i++){
        xorResult^=array[i];
    }
    //如果进行异或运算的结果为0，则说明输入的数组不符合题目要求
    if(xorResult==0){
        return null;
    }
    //确定2个整数的不同位，以此来做分组
    int separator=1;
    while(0==(xorResult&separator)){
        separator<<=1;
    }
    //第2次分组进行异或运算
    for(int i=0;i<array.length;i++){
        if(0==(array[i]&separator)){
            result[0]^=array[i];
        }else{
            result[1]^=array[i];
        }
    }
    
    return result;
}

public static void main(String[] args){
    int[] array={4,1,2,2,5,1,4,3};
    int[] result=findLostNum(array);
    System.out.println(result[0]+", "+result[1]);
}

Chapter6：算法的业务应用

1. Bitmap算法/位图算法

用户标签→关系型数据库
Bitmap（一块长度为10bit的内存空间）算法：用于对大量整数做去重和查询操作
用标签对应多个用户，将其转为Bitmap做交集/并集
算法优势：高性能的位运算
反向匹配：全量的Bitmap（异或）

static class MyBitmap{
    //每一个word是一个long类型元素，对应一个64位二进制数据
    private long[] words;
    //Bitmap的位数大小
    private int size;
    
    public MyBitmap(int size){
        this.size=size;
        this.words=new long[(getWordIndex(size-1)+1)];
    }
    
    /**
        * 判断Bitmap某一位的状态
        * @param bitIndex 位图的第bitIndex位
        * */
    public boolean getBit(int bitIndex){
        if(bitIndex<0||bitIndex>size-1){
            throw new IndexOutOfBoundsException("超过Bitmap有效范围");
        }
        int wordIndex=getWordIndex(bitIndex);
        return (words[wordIndex]&(1L<<bitIndex))!=0;
    }
    
    /**
        * 把Bitmap某一位设置为true
        * @param bitIndex 位图的第bitIndex位
        * */
    public void setBit(int bitIndex){
        if(bitIndex<0||bitIndex>size-1){
            throw new IndexOutOfBoundsException("超过Bitmap有效范围");
        }
        int wordIndex=getWordIndex(bitIndex);
        words[wordIndex]|=(1L<<bitIndex);
    }
    
    /**
        * 定位Bitmap某一位所对应的word
        * @param bitIndex 位图的第bitIndex位
        * */
    private int getWordIndex(int bitIndex){
        //右移6位，相当于除以64
        return bitIndex>>6;
    }
}

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uP2R2Xxj-1595582632849)(漫画算法8.png)]

2. LRU算法

用哈希表做缓存，哈希表过大

Least Recently Used
内存管理算法
假设：长期不被使用的数据，在未来被用到的几率也不大。因此，当数据所占内存达到一定阈值时，我们要移除掉最近最少被使用的数据。
数据结构——哈希链表

依靠哈希链表的有序性，可以把Key-Value按照最后的使用时间进行排序。
大致来说就是把最近访问的用户添加/移动到最后面

Java里封装的轮子：LinkedHashMap

static class LRUCache{
    private Node head;
    private Node end;
    //缓存存储上限
    private int limit;
    
    private HashMap<String,Node> hashMap;
    
    public LRUCache(int limit){
        this.limit=limit;
        hashMap=new HashMap<String,Node>();
    }
    
    public String get(String key){
        Node node=hashMap.get(key);
        if(node==null){
            return null;
        }
        refreshNode(node);
        return node.value;
    }
    
    public void put(String key,String value){
        Node node=hashMap.get(key);
        if(node==null){
            //如果Key不存在，则插入Key-Value
            if(hashMap.size()>=limit){
                String oldKey=removeNode(head);
                hashMap.remove(oldKey);
            }
            node=new Node(key,value);
            addNode(node);
            hashMap.put(key, node);
        }else{
            //如果Key存在，则刷新Key-Value
            node.value=value;
            refreshNode(node);
        }
    }
    
    public void remove(String key){
        Node node=hashMap.get(key);
        removeNode(node);
        hashMap.remove(key);
    }
    
    /**
        * 刷新被访问的节点位置
        * @param node 被访问的节点
        * */
    private void refreshNode(Node node){
        //如果访问的是尾节点，则无需移动节点
        if(node==end){
            return;
        }
        //移除节点
        removeNode(node);
        //重新插入节点
        addNode(node);
    }
    
    /**
        * 删除节点
        * @param node 要删除的节点
        * */
    private String removeNode(Node node){
        if(node==head&&node==end){
            //移除唯一的节点
            head=null;
            end=null;
        }else if(node==end){
            //移除尾节点
            end=end.pre;
            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 addNode(Node node){
        if(end!=null){
            end.next=node;
            node.pre=end;
            node.next=null;
        }
        end=node;
        if(head==null){
            head=node;
        }
    }
    
    class Node{
        Node(String key,String value){
            this.key=key;
            this.value=value;
        }
        public Node pre;
        public Node next;
        public String key;
        public String value;
    }
}

public static void main(String[] args){
    LRUCache lruCache=new LRUCache(5);
    lruCache.put("001", "用户1信息");
    lruCache.put("002", "用户2信息");
    lruCache.put("003", "用户3信息");
    lruCache.put("004", "用户4信息");
    lruCache.put("005", "用户5信息");
    lruCache.get("002");
    lruCache.put("004", "用户4信息更新");
    lruCache.put("006", "用户6信息");
    System.out.println(lruCache.get("001"));
    System.out.println(lruCache.get("006"));
}

注意：这段代码不是线程安全的代码

对于用户系统的需求，也可以使用缓存数据库Redis来实现，Redis底层也实现了类似LRU的回收算法。

3. A星寻路算法

A*search algorithm

从起点绕过障碍物走到终点

OpenList：可到达的格子
CloseList：已到达的格子
F=G+H
G：从起点走到当前格子的成本，也就是已经花费了多少步。
H：在不考虑障碍的情况下，从当前格子走到目标格子的距离，也就是离目标还有多远。
F：G和H的综合评估，也就是从起点到达当前格子，再从当前格子到达目标格子的总步数。

将起点放入OpenList→
（找出OpenList中F值最小的值作为当前格子，将当前格子移入CloseList→将当前格子上下左右可到达的格子，看它们是否在OpenList或CloseList中；如果不在，则将它们加入OpenList，计算出相应的G、H、F值，并把当前格子作为它们的“父节点”。）循环
到达终点后顺着父节点依次回溯，找到一条最佳路径

启发式搜索

//迷宫地图
public 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}
};

/**
    * A*寻路主逻辑
    * @param start 迷宫起点
    * @param end 迷宫终点
    * */
public static Grid aStarSearch(Grid start,Grid end){
    ArrayList<Grid> openList=new ArrayList<Grid>();
    ArrayList<Grid> closeList=new ArrayList<Grid>();
    //把起点加入openList
    openList.add(start);
    //主循环，每一轮检查1个当前方格节点
    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){
            if(!openList.contains(grid)){
                //邻近节点不在openList中，标记“父节点”、G、H、F，并放入openList
                grid.initGird(currentGrid,end);
                openList.add(grid);
            }
        }
        //如果终点在openList中，直接返回终点格子
        for(Grid grid:openList){
            if((grid.x==end.x)&&(grid.y==end.y)){
                return grid;
            }
        }
    }
    //openList用尽，仍然找不到终点，说明终点不可到达，返回空
    return null;
}

private static Grid findMinGird(ArrayList<Grid> openList){
    Grid tempGrid=openList.get(0);
    for(Grid grid:openList){
        if(grid.f<tempGrid.f){
            tempGrid=grid;
        }
    }
    return tempGrid;
}

private static ArrayList<Grid> findNeighbors(Grid grid,List<Grid> openList,List<Grid> closeList){
    ArrayList<Grid> gridList=new ArrayList<Grid>();
    if(isValidGrid(grid.x,grid.y-1,openList,closeList)){
        gridList.add(new Grid(grid.x,grid.y-1));
    }
    if(isValidGrid(grid.x,grid.y+1,openList,closeList)){
        gridList.add(new Grid(grid.x,grid.y+1));
    }
    if(isValidGrid(grid.x-1,grid.y,openList,closeList)){
        gridList.add(new Grid(grid.x-1,grid.y));
    }
    if(isValidGrid(grid.x+1,grid.y,openList,closeList)){
        gridList.add(new Grid(grid.x+1,grid.y));
    }
    return gridList;
}

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

private static boolean containGrid(List<Grid> grids,int x,int y){
    for(Grid n:grids){
        if((n.x==x)&&(n.y==y)){
            return true;
        }
    }
    return false;
}

static class Grid{
    public int x;
    public int y;
    public int f;
    public int g;
    public int h;
    public Grid parent;
    
    public Grid(int x,int y){
        this.x=x;
        this.y=y;
    }
    
    public void initGird(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;
    }
}

public static void main(String[] args){
    //设置起点和终点
    Grid startGrid=new Grid(2,1);
    Grid endGrid=new Grid(2,5);
    //搜索迷宫终点
    Grid resultGrid=aStarSearch(startGrid,endGrid);		
    //回溯迷宫路径
    ArrayList<Grid> path=new ArrayList<Grid>();
    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();
    }
}

4. 红包算法

红包金额尽可能分布均衡
为了避免高并发引起的一些问题：先计算好每个红包拆除的金额，并把它们放到一个队列里，领取红包的用户要在队列中找到属于自己的那一份。
公平

方法1：二倍均值法

把每次随机金额的上限定为剩余人均金额的两倍

假设剩余红包金额为m元，剩余人数为n：
每次抢到的金额=随机区间[0.01, m/n×2-0.01]元

保证了每次随机金额的均值是相等的

/**
    * 拆分红包
    * @param totalAmount 总金额（以分为单位）
    * @param totalPeopleNum 总人数
    * */
public static List<Integer> divideRedPackage(Integer totalAmount,Integer totalPeopleNum){
    List<Integer> amountList=new ArrayList<Integer>();
    Integer restAmount=totalAmount;
    Integer restPeopleNum=totalPeopleNum;
    Random random=new Random();
    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;
}

public static void main(String[] args){
    List<Integer> amountList=divideRedPackage(1000,10);
    for(Integer amount:amountList){
        System.out.println("抢到金额："+new BigDecimal(amount).divide(new BigDecimal(100)));
    }
}

方法2：线段切割法

rid(2,1);
Grid endGrid=new Grid(2,5);
//搜索迷宫终点
Grid resultGrid=aStarSearch(startGrid,endGrid);
//回溯迷宫路径
ArrayList path=new ArrayList();
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();
}
}


## 4. 红包算法
1. 红包金额尽可能分布均衡
2. 为了避免高并发引起的一些问题：先计算好每个红包拆除的金额，并把它们放到一个队列里，领取红包的用户要在队列中找到属于自己的那一份。
3. 公平

### 方法1：二倍均值法
把每次随机金额的上限定为剩余人均金额的两倍

假设剩余红包金额为m元，剩余人数为n：
每次抢到的金额=随机区间[0.01, m/n×2-0.01]元

保证了每次随机金额的均值是相等的

```java
/**
    * 拆分红包
    * @param totalAmount 总金额（以分为单位）
    * @param totalPeopleNum 总人数
    * */
public static List<Integer> divideRedPackage(Integer totalAmount,Integer totalPeopleNum){
    List<Integer> amountList=new ArrayList<Integer>();
    Integer restAmount=totalAmount;
    Integer restPeopleNum=totalPeopleNum;
    Random random=new Random();
    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;
}

public static void main(String[] args){
    List<Integer> amountList=divideRedPackage(1000,10);
    for(Integer amount:amountList){
        System.out.println("抢到金额："+new BigDecimal(amount).divide(new BigDecimal(100)));
    }
}