< div style = "color:#16b0ff;font-size:50px;font-weight: 900;text-shadow: 5px 5px 10px var(--theme-color);font-family: 'Comic Sans MS';" > Algorithm< / div >
< span style = "color:#16b0ff;font-size:20px;font-weight: 900;font-family: 'Comic Sans MS';" > Introduction</ span > ：收纳技术相关的 `Data Structure` 、`Algorithm`、`Design Pattern`等总结！
[TOC]
# Data Structure
## 位运算
- **左移( << )**： ，
- **右移( >> )**： ，
- **无符号右移( >>> )**： ， ， ， ， ，
- **位非( ~ )**： ，
- **位与( & )**： ， ，
- **位或( | )**： ， ，
- **位异或( ^ )**： ， ，
```java
a^a=0; // 自己和自己异或等于0
a^0=a; // 任何数字和0异或还等于他自己
a^b^c=a^c^b; // 异或运算具有交换律
```
### 左移( << )
案例如下：
`5<<2=20`
首先会将5转为2进制表示形式(java中，
0000 0000 0000 0000 0000 0000 0000 0`101` 然后左移2位后， ：
0000 0000 0000 0000 0000 0000 000`101` `00` 换算成10进制为20
### 右移( >> )
案例如下：
`5>>2=1`
还是先将5转为2进制表示形式：
0000 0000 0000 0000 0000 0000 0000 0`101` 然后右移2位，
`00` 00 0000 0000 0000 0000 0000 0000 000`1`
### 无符号右移( >>> )
我们知道在Java中int类型占32位， ， ， ， ， ， ， ，
案例如下：
`5>>3=0`
`-5>>-1`
`-5>>>536870911`
我们来看看它的移位过程(可以通过其结果换算成二进制进行对比)：
5换算成二进制：
5右移3位后结果为0， ：
-5换算成二进制：
-5右移3位后结果为-1， ：
-5无符号右移3位后的结果 536870911 换算成二进制： 0001 1111 1111 1111 1111 1111 1111 1111 // (用0进行补位)
### 位非( ~ )
操作数的第n位为1， ，
案例如下：
`~5=-6`
5转换为二进制：
-6转换为二进制：
### 位与( & )
**都为1则为1， ， ，
案例如下：
`5&3=1`
将2个操作数和结果都转换为二进制进行比较：
5转换为二进制：
3转换为二进制：
1转换为二进制：
### 位或( | )
第一个操作数的的第n位于第二个操作数的第n位 只要有一个是1， ，
案例如下：
`5|3=7`
5转换为二进制：
3转换为二进制：
7转换为二进制：
### 位异或( ^ )
第一个操作数的的第n位于第二个操作数的第n位 相反， ，
`a^0=a`
案例如下：
`5^3=6`
5转换为二进制：
3转换为二进制：
6转换为二进制：
### 衍生
由位运算操作符衍生而来的有：
`&=` 按位与赋值
`|=` 按位或赋值
`^=` 按位非赋值
`>>=` 右移赋值
`>>=` 无符号右移赋值
`<<=` 赋值左移
和 += 一个概念而已。
## 常用数据结构
### 数组(Array)
**优点**
- 构建非常简单
- 能在 O(1) 的时间里根据数组的下标（ ）
**缺点**
- 构建时必须分配一段连续的空间
- 查询某个元素是否存在时需要遍历整个数组，耗费 O(n) 的时间（ ，
- 删除和添加某个元素时，同样需要耗费 O(n) 的时间
**基本操作**
- **insert**：在某个索引处插入元素
- **get**：读取某个索引处的元素
- **delete**：删除某个索引处的元素
- **size**：获取数组的长度
**案例一：
**解法**：用两个指针，一个指向字符串的第一个字符 a， ， ， ，
**案例二： ，
说明：你可以假设字符串只包含小写字母。
**解题思路**：字母异位词，也就是两个字符串中的相同字符的数量要对应相等。
- 可以利用两个长度都为 26 的字符数组来统计每个字符串中小写字母出现的次数，然后再对比是否相等
- 可以只利用一个长度为 26 的字符数组，将出现在字符串 s 里的字符个数加 1， ，
### 链表(Linked List)
链表（ ） ， ， ， （ ）
**优点**
- 链表能灵活地分配内存空间
- 能在 O(1) 时间内删除或者添加元素
**缺点**
- 不像数组能通过下标迅速读取元素，每次都要从链表头开始一个一个读取
- 查询第 k 个元素需要 O(k) 时间
**基本操作**
- **insertAtEnd**：在链表结尾插入元素
- **insertAtHead**：在链表开头插入元素
- **delete** ：删除链表的指定元素
- **deleteAtHead** ：删除链表第一个元素
- **search**：在链表中查询指定元素
- **isEmpty**：查询链表是否为空
**应用场景**
- 如果要解决的问题里面**需要很多快速查询**，链表可能并不适合
- 如果遇到的问题中，数据的元素个数不确定，而且需要**经常进行数据的添加和删除**，那么链表会比较合适
- 如果数据元素大小确定，**删除和插入的操作并不多**，那么数组可能更适合
**链表实现数据结构**
**① 用链表实现队列**
**② 用链表实现栈**
**链表翻转算法**
**① 递归翻转**
```java
/**
* 链表递归翻转模板
*/
public Node reverseLinkedList(参数0) {
// Step1：
if (终止条件) {
return;
}
// Step2： ： ， ，
// Step3：
Node reverse = reverseLinkedList(参数1);
// Step4： ： ， ，
}
/**
* 链表递归翻转算法
*/
public Node reverseLinkedList(Node head) {
// Step1：
if (head == null || head.next == null) {
return head;
}
// Step2：
Node next = head.next;
// Step3：
Node reverse = reverseLinkedList(next);
// Step4：
next.next = head;
// 这里head相当于变成了尾结点， ，
head.next = null;
return reverse;
}
```
**② 三指针翻转**
```java
public static Node reverseLinkedList(Node head) {
// 单链表为空或只有一个节点，直接返回原单链表
if (head == null || head.getNext() == null) {
return head;
}
// 前一个节点指针
Node preNode = null;
// 当前节点指针
Node curNode = head;
// 下一个节点指针
Node nextNode = null;
while (curNode != null) {
// nextNode 指向下一个节点
nextNode = curNode.getNext();
// 将当前节点next域指向前一个节点
curNode.setNext(preNode);
// preNode 指针向后移动
preNode = curNode;
// curNode指针向后移动
curNode = nextNode;
}
return preNode;
}
```
**③ 利用栈翻转**
```java
public Node reverseLinkedList(Node node) {
Stack< Node > nodeStack = new Stack< >();
// 存入栈中，模拟递归开始的栈状态
while (node != null) {
nodeStack.push(node);
node = node.getNode();
}
// 特殊处理第一个栈顶元素：反转前的最后一个元素，因为它位于最后，不需要反转
Node head = null;
if ((!nodeStack.isEmpty())) {
head = nodeStack.pop();
}
// 排除以后就可以快乐的循环
while (!nodeStack.isEmpty()) {
Node tempNode = nodeStack.pop();
tempNode.getNode().setNode(tempNode);
tempNode.setNode(null);
}
return head;
}
```
#### 单向链表
单向链表包含两个域：
- **一个数据域**：用于存储数据
- **一个指针域**：用于指向下一个节点（最后一个节点则指向一个空值）：
单链表的遍历方向单一，只能从链头一直遍历到链尾。它的缺点是当要查询某一个节点的前一个节点时，只能再次从头进行遍历查询，因此效率比较低，而双向链表的出现恰好解决了这个问题。单向链表代码如下：
```java
public class Node< E > {
private Eitem;
private Node< E > next;
}
```
#### 双向链表
双向链表的每个节点由三部分组成：
- **prev指针**：指向前置节点
- **item节点**：数据信息
- **next指针**：指向后置节点
双向链表代码如下：
```kotlin
public class Node< E > {
private E item;
private Node< E > next;
private Node< E > prev;
}
```
#### 循环链表
循环链表又分为单循环链表和双循环链表，也就是将单向链表或双向链表的首尾节点进行连接。
- **单循环链表**
- **双循环链表**
### 栈(Stack)
栈是一种**先进后出**（ ， ） （ ， ）
- **单向链表**：可以利用一个单链表来实现栈的数据结构。而且，因为我们都只针对栈顶元素进行操作，所以借用单链表的头就能让所有栈的操作在 O(1) 的时间内完成。
- **Stack**： ，
```java
public class Stack< E > extends Vector< E > {
// 把元素压入栈顶
public E push(E item) {
addElement(item);
return item;
}
// 弹出栈顶元素
public synchronized E pop() {
E obj;
int len = size();
obj = peek();
removeElementAt(len - 1);
return obj;
}
// 访问当前栈顶元素，但是不拿走栈顶元素
public synchronized E peek() {
int len = size();
if (len == 0)
throw new EmptyStackException();
return elementAt(len - 1);
}
// 测试堆栈是否为空
public boolean empty() {
return size() == 0;
}
// 返回对象在堆栈中的位置，
public synchronized int search(Object o) {
int i = lastIndexOf(o);
if (i >= 0) {
return size() - i;
}
return -1;
}
}
```
**基本操作**（ ： ， ）
- `E push(E)` ：把元素压入栈
- `E pop()` ：把栈顶的元素弹出
- `E peek()` ：取栈顶元素但不弹出
- `boolean empty()` ：堆栈是否为空测试
- `int search(o)` ：返回对象在堆栈中的位置，以 1 为基数
**应用场景**
在解决某个问题的时候，只要求关心最近一次的操作，并且在操作完成了之后，需要向前查找到更前一次的操作。
**案例一：判断字符串是否有效**
给定一个只包括 '('， ， ， ， ，
- 左括号必须用相同类型的右括号闭合
- 左括号必须以正确的顺序闭合
- 空字符串可被认为是有效字符串
**解题思路**：利用一个栈，不断地往里压左括号，一旦遇上了一个右括号，我们就把栈顶的左括号弹出来，表示这是一个合法的组合，以此类推，直到最后判断栈里还有没有左括号剩余。
**案例二：每日温度**
根据每日气温列表，请重新生成一个列表，对应位置的输入是你需要再等待多久温度才会升高超过该日的天数。如果之后都不会升高，请在该位置用 0 来代替。
**解题思路**
- 思路 1： ， ，
- 思路 2： ，
### 队列(Queue)
队列(Queue)和栈不同，队列的最大特点是**先进先出**（
- **栈**：采用**后进先出**（ ）
- **队列**：采用 ** 先进先出**（ ， ）
**实现方式**
可借助**双链表**来实现队列。双链表的头指针允许在队头查看和删除数据，而双链表的尾指针允许在队尾查看和添加数据。
**基本操作**（ ： ， ）
- `int size()` ：获取队列长度
- `boolean add(E)` /`boolean offer(E)`：添加元素到队尾
- `E remove()` /`E poll()`：获取队首元素并从队列中删除
- `E element()` /`E peek()`：获取队首元素但并不从队列中删除
**应用场景**
当需要按照一定的顺序来处理数据，而该数据的数据量在不断地变化的时候，则需要队列来处理。
### 双端队列（ ）
双端队列和普通队列最大的不同在于，它允许我们在队列的头尾两端都能在 O(1) 的时间内进行数据的查看、添加和删除。
**实现方式**
双端队列（ ） ，
**应用场景**
双端队列最常用的地方就是实现一个长度动态变化的窗口或者连续区间，而动态窗口这种数据结构在很多题目里都有运用。
**案例一：滑动窗口最大值**
给定一个数组 nums，
**解题思路**
- 思路 1： ， ，
- 思路 2： ， ， ，
因为双端队列能让上面的这两种操作都能在 O(1) 的时间里完成，所以整个算法的复杂度能控制在 O(n)。
### 树(Tree)
**树(Tree)**是一个分层的数据结构，由节点和连接节点的边组成，是一种特殊的图，它与图最大的区别是没有循环。树的结构十分直观，而树的很多概念定义都有一个相同的特点：递归。各种树解决的问题以及面临的新问题：
- **二叉查找树(BST)**：解决了排序的基本问题，但是由于无法保证平衡，可能退化为链表
- **平衡二叉树(AVL)**：通过旋转解决了平衡的问题，但是旋转操作效率太低
- **红黑树**： ， ， ， ，
- **B树**：通过将二叉树改为多路平衡查找树，解决了树过高的问题
- **B+树**： ， ， ； ，
#### 树的遍历
##### 前序遍历(Preorder Traversal)
**实现原理**：
**应用场景**：运用最多的场合包括在树里进行搜索以及创建一棵新的树。
```java
// 递归实现
public void preOrderTraverse1(TreeNode root) {
if (root != null) {
System.out.print(root.val + "->");
preOrderTraverse1(root.left);
preOrderTraverse1(root.right);
}
}
// 非递归实现
public void preOrderTraverse2(TreeNode root) {
Stack< TreeNode > stack = new Stack< >();
TreeNode node = root;
while (node != null || !stack.empty()) {
if (node != null) {
System.out.print(node.val + "->");
stack.push(node);
node = node.left;
} else {
TreeNode tem = stack.pop();
node = tem.right;
}
}
}
```
##### 中序遍历(Inorder Traversal)
**实现原理**：
**应用场景**：最常见的是二叉搜索树，由于二叉搜索树的性质就是左孩子小于根节点，根节点小于右孩子，对二叉搜索树进行中序遍历的时候，被访问到的节点大小是按顺序进行的。
```java
// 递归实现
public void inOrderTraverse(TreeNode root) {
if (root != null) {
inOrderTraverse(root.left);
System.out.print(root.val + "->");
inOrderTraverse(root.right);
}
}
// 非递归实现
public void inOrderTraverse(TreeNode root) {
Stack< TreeNode > stack = new Stack< >();
TreeNode node = root;
while (node != null || !stack.isEmpty()) {
if (node != null) {
stack.push(node);
node = node.left;
} else {
TreeNode tem = stack.pop();
System.out.print(tem.val + "->");
node = tem.right;
}
}
}
```
##### 后序遍历(Postorder Traversal)
**实现原理**：
**应用场景**：在对某个节点进行分析的时候，需要来自左子树和右子树的信息。收集信息的操作是从树的底部不断地往上进行，好比你在修剪一棵树的叶子，修剪的方法是从外面不断地往根部将叶子一片片地修剪掉。
```java
// 递归实现
public void postOrderTraverse(TreeNode root) {
if (root != null) {
postOrderTraverse(root.left);
postOrderTraverse(root.right);
System.out.print(root.val + "->");
}
}
// 非递归实现
public void postOrderTraverse(TreeNode root) {
TreeNode cur, pre = null;
Stack< TreeNode > stack = new Stack< >();
stack.push(root);
while (!stack.empty()) {
cur = stack.peek();
if ((cur.left == null & & cur.right == null) || (pre != null & & (pre == cur.left || pre == cur.right))) {
System.out.print(cur.val + "->");
stack.pop();
pre = cur;
} else {
if (cur.right != null)
stack.push(cur.right);
if (cur.left != null)
stack.push(cur.left);
}
}
}
```
##### 层次遍历
```java
public void levelOrderTraverse(TreeNode root) {
if (root == null) {
return;
}
Queue< TreeNode > queue = new LinkedList< TreeNode > ();
queue.add(root);
while (!queue.isEmpty()) {
TreeNode node = queue.poll();
System.out.print(node.val + "->");
if (node.left != null) {
queue.add(node.left);
}
if (node.right != null) {
queue.add(node.right);
}
}
}
```
#### 二叉树(Binary Tree)
**二叉树是每个节点最多有两个子节点的树**。二叉树的叶子节点有0个字节点，
**存储结构**：
```java
public class TreeNode {
// 数据域
private Object data;
// 左孩子指针
private TreeNode leftChild;
// 右孩子指针
private TreeNode rightChild;
}
```
##### 斜树
- **左斜树**：所有结点都只有左子树
- **右斜树**：所有结点都只有右子树
##### 满二叉树
一颗二叉树的所有分支结点都存在左子树和右子树，且所有叶子节点都只存在在最下面一层。
##### 完全二叉树
若二叉树的深度为k， ， ， ， ，
#### 二叉搜索树(Binary Search Tree)
二叉搜索树， 又叫**二叉查找树**，它是一棵空树或是具有下列性质的二叉树：
- **若左子树不空，则左子树上所有结点的值均小于它的根结点的值**
- **若右子树不空，则右子树上所有结点的值均大于它的根结点的值**
- **它的左、右子树也分别为二叉搜索树**
**效率总结**
- **访问/查找**：最好时间复杂度 `O(logN)` ，最坏时间复杂度 `O(N)`
- **插入/删除**：最好时间复杂度 `O(logN)` ，最坏时间复杂度 `O(N)`
#### 平衡二叉树(AVL Tree)
二叉查找树在最差情况下竟然和顺序查找效率相当， ， ， ， ， ， ，
**平衡二叉树全称叫做 `平衡二叉搜索（排序）树` ，简称 AVL树**。高度为 `logN` 。本质是一颗二叉查找树， ：
- 它是**一棵空树**或**左右两个子树的高度差**的绝对值不超过 `1`
- 左右两个子树也都是一棵平衡二叉树
如下图， ， ； ， ， ， ， ，
**效率总结**
- 查找：时间复杂度维持在`O(logN)`，不会出现最差情况
- 插入：插入操作时最多需要 `1` 次旋转，其时间复杂度在`O(logN)`左右
- 删除：删除时代价稍大，执行每个删除操作的时间复杂度需要`O(2logN)`
#### 红黑树(Red-Black Tree)
二叉平衡树的严格平衡策略以**牺牲建立查找结构(插入，删除操作)的代**价，
**红黑树是一种含有红、黑结点，并能自平衡的二叉查找树**。高度为 `logN` 。其性质如下：
- **每个结点或是红色的，或是黑色的**
- **根节点是黑色的**
- **每个叶子节点（ ）
- **如果一个节点是红色的，则它的两个子节点都是黑色的**
- **任意一结点到每个叶子结点的路径都包含数量相同的黑节点**
正是红黑树的这5条性质， ，
**效率总结**
- **查找**：最好情况下时间复杂度为`O(logN)`，但在最坏情况下比`AVL`要差一些，但也远远好于`BST`
- **插入/删除**：改变树的平衡性的概率要远远小于`AVL`（ ）
因此需要旋转操作的可能性要小，且一旦需要旋转，插入一个结点最多只需旋转`2`次，删除最多只需旋转`3`次(小于`AVL`的删除操作所需要的旋转次数)。虽然变色操作的时间复杂度在`O(logN)`，但是实际上，这种操作由于简单所需要的代价很小
##### 左旋
- **逆时针旋转两个节点，让一个节点被其右子节点取代，而该节点成为右子节点的左子节点**
- **对x进行左旋，
- **左旋条件：两个连续红节点，并且叔叔节点是黑色 , 下面的红色节点在右子树**
**情况1**：如果当前节点是右子树，并且父节点是左子树。`形如：(900是新插入节点)`
要根据父节点左旋【899】（ ， ） ：
【900】的左子树挂到 【899】的右子树上 ， ，
**情况2**：如果当前节点是右子树，并且父节点是右子树。形如：(【100】是当前节点)
根据祖父节点左旋【56】（ ， ：
【56】变为子节点， ， ： （ ） ， （
##### 右旋
- **顺时针旋转两个节点，让一个节点被其左子节点取代，而该节点成为左子节点的右子节点**
- **对x进行左旋，
- **右旋条件：两个连续红节点，并且叔叔节点是黑色 , 下面的红色节点在左子树**
**情况1**：如果当前节点是左子树，并且父节点也是右子树。形如：(【8000】是当前节点)
根据父节点右旋【9000】（ ， ） ：
【9000】变为子节点， ， ，
**情况2**：如果当前节点是左子树，并且父节点也是左子树。形如：(【899】是当前节点)
根据祖父节点右旋【1000】（ ， ）
【1000】变为子节点， ，
同时： 父节点变黑（ ） ， （ ）
##### 变色
如果当前节点的父亲节点和叔叔节点均是红色，那么执行以下变色操作：
父 --> 黑
叔 --> 黑
爷 --> 红
**无法通过变色而进行旋转的四种场景**
**场景一：左左节点旋转**
这种情况下，父节点和插入的节点都是左节点，如下图(旋转原始图1)这种情况下，我们要插入节点 65。规则如下： ，
按照规则，步骤如下：
**场景二：左右节点旋转**
这种情况下，父节点是左节点，插入的节点是右节点，在旋转原始图 1 中，我们要插入节点 67。规则如下： ， ， ， ：
**场景三：右左节点旋转**
这种情况下，父节点是右节点，插入的节点是左节点，如下图（旋转原始图 2） ， ： ， ，
按照规则，步骤如下：
**场景四：右右节点旋转**
这种情况下，父节点和插入的节点都是右节点，在旋转原始图 2 中，我们要插入节点 70。规则如下： ， ， ：
#### B-树(Balance Tree)
对于在内存中的查找结构而言，红黑树的效率已经非常好了(实际上很多实际应用还对RBT进行了优化)。但是如果是数据量非常大的查找呢？ ， ，
在磁盘中组织查找结构， ， ， ， ， ，
**B树也称B-树、B-Tree， ， ， ， ：
- **每个结点最多有m-1个关键字**
- **根结点最少可以只有1个关键字**
- **非根结点至少有Math.ceil(m/2)-1个关键字**
- **每个结点中的关键字都按照从小到大的顺序排列，每个关键字的左子树中的所有关键字都小于它，而右子树中的所有关键字都大于它**
- **所有叶子结点都位于同一层，或者说根结点到每个叶子结点的长度都相同**
**B树的优势**
- **B树的高度远远小于AVL树和红黑树(B树是一颗“矮胖子”)，
- **对访问局部性原理的利用**。指当一个数据被使用时， ， ； ， ，
**案例分析**
如下图（ ， ） ：
上图是一颗阶数为4的B树。在实际应用中的B树的阶数m都非常大（ ） ， ， （ ） （ ） ， ， ， （ ） （ ） ， ， ，
#### B+树(B+Tree)
**B+树是从B树的变体**。跟B树的不同：
- **内部节点不保存数据，只用于索引**
- **B+树的每个叶子节点之间存在指针相连，而且是单链表**，叶子节点本身依关键字的大小自小而大顺序链接
**案例分析**
如下图， ， ， ， ， ，
**B+树与B树相比有以下优势**
- **更少的IO次数**： ， ， （ ） ， ， ， ， ，
- **更适于范围查询**： ， ， ， ；
- **更稳定的查询效率**： ，
**B+树劣势**
由于键会重复出现，因此**会占用更多的空间**。但是与带来的性能优势相比， ，
#### B*树
是B+树的变体，**在B+树的非根和非叶子结点再增加指向兄弟的指针**，且**定义了非叶子结点关键字个数至少为(2/3)× ， （ ） ：
## 高级数据结构
### 哈希表(Hash Table)
In a hash table, a new index is processed using the keys. And, the element corresponding to that key is stored in the index. This process is called **hashing** .
Let k be a key and h(x) be a hash function. Here, h(k) will give us a new index to store the element linked with k.
### 优先队列（ ）
能保证每次取出的元素都是队列中优先级别最高的。优先级别可以是自定义的，例如，数据的数值越大，优先级越高；或者数据的数值越小，优先级越高。优先级别甚至可以通过各种复杂的计算得到。
**实现方式**
优先队列的本质是一个二叉堆结构。堆在英文里叫 Binary Heap， ， ， ， ， ， ，
**优先队列的性质**
- 数组里的第一个元素 array[0] 拥有最高的优先级别
- 给定一个下标 i，
- 它的父节点所对应的元素下标是 (i-1)/2
- 它的左孩子所对应的元素下标是 2×
- 它的右孩子所对应的元素下标是 2×
- 数组里每个元素的优先级别都要高于它两个孩子的优先级别
**应用场景**：从一堆杂乱无章的数据当中按照一定的顺序（或者优先级）逐步地筛选出部分乃至全部的数据。
**基本操作**
**① 向上筛选（ ）
- 当有新的数据加入到优先队列中，新的数据首先被放置在二叉堆的底部。
- 不断进行向上筛选的操作，即如果发现该数据的优先级别比父节点的优先级别还要高，那么就和父节点的元素相互交换，再接着往上进行比较，直到无法再继续交换为止。
**时间复杂度**：由于二叉堆是一棵完全二叉树，并假设堆的大小为 k， ，
**② 向下筛选（ ）
- 当堆顶的元素被取出时，要更新堆顶的元素来作为下一次按照优先级顺序被取出的对象，需要将堆底部的元素放置到堆顶，然后不断地对它执行向下筛选的操作。
- 将该元素和它的两个孩子节点对比优先级，如果优先级最高的是其中一个孩子，就将该元素和那个孩子进行交换，然后反复进行下去，直到无法继续交换为止。
**时间复杂度**：整个过程就是沿着树的高度往下爬，所以时间复杂度也是 O(logk)。
**案例一：[前 K 个高频元素](https://leetcode-cn.com/problems/top-k-frequent-elements/)**
给你一个整数数组 `nums` 和一个整数 `k` ，请你返回其中出现频率前 `k` 高的元素。你可以按 ** 任意顺序** 返回答案。
**最小堆解法**：题目最终需要返回的是前 k 个频率最大的元素，可以想到借助堆这种数据结构，对于 k 频率之后的元素不用再去处理，进一步优化时间复杂度。
```java
public class Solution {
public List< Integer > topKFrequent(int[] nums, int k) {
// 使用字典，统计每个元素出现的次数，元素为键，元素出现的次数为值
HashMap< Integer , Integer > map = new HashMap();
for(int num : nums){
if (map.containsKey(num)) {
map.put(num, map.get(num) + 1);
} else {
map.put(num, 1);
}
}
// 遍历map，
PriorityQueue< Integer > pq = new PriorityQueue< >(new Comparator< Integer > () {
@Override
public int compare(Integer a, Integer b) {
return map.get(a) - map.get(b);
}
});
for (Integer key : map.keySet()) {
if (pq.size() < k ) {
pq.add(key);
} else if (map.get(key) > map.get(pq.peek())) {
pq.remove();
pq.add(key);
}
}
// 取出最小堆中的元素
List< Integer > res = new ArrayList< >();
while (!pq.isEmpty()) {
res.add(pq.remove());
}
return res;
}
}
```
### 图（ ）
**图(graph)**由多个**节点(vertex)**构成，节点之间阔以互相连接组成一个网络。(x, y)表示一条**边(edge)**，它表示节点 x 与 y 相连。边可能会有**权值(weight/cost)**。
**常见图算法**
- 图的遍历：深度优先、广度优先
- 环的检测：有向图、无向图
- 拓扑排序
- 最短路径算法：
- 连通性相关算法：
- 图的着色、旅行商问题等
### 前缀树（ ）
假如有一个字典，字典里面有如下词："A"， ， ， ， ， ， ，
**性质**
- 每个节点至少包含两个基本属性
- children： ，
- isEnd： ，
- 前缀树的根节点是空的
所谓空，即只利用到这个节点的 children 属性，即只关心在这个字典里，有哪些打头的字符
- 除了根节点，其他所有节点都有可能是单词的结尾，叶子节点一定都是单词的结尾
**实现**
- 创建
- 遍历一遍输入的字符串，对每个字符串的字符进行遍历
- 从前缀树的根节点开始，将每个字符加入到节点的 children 字符集当中
- 如果字符集已经包含了这个字符，则跳过
- 如果当前字符是字符串的最后一个，则把当前节点的 isEnd 标记为真。
由上，创建的方法很直观。前缀树真正强大的地方在于，每个节点还能用来保存额外的信息，比如可以用来记录拥有相同前缀的所有字符串。因此，当用户输入某个前缀时，就能在 O(1) 的时间内给出对应的推荐字符串。
- 搜索
与创建方法类似，从前缀树的根节点出发，逐个匹配输入的前缀字符，如果遇到了就继续往下一层搜索，如果没遇到，就立即返回。
### 线段树（ ）
假设有一个数组 array[0 … n-1]，
- 更新数组元素的数值
- 求数组任意一段区间里元素的总和（或者平均值）
**解法 1：
- 时间复杂度 O(n)。
**解法 2：
- 线段树，就是一种按照二叉树的形式存储数据的结构，每个节点保存的都是数组里某一段的总和。
- 适用于数据很多，而且需要频繁更新并求和的操作。
- 时间复杂度 O(logn)。
**实现**
如数组是 [1, 3, 5, 7, 9, 11]，那么它的线段树如下。
根节点保存的是从下标 0 到下标 5 的所有元素的总和，即 36。左右两个子节点分别保存左右两半元素的总和。按照这样的逻辑不断地切分下去，
### 树状数组（ ）
树状数组（ ）
**举例**：假设有一个数组 array[0 … n-1]，
- 更新数组元素的数值
- 求数组前 k 个元素的总和（或者平均值）
**解法 1：
- 线段树能在 O(logn) 的时间里更新和求解前 k 个元素的总和
**解法 2：
- 该问题只要求求解前 k 个元素的总和，并不要求任意一个区间
- 树状数组可以在 O(logn) 的时间里完成上述的操作
- 相对于线段树的实现，树状数组显得更简单
**树状数组特点**
- 它是利用数组来表示多叉树的结构，在这一点上和优先队列有些类似，只不过，优先队列是用数组来表示完全二叉树，而树状数组是多叉树。
- 树状数组的第一个元素是空节点。
- 如果节点 tree[y] 是 tree[x] 的父节点， ： & (-x))。
### 散列表(Hash)
散列表又称为**哈希表**，是将某个对象变换为唯一标识符，该标识符通常用一个短的随机字母和数字组成的字符串来代表。哈希可以用来实现各种数据结构，其中最常用的就是**哈希表(hash table)**。哈希表通常由数组实现。
### 二叉堆
**最大堆**：任何一个父节点的值，都 ** 大于** 或 ** 等于** 它左、右子节点的值，**堆顶** 是整个堆中的 ** 最大** 元素。
**最小堆**：任何一个父节点的值，都 ** 小于** 或 ** 等于** 它左、右孩子节点的值，**堆顶** 是整个堆中的 ** 最小** 元素。
# Algorithm
## 复杂度
**相关概念**
- **稳定**： ， ，
- **不稳定**： ， ，
- **时间复杂度**： ，
- **空间复杂度：**是指算法在计算机内执行时所需存储空间的度量，
**时间复杂度与时间效率**： < O ( log2N ) < O ( n ) < O ( N \* log2N ) < O ( N2 ) < O ( N3 ) < 2N < 3N < N !
一般来说， ， ， （ ， ）
### 常数阶
```java
int sum = 0,n = 100; //执行一次
sum = (1+n)*n/2; //执行一次
System.out.println (sum); //执行一次
```
上面算法的运行的次数的函数为 f(n)=3， ， ，
### 线性阶
线性阶主要要分析循环结构的运行情况，如下所示：
```java
for (int i = 0; i < n ; i + + ) {
//时间复杂度为O(1)的算法
...
}
```
上面算法循环体中的代码执行了n次，
### 对数阶
接着看如下代码：
```java
int number = 1;
while (number < n ) {
number = number * 2;
//时间复杂度为O(1)的算法
...
}
```
可以看出上面的代码，随着 number 每次乘以 2 后，都会越来越接近 n， ， ，
### 平方阶
下面的代码是循环嵌套：
```java
for (int i = 0; i < n ; i + + ) { for ( int j = 0; j < n ; i + + ) { / / 复 杂 度 为 O ( 1 ) 的 算 法 . . . } }
```
内层循环的时间复杂度在讲到线性阶时就已经得知是O(n)， ，
## 算法思想
### 分治(Divide and Conquer)
分治算法思想很大程度上是基于递归的，也比较适合用递归来实现。顾名思义，分而治之。一般分为以下三个过程：
- **分解**：将原问题分解成一系列子问题
- **解决**：递归求解各个子问题，若子问题足够小，则直接求解
- **合并**：将子问题的结果合并成原问题
比较经典的应用就是`归并排序 (Merge Sort)` 以及`快速排序 (Quick Sort)` 等。我们来从归并排序理解分治思想，归并排序就是将待排序数组不断二分为规模更小的子问题处理，再将处理好的子问题合并起来。
### 贪心(Greedy)
`贪心算法` 是`动态规划`算法的一个子集，可以更高效解决一部分更特殊的问题。实际上，用贪心算法解决问题的思路，并不总能给出最优解。因为它在每一步的决策中，选择目前最优策略，不考虑全局是不是最优。
**贪心算法+双指针求解**
- 给一个孩子的饼干应当尽量小并且能满足孩子，大的留来满足胃口大的孩子
- 因为胃口小的孩子最容易得到满足，所以优先满足胃口小的孩子需求
- 按照从小到大的顺序使用饼干尝试是否可满足某个孩子
- 当饼干 j >= 胃口 i 时，饼干满足胃口，更新满足的孩子数并移动指针 `i++ j++ res++`
- 当饼干 j < 胃口 i 时，饼干不能满足胃口，需要换大的 `j++`
### 回溯(Backtracking)
使用回溯法进行求解，回溯是一种通过穷举所有可能情况来找到所有解的算法。如果一个候选解最后被发现并不是可行解，回溯算法会舍弃它，并在前面的一些步骤做出一些修改，并重新尝试找到可行解。究其本质，其实就是枚举。
- 如果没有更多的数字需要被输入，说明当前的组合已经产生
- 如果还有数字需要被输入：
- 遍历下一个数字所对应的所有映射的字母
- 将当前的字母添加到组合最后，也就是 `str + tmp[r]`
### 动态规划(Dynamic Programming)
虽然动态规划的最终版本 (降维再去维) 大都不是递归，但解题的过程还是离开不递归的。新手可能会觉得动态规划思想接受起来比较难，确实，动态规划求解问题的过程不太符合人类常规的思维方式，我们需要切换成机器思维。使用动态规划思想解题，首先要明确动态规划的三要素。动态规划三要素：
- `重叠子问题` ：切换机器思维，自底向上思考
- `最优子结构` ：子问题的最优解能够推出原问题的优解
- `状态转移方程` ：
## 算法模板
### 递归模板
```java
public void recur(int level, int param) {
// terminator
if (level > MAX_LEVEL) {
// process result
return;
}
// process current logic
process(level, param);
// drill down
recur(level + 1, newParam);
// restore current status
}
```
**List转树形结构**
- **方案一：两层循环实现建树**
- **方案二：使用递归方法建树**
```java
public class TreeNode {
private String id;
private String parentId;
private String name;
private List< TreeNode > children;
/**
* 方案一：两层循环实现建树
*
* @param treeNodes 传入的树节点列表
* @return
*/
public static List< TreeNode > bulid(List< TreeNode > treeNodes) {
List< TreeNode > trees = new ArrayList< >();
for (TreeNode treeNode : treeNodes) {
if ("0".equals(treeNode.getParentId())) {
trees.add(treeNode);
}
for (TreeNode it : treeNodes) {
if (it.getParentId() == treeNode.getId()) {
if (treeNode.getChildren() == null) {
treeNode.setChildren(new ArrayList< TreeNode > ());
}
treeNode.getChildren().add(it);
}
}
}
return trees;
}
/**
* 方案二：使用递归方法建树
*
* @param treeNodes
* @return
*/
public static List< TreeNode > buildByRecursive(List< TreeNode > treeNodes) {
List< TreeNode > trees = new ArrayList< >();
for (TreeNode treeNode : treeNodes) {
if ("0".equals(treeNode.getParentId())) {
trees.add(findChildren(treeNode, treeNodes));
}
}
return trees;
}
/**
* 递归查找子节点
*
* @param treeNodes
* @return
*/
private static TreeNode findChildren(TreeNode treeNode, List< TreeNode > treeNodes) {
for (TreeNode it : treeNodes) {
if (treeNode.getId().equals(it.getParentId())) {
if (treeNode.getChildren() == null) {
treeNode.setChildren(new ArrayList< >());
}
treeNode.getChildren().add(findChildren(it, treeNodes));
}
}
return treeNode;
}
}
```
### 回溯模板
### DFS模板
### BFS模板
## 查找算法
### 顺序查找
就是一个一个依次查找。
### 二分查找
二分查找又叫折半查找，从有序列表的初始候选区`li[0:n]`开始，通过对待查找的值与候选区中间值的比较，可以使候选区减少一半。如果待查值小于候选区中间值，则只需比较中间值左边的元素，减半查找范围。依次类推依次减半。
- 二分查找的前提：**列表有序**
- 二分查找的有点：**查找速度快**
- 二分查找的时间复杂度为：**O(logn)**
JAVA代码如下：
```java
/**
* 执行递归二分查找，返回第一次出现该值的位置
*
* @param array 已排序的数组
* @param start 开始位置， ：
* @param end 结束位置， ：
* @param findValue 需要找的值
* @return 值在数组中的位置，
*/
public static int searchRecursive(int[] array, int start, int end, int findValue) {
// 如果数组为空，直接返回-1，
if (array == null) {
return -1;
}
if (start < = end) {
// 中间位置
int middle = (start + end) / 1;
// 中值
int middleValue = array[middle];
if (findValue == middleValue) {
// 等于中值直接返回
return middle;
} else if (findValue < middleValue ) {
// 小于中值时在中值前面找
return searchRecursive(array, start, middle - 1, findValue);
} else {
// 大于中值在中值后面找
return searchRecursive(array, middle + 1, end, findValue);
}
} else {
// 返回-1，
return -1;
}
}
/**
* 循环二分查找，返回第一次出现该值的位置
*
* @param array 已排序的数组
* @param findValue 需要找的值
* @return 值在数组中的位置，
*/
public static int searchLoop(int[] array, int findValue) {
// 如果数组为空，直接返回-1，
if (array == null) {
return -1;
}
// 起始位置
int start = 0;
// 结束位置
int end = array.length - 1;
while (start < = end) {
// 中间位置
int middle = (start + end) / 2;
// 中值
int middleValue = array[middle];
if (findValue == middleValue) {
// 等于中值直接返回
return middle;
} else if (findValue < middleValue ) {
// 小于中值时在中值前面找
end = middle - 1;
} else {
// 大于中值在中值后面找
start = middle + 1;
}
}
// 返回-1，
return -1;
}
```
### 插值查找
插值查找算法类似于二分查找， ， ， ，
 ** 改为** 
**注意事项**
- 对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找，速度较快
- 关键字分布不均匀的情况下，该方法不一定比折半查找要好
```java
/**
* 插值查找
*
* @param arr 已排序的数组
* @param left 开始位置， ：
* @param right 结束位置， ：
* @param findValue
* @return
*/
public static int insertValueSearch(int[] arr, int left, int right, int findValue) {
//注意： < arr [ 0 ] 和 findVal > arr[arr.length - 1] 必须需要, 否则我们得到的 mid 可能越界
if (left > right || findValue < arr [ 0 ] | | findValue > arr[arr.length - 1]) {
return -1;
}
// 求出mid, 自适应
int mid = left + (right - left) * (findValue - arr[left]) / (arr[right] - arr[left]);
int midValue = arr[mid];
if (findValue > midValue) {
// 向右递归
return insertValueSearch(arr, mid + 1, right, findValue);
} else if (findValue < midValue ) {
// 向左递归
return insertValueSearch(arr, left, mid - 1, findValue);
} else {
return mid;
}
}
```
### 斐波那契查找
黄金分割点是指把一条线段分割为两部分， ，
斐波那契查找原理与前两种相似，仅仅改变了中间结点(mid)的位置， ， ，
JAVA代码如下：
```java
/**
* 因为后面我们mid=low+F(k-1)-1， ，
* < p >
* 非递归方法得到一个斐波那契数列
*
* @return
*/
private static int[] getFibonacci() {
int[] fibonacci = new int[20];
fibonacci[0] = 1;
fibonacci[1] = 1;
for (int i = 2; i < fibonacci.length ; i + + ) {
fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2];
}
return fibonacci;
}
/**
* 编写斐波那契查找算法
* < p >
* 使用非递归的方式编写算法
*
* @param arr 数组
* @param findValue 我们需要查找的关键码(值)
* @return 返回对应的下标，如果没有-1
*/
public static int fibonacciSearch(int[] arr, int findValue) {
int low = 0;
int high = arr.length - 1;
int k = 0;// 表示斐波那契分割数值的下标
int mid = 0;// 存放mid值
int[] fibonacci = getFibonacci();// 获取到斐波那契数列
// 获取到斐波那契分割数值的下标
while (high > fibonacci[k] - 1) {
k++;
}
// 因为 fibonacci[k] 值可能大于 arr 的 长度， ，
int[] temp = Arrays.copyOf(arr, fibonacci[k]);
// 实际上需求使用arr数组最后的数填充 temp
for (int i = high + 1; i < temp.length ; i + + ) {
temp[i] = arr[high];
}
// 使用while来循环处理，
while (low < = high) {
mid = low + fibonacci[k] - 1;
if (findValue < temp [ mid ] ) {
high = mid - 1;
k--;
} else if (findValue > temp[mid]) {
low = mid + 1;
k++;
} else {
return Math.min(mid, high);
}
}
return -1;
}
```
## 搜素算法
### 深度优先搜索(DFS)
深度优先搜索（ ）
**DFS解决的是连通性的问题**。即给定两个点，一个是起始点，一个是终点，判断是不是有一条路径能从起点连接到终点。起点和终点，也可以指的是某种起始状态和最终的状态。问题的要求并不在乎路径是长还是短，只在乎有还是没有。
**代码案例**
```java
/**
* Depth-First Search(DFS)
* < p >
* 从根节点出发，沿着左子树方向进行纵向遍历，直到找到叶子节点为止。然后回溯到前一个节点，进行右子树节点的遍历，直到遍历完所有可达节点为止。
* < p >
* 数据结构：栈
* 父节点入栈，父节点出栈，先右子节点入栈，后左子节点入栈。递归遍历全部节点即可
*
* @author lry
*/
public class DepthFirstSearch {
/**
* 树节点
*
* @param < V >
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public static class TreeNode< V > {
private V value;
private List< TreeNode < V > > childList;
// 二叉树节点支持如下
public TreeNode< V > getLeft() {
if (childList == null || childList.isEmpty()) {
return null;
}
return childList.get(0);
}
public TreeNode< V > getRight() {
if (childList == null || childList.isEmpty()) {
return null;
}
return childList.get(1);
}
}
/**
* 模型：
* .......A
* ...../ \
* ....B C
* .../ \ / \
* ..D E F G
* ./ \ / \
* H I J K
*/
public static void main(String[] args) {
TreeNode< String > treeNodeA = new TreeNode< >("A", new ArrayList< >());
TreeNode< String > treeNodeB = new TreeNode< >("B", new ArrayList< >());
TreeNode< String > treeNodeC = new TreeNode< >("C", new ArrayList< >());
TreeNode< String > treeNodeD = new TreeNode< >("D", new ArrayList< >());
TreeNode< String > treeNodeE = new TreeNode< >("E", new ArrayList< >());
TreeNode< String > treeNodeF = new TreeNode< >("F", new ArrayList< >());
TreeNode< String > treeNodeG = new TreeNode< >("G", new ArrayList< >());
TreeNode< String > treeNodeH = new TreeNode< >("H", new ArrayList< >());
TreeNode< String > treeNodeI = new TreeNode< >("I", new ArrayList< >());
TreeNode< String > treeNodeJ = new TreeNode< >("J", new ArrayList< >());
TreeNode< String > treeNodeK = new TreeNode< >("K", new ArrayList< >());
// A->B,C
treeNodeA.getChildList().add(treeNodeB);
treeNodeA.getChildList().add(treeNodeC);
// B->D,E
treeNodeB.getChildList().add(treeNodeD);
treeNodeB.getChildList().add(treeNodeE);
// C->F,G
treeNodeC.getChildList().add(treeNodeF);
treeNodeC.getChildList().add(treeNodeG);
// D->H,I
treeNodeD.getChildList().add(treeNodeH);
treeNodeD.getChildList().add(treeNodeI);
// G->J,K
treeNodeG.getChildList().add(treeNodeJ);
treeNodeG.getChildList().add(treeNodeK);
System.out.println("非递归方式");
dfsNotRecursive(treeNodeA);
System.out.println();
System.out.println("前续遍历");
dfsPreOrderTraversal(treeNodeA, 0);
System.out.println();
System.out.println("后续遍历");
dfsPostOrderTraversal(treeNodeA, 0);
System.out.println();
System.out.println("中续遍历");
dfsInOrderTraversal(treeNodeA, 0);
}
/**
* 非递归方式
*
* @param tree
* @param < V >
*/
public static < V > void dfsNotRecursive(TreeNode< V > tree) {
if (tree != null) {
// 次数之所以用 Map 只是为了保存节点的深度，如果没有这个需求可以改为 Stack< TreeNode < V > >
Stack< Map < TreeNode < V > , Integer>> stack = new Stack< >();
Map< TreeNode < V > , Integer> root = new HashMap< >();
root.put(tree, 0);
stack.push(root);
while (!stack.isEmpty()) {
Map< TreeNode < V > , Integer> item = stack.pop();
TreeNode< V > node = item.keySet().iterator().next();
int depth = item.get(node);
// 打印节点值以及深度
System.out.print("-->[" + node.getValue().toString() + "," + depth + "]");
if (node.getChildList() != null & & !node.getChildList().isEmpty()) {
for (TreeNode< V > treeNode : node.getChildList()) {
Map< TreeNode < V > , Integer> map = new HashMap< >();
map.put(treeNode, depth + 1);
stack.push(map);
}
}
}
}
}
/**
* 递归前序遍历方式
* < p >
* 前序遍历(Pre-Order Traversal) ：指先访问根，然后访问子树的遍历方式，二叉树则为：根->左->右
*
* @param tree
* @param depth
* @param < V >
*/
public static < V > void dfsPreOrderTraversal(TreeNode< V > tree, int depth) {
if (tree != null) {
// 打印节点值以及深度
System.out.print("-->[" + tree.getValue().toString() + "," + depth + "]");
if (tree.getChildList() != null & & !tree.getChildList().isEmpty()) {
for (TreeNode< V > item : tree.getChildList()) {
dfsPreOrderTraversal(item, depth + 1);
}
}
}
}
/**
* 递归后序遍历方式
* < p >
* 后序遍历(Post-Order Traversal)：指先访问子树，然后访问根的遍历方式，二叉树则为：左->右->根
*
* @param tree
* @param depth
* @param < V >
*/
public static < V > void dfsPostOrderTraversal(TreeNode< V > tree, int depth) {
if (tree != null) {
if (tree.getChildList() != null & & !tree.getChildList().isEmpty()) {
for (TreeNode< V > item : tree.getChildList()) {
dfsPostOrderTraversal(item, depth + 1);
}
}
// 打印节点值以及深度
System.out.print("-->[" + tree.getValue().toString() + "," + depth + "]");
}
}
/**
* 递归中序遍历方式
* < p >
* 中序遍历(In-Order Traversal)：指先访问左（右）子树，然后访问根，最后访问右（左）子树的遍历方式，二叉树则为：左->根->右
*
* @param tree
* @param depth
* @param < V >
*/
public static < V > void dfsInOrderTraversal(TreeNode< V > tree, int depth) {
if (tree.getLeft() != null) {
dfsInOrderTraversal(tree.getLeft(), depth + 1);
}
// 打印节点值以及深度
System.out.print("-->[" + tree.getValue().toString() + "," + depth + "]");
if (tree.getRight() != null) {
dfsInOrderTraversal(tree.getRight(), depth + 1);
}
}
}
```
### 广度优先搜索(BFS)
广度优先搜索（ ）
**BFS一般用来解决最短路径的问题**。和深度优先搜索不同，广度优先的搜索是从起始点出发，一层一层地进行，每层当中的点距离起始点的步数都是相同的，当找到了目的地之后就可以立即结束。广度优先的搜索可以同时从起始点和终点开始进行，称之为双端 BFS。这种算法往往可以大大地提高搜索的效率。
**代码案例**
```java
/**
* Breadth-First Search(BFS)
* < p >
* 从根节点出发，在横向遍历二叉树层段节点的基础上纵向遍历二叉树的层次。
* < p >
* 数据结构：队列
* 父节点入队，父节点出队列，先左子节点入队，后右子节点入队。递归遍历全部节点即可
*
* @author lry
*/
public class BreadthFirstSearch {
/**
* 树节点
*
* @param < V >
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public static class TreeNode< V > {
private V value;
private List< TreeNode < V > > childList;
}
/**
* 模型：
* .......A
* ...../ \
* ....B C
* .../ \ / \
* ..D E F G
* ./ \ / \
* H I J K
*/
public static void main(String[] args) {
TreeNode< String > treeNodeA = new TreeNode< >("A", new ArrayList< >());
TreeNode< String > treeNodeB = new TreeNode< >("B", new ArrayList< >());
TreeNode< String > treeNodeC = new TreeNode< >("C", new ArrayList< >());
TreeNode< String > treeNodeD = new TreeNode< >("D", new ArrayList< >());
TreeNode< String > treeNodeE = new TreeNode< >("E", new ArrayList< >());
TreeNode< String > treeNodeF = new TreeNode< >("F", new ArrayList< >());
TreeNode< String > treeNodeG = new TreeNode< >("G", new ArrayList< >());
TreeNode< String > treeNodeH = new TreeNode< >("H", new ArrayList< >());
TreeNode< String > treeNodeI = new TreeNode< >("I", new ArrayList< >());
TreeNode< String > treeNodeJ = new TreeNode< >("J", new ArrayList< >());
TreeNode< String > treeNodeK = new TreeNode< >("K", new ArrayList< >());
// A->B,C
treeNodeA.getChildList().add(treeNodeB);
treeNodeA.getChildList().add(treeNodeC);
// B->D,E
treeNodeB.getChildList().add(treeNodeD);
treeNodeB.getChildList().add(treeNodeE);
// C->F,G
treeNodeC.getChildList().add(treeNodeF);
treeNodeC.getChildList().add(treeNodeG);
// D->H,I
treeNodeD.getChildList().add(treeNodeH);
treeNodeD.getChildList().add(treeNodeI);
// G->J,K
treeNodeG.getChildList().add(treeNodeJ);
treeNodeG.getChildList().add(treeNodeK);
System.out.println("递归方式");
bfsRecursive(Arrays.asList(treeNodeA), 0);
System.out.println();
System.out.println("非递归方式");
bfsNotRecursive(treeNodeA);
}
/**
* 递归遍历
*
* @param children
* @param depth
* @param < V >
*/
public static < V > void bfsRecursive(List< TreeNode < V > > children, int depth) {
List< TreeNode < V > > thisChildren, allChildren = new ArrayList< >();
for (TreeNode< V > child : children) {
// 打印节点值以及深度
System.out.print("-->[" + child.getValue().toString() + "," + depth + "]");
thisChildren = child.getChildList();
if (thisChildren != null & & thisChildren.size() > 0) {
allChildren.addAll(thisChildren);
}
}
if (allChildren.size() > 0) {
bfsRecursive(allChildren, depth + 1);
}
}
/**
* 非递归遍历
*
* @param tree
* @param < V >
*/
public static < V > void bfsNotRecursive(TreeNode< V > tree) {
if (tree != null) {
// 跟上面一样，使用 Map 也只是为了保存树的深度，没这个需要可以不用 Map
Queue< Map < TreeNode < V > , Integer>> queue = new ArrayDeque< >();
Map< TreeNode < V > , Integer> root = new HashMap< >();
root.put(tree, 0);
queue.offer(root);
while (!queue.isEmpty()) {
Map< TreeNode < V > , Integer> itemMap = queue.poll();
TreeNode< V > node = itemMap.keySet().iterator().next();
int depth = itemMap.get(node);
//打印节点值以及深度
System.out.print("-->[" + node.getValue().toString() + "," + depth + "]");
if (node.getChildList() != null & & !node.getChildList().isEmpty()) {
for (TreeNode< V > child : node.getChildList()) {
Map< TreeNode < V > , Integer> map = new HashMap< >();
map.put(child, depth + 1);
queue.offer(map);
}
}
}
}
}
}
```
### 迪杰斯特拉算法(Dijkstra)
**迪杰斯特拉(Dijkstra)算法** 是典型最短路径算法，用于计算一个节点到其他节点的最短路径。它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。
**基本思想**
通过Dijkstra计算图G中的最短路径时，
此外， ，
初始时， ； ， ， ， ； ， ， ， ； ，
**操作步骤**
- 初始时， ； ， ， ， ，
- U中选出"距离最短的顶点k"， ； ，
- 更新U中各个顶点到起点s的距离。之所以更新U中顶点的距离， ， ； ，
- 重复步骤(2)和(3)，直到遍历完所有顶点
**迪杰斯特拉算法图解**
以上图G4为例， ：
** 代码案例**
```java
public class Dijkstra {
// 代表正无穷
public static final int M = 10000;
public static String[] names = new String[]{"A", "B", "C", "D", "E", "F", "G",};
public static void main(String[] args) {
// 二维数组每一行分别是 A、B、C、D、E 各点到其余点的距离,
// A -> A 距离为0, 常量M 为正无穷
int[][] weight1 = {
{0, 12, M, M, M, 16, 14},
{12, 0, 10, M, M, 7, M},
{M, 10, 0, 3, 5, 6, M},
{M, M, 3, 0, 4, M, M},
{M, M, 5, 4, 0, 2, 8},
{16, 7, 6, M, 2, 0, 9},
{14, M, M, M, 8, 9, 0}
};
int start = 0;
int[] shortPath = dijkstra(weight1, start);
System.out.println("===============");
for (int i = 0; i < shortPath.length ; i + + ) {
System.out.println("从" + names[start] + "出发到" + names[i] + "的最短距离为：" + shortPath[i]);
}
}
/**
* Dijkstra算法
*
* @param weight 图的权重矩阵
* @param start 起点编号start（ ， ）
* @return 返回一个int[] 数组，
*/
public static int[] dijkstra(int[][] weight, int start) {
// 顶点个数
int n = weight.length;
// 标记当前该顶点的最短路径是否已经求出,1表示已求出
int[] visited = new int[n];
// 保存start到其他各点的最短路径
int[] shortPath = new int[n];
// 保存start到其他各点最短路径的字符串表示
String[] path = new String[n];
for (int i = 0; i < n ; i + + ) {
path[i] = names[start] + "-->" + names[i];
}
// 初始化，第一个顶点已经求出
shortPath[start] = 0;
visited[start] = 1;
// 要加入n-1个顶点
for (int count = 1; count < n ; count + + ) {
// 选出一个距离初始顶点start最近的未标记顶点
int k = -1;
int dMin = Integer.MAX_VALUE;
for (int i = 0; i < n ; i + + ) {
if (visited[i] == 0 & & weight[start][i] < dMin ) {
dMin = weight[start][i];
k = i;
}
}
// 将新选出的顶点标记为已求出最短路径，
shortPath[k] = dMin;
visited[k] = 1;
// 以k为中间点，
for (int i = 0; i < n ; i + + ) {
// 如果 '起始点到当前点距离' + '当前点到某点距离' < '起始点到某点距离', 则更新
if (visited[i] == 0 & & weight[start][k] + weight[k][i] < weight [ start ] [ i ] ) {
weight[start][i] = weight[start][k] + weight[k][i];
path[i] = path[k] + "-->" + names[i];
}
}
}
for (int i = 0; i < n ; i + + ) {
System.out.println("从" + names[start] + "出发到" + names[i] + "的最短路径为：" + path[i]);
}
return shortPath;
}
}
```
### kruskal(克鲁斯卡尔)算法
https://www.cnblogs.com/skywang12345/category/508186.html
## 排序算法
十种常见排序算法可以分为两大类：
- **非线性时间比较类排序**
通过比较来决定元素间的相对次序，
- **线性时间非比较类排序**
不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。
### 冒泡排序（ ）
**循环遍历多次每次从前往后把大元素往后调，每次确定一个最大(最小)元素，多次后达到排序序列。**这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
**算法步骤**
- 比较相邻的元素。如果第一个比第二个大，就交换它们两个
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数
- 针对所有的元素重复以上的步骤，除了最后一个
- 重复步骤1~3，
**代码实现**
```java
/**
* 冒泡排序
* < p >
* 描述：每轮连续比较相邻的两个数，前数大于后数，则进行替换。每轮完成后，本轮最大值已被移至最后
*
* @param arr 待排序数组
*/
public static int[] bubbleSort(int[] arr) {
for (int i = 0; i < arr.length - 1 ; i + + ) {
for (int j = 0; j < arr.length - 1 - i ; j + + ) {
// 每次比较2个相邻的数,前一个小于后一个
if (arr[j] > arr[j + 1]) {
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
return arr;
}
```
以下是冒泡排序算法复杂度:
| 平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 |
| :------------- | :------- | :------- | :--------- |
| O(n²) | O(n) | O(n²) | O(1) |
冒泡排序是最容易实现的排序, 最坏的情况是每次都需要交换, 共需遍历并交换将近n²/2次, 时间复杂度为O(n²). 最佳的情况是内循环遍历一次后发现排序是对的, 因此退出循环, 时间复杂度为O(n)。平均来讲, 时间复杂度为O(n²). 由于冒泡排序中只有缓存的temp变量需要内存空间, 因此空间复杂度为常量O(1)。
Tips: 由于冒泡排序只在相邻元素大小不符合要求时才调换他们的位置, 它并不改变相同元素之间的相对顺序, 因此它是稳定的排序算法。
### 选择排序（ ）
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
**算法描述**
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
- 初始状态：
- 第i趟排序(i=1,2,3…n-1)开始时， ） ， ，
- n-1趟结束，
**代码实现**
```java
/**
* 选择排序
* < p >
* 描述：每轮选择出最小值，然后依次放置最前面
*
* @param arr 待排序数组
*/
public static int[] selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1 ; i + + ) {
// 选最小的记录
int min = i;
for (int j = i + 1; j < arr.length ; j + + ) {
if (arr[min] > arr[j]) {
min = j;
}
}
// 内层循环结束后， ， ：
if (min != i) {
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}
return arr;
}
```
以下是选择排序复杂度:
| 平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 |
| :------------- | :------- | :------- | :--------- |
| O(n²) | O(n²) | O(n²) | O(1) |
选择排序的简单和直观名副其实， ， ， ， ，
### 插入排序（ ）
插入排序（ ） ， ， ， ， `直接插入排序` 、`折半插入排序`(又称二分插入排序)、`链表插入排序`、`希尔排序` 。
**算法描述**
一般来说， ：
- 从第一个元素开始，该元素可以认为已经被排序
- 取出下一个元素，在已经排序的元素序列中从后向前扫描
- 如果该元素（已排序）大于新元素，将该元素移到下一位置
- 重复步骤3，
- 将新元素插入到该位置后
- 重复步骤2~5
**代码实现**
```java
/**
* 直接插入排序
* < p >
* 1. 从第一个元素开始，该元素可以认为已经被排序
* 2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
* 3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
* 4. 重复步骤3，
* 5. 将新元素插入到该位置后
* 6. 重复步骤2~5
*
* @param arr 待排序数组
*/
public static int[] insertionSort(int[] arr) {
for (int i = 1; i < arr.length ; i + + ) {
// 取出下一个元素，在已经排序的元素序列中从后向前扫描
int temp = arr[i];
for (int j = i; j >= 0; j--) {
if (j > 0 & & arr[j - 1] > temp) {
// 如果该元素（ ） ，
arr[j] = arr[j - 1];
} else {
// 将新元素插入到该位置后
arr[j] = temp;
break;
}
}
}
return arr;
}
/**
* 折半插入排序
* < p >
* 往前找合适的插入位置时采用二分查找的方式，即折半插入
* < p >
* 交换次数较多的实现
*
* @param arr 待排序数组
*/
public static int[] insertionBinarySort(int[] arr) {
for (int i = 1; i < arr.length ; i + + ) {
if (arr[i] < arr [ i - 1 ] ) {
int tmp = arr[i];
// 记录搜索范围的左边界,右边界
int low = 0, high = i - 1;
while (low < = high) {
// 记录中间位置Index
int mid = (low + high) / 2;
// 比较中间位置数据和i处数据大小，
if (arr[mid] < tmp ) {
// 左边指针则一只中间位置+1
low = mid + 1;
} else {
// 右边指针则一只中间位置-1
high = mid - 1;
}
}
// 将low~i处数据整体向后移动1位
for (int j = i; j > low; j--) {
arr[j] = arr[j - 1];
}
arr[low] = tmp;
}
}
return arr;
}
```
插入排序复杂度：
| 平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 |
| :------------- | :------- | :------- | :--------- |
| O(n²) | O(n) | O(n²) | O(1) |
Tips： ， ， （
### 希尔排序（ ）
1959年Shell发明，
**算法描述**
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
- 选择一个增量序列t1， ， ， ， ，
- 按增量序列个数k，
- 每趟排序， ， ，
**代码实现**
```java
/**
* 希尔排序
* < p >
* 1. 选择一个增量序列t1， ， ， ， ， ； （ ， ， ）
* 2. 按增量序列个数k，
* 3. 每趟排序， ，
* 仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
*
* @param arr 待排序数组
*/
public static int[] shellSort(int[] arr) {
int gap = arr.length / 2;
// 不断缩小gap，
for (; gap > 0; gap /= 2) {
// 使用当前gap进行组内插入排序
for (int j = 0; (j + gap) < arr.length ; j + + ) {
for (int k = 0; (k + gap) < arr.length ; k + = gap ) {
if (arr[k] > arr[k + gap]) {
int temp = arr[k + gap];
arr[k + gap] = arr[k];
arr[k] = temp;
}
}
}
}
return arr;
}
```
以下是希尔排序复杂度:
| 平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 |
| :------------- | :--------- | :--------- | :--------- |
| O(nlog2 n) | O(nlog2 n) | O(nlog2 n) | O(1) |
Tips： ， （ ）
### 归并排序（ ）
**简介**
**基本思想**： （ ） （ ） ， ，
**场景使用**
**应用场景**：内存少的时候使用，可以进行**并行计算**的时候使用。
**步骤**：
- 选择**相邻**两个数组成一个有序序列
- 选择相邻的两个有序序列组成一个有序序列
- 重复第二步，直到全部组成一个**有序**序列
**算法描述**
**a.递归法**（ ）
①. 将序列每相邻两个数字进行归并操作，形成 floor(n/2)个序列，排序后每个序列包含两个元素；
②. 将上述序列再次归并，形成 floor(n/4)个序列，每个序列包含四个元素；
③. 重复步骤②，直到所有元素排序完毕。
**b.迭代法**
①. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
②. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
③. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
④. 重复步骤③直到某一指针到达序列尾
⑤. 将另一序列剩下的所有元素直接复制到合并序列尾
**代码实现**
```java
/**
* 归并排序（递归）
* < p >
* ①. 将序列每相邻两个数字进行归并操作，形成 floor(n/2)个序列，排序后每个序列包含两个元素；
* ②. 将上述序列再次归并，形成 floor(n/4)个序列，每个序列包含四个元素；
* ③. 重复步骤②，直到所有元素排序完毕。
*
* @param arr 待排序数组
*/
public static int[] mergeSort(int[] arr) {
return mergeSort(arr, 0, arr.length - 1);
}
private static int[] mergeSort(int[] arr, int low, int high) {
int center = (high + low) / 2;
if (low < high ) {
// 递归， ， ，
mergeSort(arr, low, center);
mergeSort(arr, center + 1, high);
// 当数组不能再分，开始归并排序
mergeSort(arr, low, center, high);
}
return arr;
}
private static void mergeSort(int[] a, int low, int mid, int high) {
int[] temp = new int[high - low + 1];
int i = low, j = mid + 1, k = 0;
// 把较小的数先移到新数组中
while (i < = mid & & j < = high) {
if (a[i] < a [ j ] ) {
temp[k++] = a[i++];
} else {
temp[k++] = a[j++];
}
}
// 把左边剩余的数移入数组
while (i < = mid) {
temp[k++] = a[i++];
}
// 把右边边剩余的数移入数组
while (j < = high) {
temp[k++] = a[j++];
}
// 把新数组中的数覆盖nums数组
for (int x = 0; x < temp.length ; x + + ) {
a[x + low] = temp[x];
}
}
```
以下是归并排序算法复杂度:
| 平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 |
| :------------- | :-------- | :-------- | :--------- |
| O(nlog₂n) | O(nlog₂n) | O(nlog₂n) | O(n) |
从效率上看，归并排序可算是排序算法中的”佼佼者”. 假设数组长度为n， ， ，
Tips： ， ， ， ）
### 快速排序（ ）
快速排序（ ） ， ， ， ， ，
**算法描述**
快速排序使用分治法来把一个串（ ） （ ） ：
- 从数列中挑出一个元素，称为 “基准”（ ）
- 重新排序数列， ， （ ） ， （ ）
- 递归地（ ）
**代码实现**
```java
/**
* 快速排序（递归）
* < p >
* ①. 从数列中挑出一个元素，称为"基准"（ ）
* ②. 重新排序数列， ， （ ） ， （ ）
* ③. 递归地（ ）
*
* @param arr 待排序数组
*/
public static int[] quickSort(int[] arr) {
return quickSort(arr, 0, arr.length - 1);
}
private static int[] quickSort(int[] arr, int low, int high) {
if (arr.length < = 0 || low >= high) {
return arr;
}
int left = low;
int right = high;
// 挖坑1：
int temp = arr[left];
while (left < right ) {
// 坑2： ，
while (left < right & & arr [ right ] > = temp) {
right--;
}
arr[left] = arr[right];
// 坑3： ，
while (left < right & & arr [ left ] < = temp ) {
left++;
}
arr[right] = arr[left];
}
// 基准值填补到坑3中，
arr[left] = temp;
quickSort(arr, low, left - 1);
quickSort(arr, left + 1, high);
return arr;
}
/**
* 快速排序（非递归）
* < p >
* ①. 从数列中挑出一个元素，称为"基准"（ ）
* ②. 重新排序数列， ， （ ） ， （ ）
* ③. 把分区之后两个区间的边界（ ） ，
*
* @param arr 待排序数组
*/
public static int[] quickSortByStack(int[] arr) {
Stack< Integer > stack = new Stack< >();
// 初始状态的左右指针入栈
stack.push(0);
stack.push(arr.length - 1);
while (!stack.isEmpty()) {
// 出栈进行划分
int high = stack.pop();
int low = stack.pop();
int pivotIdx = partition(arr, low, high);
// 保存中间变量
if (pivotIdx > low) {
stack.push(low);
stack.push(pivotIdx - 1);
}
if (pivotIdx < high & & pivotIdx > = 0) {
stack.push(pivotIdx + 1);
stack.push(high);
}
}
return arr;
}
private static int partition(int[] arr, int low, int high) {
if (arr.length < = 0) return -1;
if (low >= high) return -1;
int l = low;
int r = high;
// 挖坑1：
int pivot = arr[l];
while (l < r ) {
// 坑2： ，
while (l < r & & arr [ r ] > = pivot) {
r--;
}
arr[l] = arr[r];
// 坑3： ，
while (l < r & & arr [ l ] < = pivot ) {
l++;
}
arr[r] = arr[l];
}
// 基准值填补到坑3中，
arr[l] = pivot;
return l;
}
```
以下是快速排序算法复杂度:
| 平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 |
| :------------- | :-------- | :------- | :--------------------- |
| O(nlog₂n) | O(nlog₂n) | O(n²) | O(1)（原地分区递归版） |
快速排序排序效率非常高。 虽然它运行最糟糕时将达到O(n²)的时间复杂度, 但通常平均来看, 它的时间复杂为O(nlogn), 比同样为O(nlogn)时间复杂度的归并排序还要快. 快速排序似乎更偏爱乱序的数列, 越是乱序的数列, 它相比其他排序而言, 相对效率更高。
Tips: 同选择排序相似, 快速排序每次交换的元素都有可能不是相邻的, 因此它有可能打破原来值为相同的元素之间的顺序. 因此, 快速排序并不稳定。
### 基数排序（ ）
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。
**算法描述**
- 取得数组中的最大数，并取得位数
- arr为原始数组，
- 对radix进行计数排序（ ）
**代码实现**
```java
/**
* 基数排序（
* < p >
* 基数排序适用于：
* (1)数据范围较小，
* (2)每个数值都要大于等于0
* < p >
* ①. 取得数组中的最大数，并取得位数；
* ②. arr为原始数组， ；
* ③. 对radix进行计数排序（ ） ；
*
* @param arr 待排序数组
*/
public static int[] radixSort(int[] arr) {
// 取得数组中的最大数，并取得位数
int max = 0;
for (int item : arr) {
if (max < item ) {
max = item;
}
}
int maxDigit = 1;
while (max / 10 > 0) {
maxDigit++;
max = max / 10;
}
// 申请一个桶空间
int[][] buckets = new int[10][arr.length];
int base = 10;
// 从低位到高位，对每一位遍历，将所有元素分配到桶中
for (int i = 0; i < maxDigit ; i + + ) {
// 存储各个桶中存储元素的数量
int[] bktLen = new int[10];
// 分配：将所有元素分配到桶中
for (int value : arr) {
int whichBucket = (value % base) / (base / 10);
buckets[whichBucket][bktLen[whichBucket]] = value;
bktLen[whichBucket]++;
}
// 收集：将不同桶里数据挨个捞出来,为下一轮高位排序做准备,由于靠近桶底的元素排名靠前,因此从桶底先捞
int k = 0;
for (int b = 0; b < buckets.length ; b + + ) {
for (int p = 0; p < bktLen [ b ] ; p + + ) {
arr[k++] = buckets[b][p];
}
}
base *= 10;
}
return arr;
}
```
以下是基数排序算法复杂度， ：
| 平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 |
| :------------- | :--------- | :--------- | :--------- |
| O(d*(n+r)) | O(d*(n+r)) | O(d*(n+r)) | O(n+r) |
其中，**d 为位数， ， `O(d*(n + r))` 。基数排序更适合用于对时间, 字符串等这些**整体权值未知的数据**进行排序。
Tips: 基数排序不改变相同元素之间的相对顺序，因此它是稳定的排序算法。
### 堆排序（ ）
对于堆排序，首先是建立在堆的基础上，堆是一棵完全二叉树，还要先认识下大根堆和小根堆，完全二叉树中所有节点均大于(或小于)它的孩子节点，所以这里就分为两种情况：
- 如果所有节点**「大于」**孩子节点值，那么这个堆叫做**「大根堆」**，堆的最大值在根节点
- 如果所有节点**「小于」**孩子节点值，那么这个堆叫做**「小根堆」**，堆的最小值在根节点
堆排序（ ） ， ， ， ，
**算法描述**
- 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区
- 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]< =R[n]
- 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆， ，
**动图演示**
**代码实现**
```java
/**
* 堆排序算法
*
* @param arr 待排序数组
*/
public static int[] heapSort(int[] arr) {
// 将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆
for (int i = arr.length / 2 - 1; i >= 0; i--) {
adjustHeap(arr, i, arr.length);
}
// 将最大的节点放在堆尾，然后从根节点重新调整
for (int j = arr.length - 1; j > 0; j--) {
// 交换
int temp = arr[j];
arr[j] = arr[0];
arr[0] = temp;
// 完成将以i对应的非叶子结点的树调整成大顶堆
adjustHeap(arr, 0, j);
}
return arr;
}
/**
* 功能： 完成将以i对应的非叶子结点的树调整成大顶堆
*
* @param arr 待排序数组
* @param i 表示非叶子结点在数组中索引
* @param length 表示对多少个元素继续调整， length 是在逐渐的减少
*/
private static void adjustHeap(int[] arr, int i, int length) {
// 先取出当前元素的值，保存在临时变量
int temp = arr[i];
//开始调整。说明：
for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
// 说明左子结点的值小于右子结点的值
if (k + 1 < length & & arr [ k ] < arr [ k + 1 ] ) {
// k 指向右子结点
k++;
}
// 如果子结点大于父结点
if (arr[k] > temp) {
// 把较大的值赋给当前结点
arr[i] = arr[k];
// i 指向 k,继续循环比较
i = k;
} else {
break;
}
}
//当for 循环结束后，
arr[i] = temp;
}
```
| 平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 |
| :------------- | :------------- | :------------- | :--------- |
| O(n \log_{2}n) | O(n \log_{2}n) | O(n \log_{2}n) | O(1) |
Tips: ** 由于堆排序中初始化堆的过程比较次数较多, 因此它不太适用于小序列.** 同时由于多次任意下标相互交换位置, 相同元素之间原本相对的顺序被破坏了, 因此, 它是不稳定的排序.
### 计数排序（ ）
计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
**算法描述**
- 找出待排序的数组中最大和最小的元素
- 统计数组中每个值为i的元素出现的次数，
- 对所有的计数累加（ ， ）
- 反向填充目标数组： ，
**动图演示**
**代码实现**
```java
/**
* 计数排序算法
*
* @param arr 待排序数组
*/
public static int[] countingSort(int[] arr) {
// 得到数列的最大值与最小值，
int max = arr[0];
int min = arr[0];
for (int i = 1; i < arr.length ; i + + ) {
if (arr[i] > max) {
max = arr[i];
}
if (arr[i] < min ) {
min = arr[i];
}
}
int d = max - min;
// 创建统计数组并计算统计对应元素个数
int[] countArray = new int[d + 1];
for (int value : arr) {
countArray[value - min]++;
}
// 统计数组变形，后面的元素等于前面的元素之和
int sum = 0;
for (int i = 0; i < countArray.length ; i + + ) {
sum += countArray[i];
countArray[i] = sum;
}
// 倒序遍历原始数组，从统计数组找到正确位置，输出到结果数组
int[] sortedArray = new int[arr.length];
for (int i = arr.length - 1; i >= 0; i--) {
sortedArray[countArray[arr[i] - min] - 1] = arr[i];
countArray[arr[i] - min]--;
}
return sortedArray;
}
```
**算法分析**
计数排序是一个稳定的排序算法。当输入的元素是 n 个 0到 k 之间的整数时， ， ， ，
### 桶排序（ ）
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。
**算法描述**
- 设置一个定量的数组当作空桶
- 遍历输入数据，并且把数据一个一个放到对应的桶里去
- 对每个不是空的桶进行排序
- 从不是空的桶里把排好序的数据拼接起来
**代码实现**
```java
/**
* 桶排序算法
*
* @param arr 待排序数组
*/
public static int[] bucketSort(int[] arr) {
// 计算最大值与最小值
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
for (int value : arr) {
max = Math.max(max, value);
min = Math.min(min, value);
}
// 计算桶的数量
int bucketNum = (max - min) / arr.length + 1;
List< List < Integer > > bucketArr = new ArrayList< >(bucketNum);
for (int i = 0; i < bucketNum ; i + + ) {
bucketArr.add(new ArrayList< >());
}
// 将每个元素放入桶
for (int value : arr) {
int num = (value - min) / (arr.length);
bucketArr.get(num).add(value);
}
// 对每个桶进行排序
for (List< Integer > integers : bucketArr) {
Collections.sort(integers);
}
// 将桶中的元素赋值到原序列
int index = 0;
for (List< Integer > integers : bucketArr) {
for (Integer integer : integers) {
arr[index++] = integer;
}
}
return arr;
}
```
**算法分析**
桶排序最好情况下使用线性时间O(n)， ， ，
# Case
## 双指针
### 删除排序数组中的重复项
给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
```java
/**
* 双指针解决
*/
public int removeDuplicates(int[] A) {
// 边界条件判断
if (A == null || A.length == 0){
return 0;
}
int left = 0;
for (int right = 1; right < A.length ; right + + ) {
// 如果左指针和右指针指向的值一样，说明有重复的，
// 这个时候，左指针不动，右指针继续往右移。如果他俩
// 指向的值不一样就把右指针指向的值往前挪
if (A[left] != A[right]){
A[++left] = A[right];
}
}
return ++left;
}
```
### 移动零
给定一个数组 `nums` ，编写一个函数将所有 `0` 移动到数组的末尾，同时保持非零元素的相对顺序。
**示例：**输入: [0,1,0,3,12]，输出: [1,3,12,0,0]
可以参照双指针的思路解决， ， ， ， ，
```java
public void moveZeroes(int[] nums) {
int i = 0;// 统计前面0的个数
for (int j = 0; j < nums.length ; j + + ) {
if (nums[j] == 0) {//如果当前数字是0就不操作
i++;
} else if (i != 0) {
//否则， ，
//当前位置设为0
nums[j - i] = nums[j];
nums[j] = 0;
}
}
}
```
## 反转
### 旋转数组
给定一个数组，将数组中的元素向右移动 `k` 个位置，其中 `k` 是非负数。
先反转全部数组， ， ， ：
```java
public void rotate(int[] nums, int k) {
int length = nums.length;
k %= length;
reverse(nums, 0, length - 1);//先反转全部的元素
reverse(nums, 0, k - 1);//在反转前k个元素
reverse(nums, k, length - 1);//接着反转剩余的
}
//把数组中从[start，
public void reverse(int[] nums, int start, int end) {
while (start < end ) {
int temp = nums[start];
nums[start++] = nums[end];
nums[end--] = temp;
}
}
```
## 栈
### 判断字符串括号是否合法
字符串中只有字符'('和')'。合法字符串需要括号可以配对。如：()， ， ， ，
**① 栈**
```java
/**
* 判断字符串括号是否合法
*
* @param s
* @return
*/
public boolean isValid(String s) {
// 当字符串本来就是空的时候，
if (s == null || s.length() == 0) {
return true;
}
// 当字符串长度为奇数的时候，不可能是一个有效的合法字符串
if (s.length() % 2 == 1) {
return false;
}
// 消除法的主要核心逻辑:
Stack< Character > t = new Stack< >();
for (int i = 0; i < s.length ( ) ; i + + ) {
// 取出字符
char c = s.charAt(i);
if (c == '(') {
// 如果是'('，那么压栈
t.push(c);
} else if (c == ')') {
// 如果是')'，那么就尝试弹栈
if (t.empty()) {
// 如果弹栈失败，
return false;
}
t.pop();
}
}
return t.empty();
}
```
**复杂度分析**：每个字符只入栈一次，出栈一次，所以时间复杂度为 O(N)，而空间复杂度为 O(N)，因为最差情况下可能会把整个字符串都入栈。
**② 栈深度扩展**
如果仔细观察，你会发现，栈中存放的元素是一样的。全部都是左括号'('，除此之外，再也没有别的元素，优化方法如下。**栈中元素都相同时，实际上没有必要使用栈，只需要记录栈中元素个数。** 我们可以通过画图来解决这个问题，如下图所示：
```java
/**
* 判断字符串括号是否合法
*
* @param s
* @return
*/
public boolean isValid(String s) {
// 当字符串本来就是空的时候，
if (s == null || s.length() == 0) {
return true;
}
// 当字符串长度为奇数的时候，不可能是一个有效的合法字符串
if (s.length() % 2 == 1) {
return false;
}
// 消除法的主要核心逻辑:
int leftBraceNumber = 0;
for (int i = 0; i < s.length ( ) ; i + + ) {
// 取出字符
char c = s.charAt(i);
if (c == '(') {
// 如果是'('，那么压栈
leftBraceNumber++;
} else if (c == ')') {
// 如果是')'，那么就尝试弹栈
if (leftBraceNumber < = 0) {
// 如果弹栈失败，
return false;
}
--leftBraceNumber;
}
}
return leftBraceNumber == 0;
}
```
**复杂度分析**：每个字符只入栈一次，出栈一次，所以时间复杂度为 O(N)，而空间复杂度为 O(1)，因为我们已经只用一个变量来记录栈中的内容。
**③ 栈广度扩展**
接下来再来看看如何进行广度扩展。观察题目可以发现，栈中只存放了一个维度的信息：左括号'('和右括号')'。如果栈中的内容变得更加丰富一点，就可以得到下面这道扩展题。给定一个只包括 '('， ， ， ， ，
- 左括号必须用相同类型的右括号闭合
- 左括号必须以正确的顺序闭合
- 注意空字符串可被认为是有效字符串
```java
/**
* 判断字符串括号是否合法
*
* @param s
* @return
*/
public boolean isValid(String s) {
if (s == null || s.length() == 0) {
return true;
}
if (s.length() % 2 == 1) {
return false;
}
Stack< Character > t = new Stack< >();
for (int i = 0; i < s.length ( ) ; i + + ) {
char c = s.charAt(i);
if (c == '{' || c == '(' || c == '[') {
t.push(c);
} else if (c == '}') {
if (t.empty() || t.peek() != '{') {
return false;
}
t.pop();
} else if (c == ']') {
if (t.empty() || t.peek() != '[') {
return false;
}
t.pop();
} else if (c == ')') {
if (t.empty() || t.peek() != '(') {
return false;
}
t.pop();
} else {
return false;
}
}
return t.empty();
}
```
### 大鱼吃小鱼
在水中有许多鱼，可以认为这些鱼停放在 x 轴上。再给定两个数组 Size， ， ， （ ，
- 所有的鱼都同时开始游动，每次按照鱼的方向，都游动一个单位距离
- 当方向相对时，大鱼会吃掉小鱼；
- 鱼的大小都不一样。
输入： ， ： ？
```java
/**
* 大鱼吃小鱼
*
* @param fishSize
* @param fishDirection
* @return
*/
public int solution(int[] fishSize, int[] fishDirection) {
// 首先拿到鱼的数量: 如果鱼的数量小于等于1，
final int fishNumber = fishSize.length;
if (fishNumber < = 1) {
return fishNumber;
}
// 0表示鱼向左游
final int left = 0;
// 1表示鱼向右游
final int right = 1;
Stack< Integer > t = new Stack< >();
for (int i = 0; i < fishNumber ; i + + ) {
// 当前鱼的情况： ， ； ，
final int curFishDirection = fishDirection[i];
final int curFishSize = fishSize[i];
// 当前的鱼是否被栈中的鱼吃掉了
boolean hasEat = false;
// 如果栈中还有鱼，并且栈中鱼向右，当前的鱼向左游，那么就会有相遇的可能性
while (!t.empty() & & fishDirection[t.peek()] == right & & curFishDirection == left) {
// 如果栈顶的鱼比较大，那么把新来的吃掉
if (fishSize[t.peek()] > curFishSize) {
hasEat = true;
break;
}
// 如果栈中的鱼较小，那么会把栈中的鱼吃掉，栈中的鱼被消除，所以需要弹栈。
t.pop();
}
// 如果新来的鱼，没有被吃掉，那么压入栈中。
if (!hasEat) {
t.push(i);
}
}
return t.size();
}
```
### 找出数组中右边比我小的元素
一个整数数组 A， ： ，
```java
/**
* 找出数组中右边比我小的元素
*
* @param A
* @return
*/
public static int[] findRightSmall(int[] A) {
// 结果数组
int[] ans = new int[A.length];
// 注意，栈中的元素记录的是下标
Stack< Integer > t = new Stack< >();
for (int i = 0; i < A.length ; i + + ) {
final int x = A[i];
// 每个元素都向左遍历栈中的元素完成消除动作
while (!t.empty() & & A[t.peek()] > x) {
// 消除的时候，记录一下被谁消除了
ans[t.peek()] = i;
// 消除时候，值更大的需要从栈中消失
t.pop();
}
// 剩下的入栈
t.push(i);
}
// 栈中剩下的元素，由于没有人能消除他们，因此，只能将结果设置为-1。
while (!t.empty()) {
ans[t.peek()] = -1;
t.pop();
}
return ans;
}
```
### 字典序最小的 k 个数的子序列
给定一个正整数数组和 k， ， ， ： ** 长度为 k**；
输入： ， ：
**解释**：在所有可能的解：{[3,5], [3,2], [3,6], [5,2], [5,6], [2,6]} 中，[2,6] 字典序最小。所谓字典序就是， ： ， < i ， xp = = yp 且 xi < yi ， 那 么 我 们 认 为 x 的 字 典 序 小 于 y 。
```java
/**
* 字典序最小的 k 个数的子序列
*
* @param nums
* @param k
* @return
*/
public int[] findSmallSeq(int[] nums, int k) {
int[] ans = new int[k];
Stack< Integer > s = new Stack();
// 这里生成单调栈
for (int i = 0; i < nums.length ; i + + ) {
final int x = nums[i];
final int left = nums.length - i;
// 注意我们想要提取出k个数，
while (!s.empty() & & (s.size() + left > k) & & s.peek() > x) {
s.pop();
}
s.push(x);
}
// 如果递增栈里面的数太多，
// 多余的栈中的元素需要扔掉。
while (s.size() > k) {
s.pop();
}
// 把k个元素取出来，
for (int i = k - 1; i >= 0; i--) {
ans[i] = s.peek();
s.pop();
}
return ans;
}
```
## FIFO队列
### 二叉树的层次遍历（两种方法）
从上到下按层打印二叉树，同一层结点按从左到右的顺序打印，每一层打印到一行。输入：
输出：[[3], [9, 8], [6, 7]]
```java
// 二叉树结点的定义
public class TreeNode {
// 树结点中的元素值
int val = 0;
// 二叉树结点的左子结点
TreeNode left = null;
// 二叉树结点的右子结点
TreeNode right = null;
}
```
**Queue表示FIFO队列解法**：
```java
public List< List < Integer > > levelOrder(TreeNode root) {
// 生成FIFO队列
Queue< TreeNode > Q = new LinkedList< >();
// 如果结点不为空，
if (root != null) {
Q.offer(root);
}
// ans用于保存层次遍历的结果
List< List < Integer > > ans = new LinkedList< >();
// 开始利用FIFO队列进行层次遍历
while (Q.size() > 0) {
// 取出当前层里面元素的个数
final int qSize = Q.size();
// 当前层的结果存放于tmp链表中
List< Integer > tmp = new LinkedList< >();
// 遍历当前层的每个结点
for (int i = 0; i < qSize ; i + + ) {
// 当前层前面的结点先出队
TreeNode cur = Q.poll();
// 把结果存放当于当前层中
tmp.add(cur.val);
// 把下一层的结点入队，注意入队时需要非空才可以入队。
if (cur.left != null) {
Q.offer(cur.left);
}
if (cur.right != null) {
Q.offer(cur.right);
}
}
// 把当前层的结果放到返回值里面。
ans.add(tmp);
}
return ans;
}
```
**ArrayList表示FIFO队列解法**：
```java
public List< List < Integer > > levelOrder(TreeNode root) {
List< List < Integer > > ans = new ArrayList< >();
// 初始化当前层结点
List< TreeNode > curLevel = new ArrayList< >();
// 注意：
if (root != null) {
curLevel.add(root);
}
while (curLevel.size() > 0) {
// 准备用来存放下一层的结点
List< TreeNode > nextLevel = new ArrayList< >();
// 用来存放当前层的结果
List< Integer > curResult = new ArrayList< >();
// 遍历当前层的每个结点
for (TreeNode cur : curLevel) {
// 把当前层的值存放到当前结果里面
curResult.add(cur.val);
// 生成下一层
if (cur.left != null) {
nextLevel.add(cur.left);
}
if (cur.right != null) {
nextLevel.add(cur.right);
}
}
// 注意这里的更迭!滚动前进
curLevel = nextLevel;
// 把当前层的值放到结果里面
ans.add(curResult);
}
return ans;
}
```
### 循环队列
设计一个可以容纳 k 个元素的循环队列。需要实现以下接口：
```java
public class MyCircularQueue {
// 参数k表示这个循环队列最多只能容纳k个元素
public MyCircularQueue(int k){}
// 将value放到队列中, 成功返回true
public boolean enQueue(int value){return false;}
// 删除队首元素，
public boolean deQueue(){return false;}
// 得到队首元素，如果为空，返回-1
public int Front(){return 0;}
// 得到队尾元素，如果队列为空，返回-1
public int Rear(){return 0;}
// 看一下循环队列是否为空
public boolean isEmpty(){return false;}
// 看一下循环队列是否已放满k个元素
public boolean isFull(){return false;}
}
```
循环队列的重点在于**循环使用固定空间**，难点在于**控制好 front/rear 两个首尾指示器**。
**方法一：
只使用 k 个元素的空间，三个变量 front, rear, used 来控制循环队列。标记 k = 6 时，循环队列的三种情况，如下图所示：
```java
public class MyCircularQueue {
// 已经使用的元素个数
private int used = 0;
// 第一个元素所在位置
private int front = 0;
// rear是enQueue可在存放的位置， ，
private int rear = 0;
// 循环队列最多可以存放的元素个数
private int capacity = 0;
// 循环队列的存储空间
private int[] a = null;
public MyCircularQueue(int k) {
// 初始化循环队列
capacity = k;
a = new int[capacity];
}
public boolean enQueue(int value) {
// 如果已经放满了
if (isFull()) {
return false;
}
// 如果没有放满，
a[rear] = value;
// rear注意取模
rear = (rear + 1) % capacity;
// 已经使用的空间
used++;
// 存放成功!
return true;
}
public boolean deQueue() {
// 如果是一个空队列，当然不能出队
if (isEmpty()) {
return false;
}
// 第一个元素取出
int ret = a[front];
// 注意取模
front = (front + 1) % capacity;
// 已经存放的元素减减
used--;
// 取出元素成功
return true;
}
public int front() {
// 如果为空，不能取出队首元素
if (isEmpty()) {
return -1;
}
// 取出队首元素
return a[front];
}
public int rear() {
// 如果为空，不能取出队尾元素
if (isEmpty()) {
return -1;
}
// 注意：
// 需要取模
int tail = (rear - 1 + capacity) % capacity;
return a[tail];
}
// 队列是否为空
public boolean isEmpty() {
return used == 0;
}
// 队列是否满了
public boolean isFull() {
return used == capacity;
}
}
```
**复杂度分析**：入队操作与出队操作都是 O(1)。
**方法二：
方法 1 利用 used 变量对满队列和空队列进行了区分。实际上，这种区分方式还有另外一种办法，使用 k+1 个元素的空间，两个变量 front, rear 来控制循环队列的使用。具体如下：
- 在申请数组空间的时候，申请 k + 1 个空间
- 在放满循环队列的时候，必须要保证 rear 与 front 之间有空隙
如下图（此时 k = 5） ：
```java
public class MyCircularQueue {
// 队列的头部元素所在位置
private int front = 0;
// 队列的尾巴，注意我们采用的是前开后闭原则， [front, rear)
private int rear = 0;
private int[] a = null;
private int capacity = 0;
public MyCircularQueue(int k) {
// 初始化队列，注意此时队列中元素个数为
// k + 1
capacity = k + 1;
a = new int[k + 1];
}
public boolean enQueue(int value) {
// 如果已经满了，无法入队
if (isFull()) {
return false;
}
// 把元素放到rear位置
a[rear] = value;
// rear向后移动
rear = (rear + 1) % capacity;
return true;
}
public boolean deQueue() {
// 如果为空，无法出队
if (isEmpty()) {
return false;
}
// 出队之后，
front = (front + 1) % capacity;
return true;
}
public int front() {
// 如果能取出第一个元素，
return isEmpty() ? -1 : a[front];
}
public int rear() {
// 由于我们使用的是前开后闭原则
// [front, rear)
// 所以在取最后一个元素时，应该是
// (rear - 1 + capacity) % capacity;
int tail = (rear - 1 + capacity) % capacity;
return isEmpty() ? -1 : a[tail];
}
public boolean isEmpty() {
// 队列是否为空
return front == rear;
}
public boolean isFull() {
// rear与front之间至少有一个空格
// 当rear指向这个最后的一个空格时，
// 队列就已经放满了!
return (rear + 1) % capacity == front;
}
}
```
**复杂度分析**：入队与出队操作都是 O(1)。
## 单调队列
单调队列属于**双端队列**的一种。双端队列与 FIFO 队列的区别在于：
- FIFO 队列只能从尾部添加元素，首部弹出元素
- 双端队列可以从首尾两端 push/pop 元素
### 滑动窗口的最大值
给定一个数组和滑动窗口的大小， ： ， ：
```java
public class Solution {
// 单调队列使用双端队列来实现
private ArrayDeque< Integer > Q = new ArrayDeque< >();
// 入队的时候， ，
// 需要保证整个队列的数值是单调的
// (在这个题里面我们需要是递减的)
// 并且需要注意， < val
// 如果写成Q.getLast() < = val就变成了严格单调递增
private void push(int val) {
while (!Q.isEmpty() & & Q.getLast() < val ) {
Q.removeLast();
}
// 将元素入队
Q.addLast(val);
}
// 出队的时候，要相等的时候才会出队
private void pop(int val) {
if (!Q.isEmpty() & & Q.getFirst() == val) {
Q.removeFirst();
}
}
public int[] maxSlidingWindow(int[] nums, int k) {
List< Integer > ans = new ArrayList< >();
for (int i = 0; i < nums.length ; i + + ) {
push(nums[i]);
// 如果队列中的元素还少于k个
// 那么这个时候，还不能去取最大值
if (i < k - 1 ) {
continue;
}
// 队首元素就是最大值
ans.add(Q.getFirst());
// 尝试去移除元素
pop(nums[i - k + 1]);
}
// 将ans转换成为数组返回!
return ans.stream().mapToInt(Integer::valueOf).toArray();
}
}
```
**复杂度分析**：每个元素都只入队一次，出队一次，每次入队与出队都是 O(1) 的复杂度，因此整个算法的复杂度为 O(n)。
### 捡金币游戏
给定一个数组 A[]，每个位置 i 放置了金币 A[i]，小明从 A[0] 出发。当小明走到 A[i] 的时候，下一步他可以选择 A[i+1, i+k]（当然，不能超出数组边界）。每个位置一旦被选择，将会把那个位置的金币收走（如果为负数，就要交出金币）。请问，最多能收集多少金币？
输入：[1,-1,-100,-1000,100,3], k = 2， ：
**解释**：从 A[0] = 1 出发，收获金币 1。下一步走往 A[2] = -100, 收获金币 -100。再下一步走到 A[4] = 100， ， ，
```java
public class Solution {
public int maxResult(int[] A, int k) {
// 处理掉各种边界条件!
if (A == null || A.length == 0 || k < = 0) {
return 0;
}
final int N = A.length;
// 每个位置可以收集到的金币数目
int[] get = new int[N];
// 单调队列，这里并不是严格递减
ArrayDeque< Integer > Q = new ArrayDeque< Integer > ();
for (int i = 0; i < N ; i + + ) {
// 在取最大值之前，需要保证单调队列中都是有效值。
// 也就是都在区间里面的值
// 当要求get[i]的时候，
// 单调队列中应该是只能保存[i-k, i-1]这个范围
if (i - k > 0) {
if (!Q.isEmpty() & & Q.getFirst() == get[i - k - 1]) {
Q.removeFirst();
}
}
// 从单调队列中取得较大值
int old = Q.isEmpty() ? 0 : Q.getFirst();
get[i] = old + A[i];
// 入队的时候，采用单调队列入队
while (!Q.isEmpty() & & Q.getLast() < get [ i ] ) {
Q.removeLast();
}
Q.addLast(get[i]);
}
return get[N - 1];
}
}
```
**复杂度分析**：每个元素只入队一次，出队一次，每次入队与出队复杂度都是 O(n)。因此，时间复杂度为 O(n)，空间复杂度为 O(n)。
# Design Pattern
## 创建型模式
建造类设计模式提供了对创建对象的基本定义和约束条件，
### 工厂模式(Factory)
**概念**
定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的**实例化延迟**到其子类。
**使用场景**
jdbc 连接数据库，硬件访问，降低对象的产生和销毁。
实现工厂模式需要满足三个条件：
- 超类（ ） ：
- 子类（ ） ：
- 工厂类（ ） ：
### 抽象工厂模式(Abstract Factory)
**概念**
为创建一组相关或相互依赖的对象提供一个接口，而且**无须指定它们的具体类。**
**使用场景**
一个对象族（或是一组没有任何关系的对象）都有相同的约束。
涉及不同操作系统的时候，都可以考虑使用抽象工厂模式。
### 单例模式(Singleton)
**概念**
确保某一个类只有一个实例，而且**自行实例化**并向整个系统提供这个实例。
**使用场景**
- 要求生成唯一序列号的环境
- 在整个项目中需要一个共享访问点或共享数据， ， ， ，
- 创建一个对象需要消耗的资源过多，
- 需要定义大量的静态常量和静态方法（ ） ， （ ， ）
### 建造者模式(Builder)
**概念**
将一个复杂对象的构建与它的表示分离，使得**同样的构建过程可以创建不同的表示。**
**使用场景**
- 相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式
- 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式
- 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适
### 原型模式(Prototype)
**概念**
用原型实例指定创建对象的种类，并且**通过拷贝这些原型**创建新的对象。
**使用场景**
- **资源优化场景：**类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等
- **性能和安全要求的场景：**通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式
- **一个对象多个修改者的场景：**一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以、考虑使用原型模式拷贝多个对象供调用者使用
## 结构型模式
结构类设计模式主要解决如何通过多个小对象组合出一个大对象的问题，如使用继承和接口实现将多个类组合在一起。
### 适配器模式(Adapter)
**概念**
将一个类的接口**变换成客户端所期待的另一种接口，**从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。
**使用场景**
你有动机修改一个已经投产中的接口时，适配器模式可能是最适合你的模式。比如系统扩展了，需要使用一个已有或新建立的类，但这个类又不符合系统的接口，怎么办？详细设计阶段不要考虑使用适配器模式，使用主要场景为扩展应用中。
### 组合模式(Composite)
**概念**
将对象组合成树形结构以表示**“部分-整体”**的层次结构，使得用户对单个对象和组合对象的使用具有一致性。
**使用场景**
- 维护和展示部分-整体关系的场景，如树形菜单、文件和文件夹管理
- 从一个整体中能够独立出部分模块或功能的场景
- 只要是树形结构，就考虑使用组合模式
**案例**：每个员工都有姓名、部门、薪水这些属性，同时还有下属员工集合（虽然可能集合为空），而下属员工和自己的结构是一样的，也有姓名、部门这些属性，同时也有他们的下属员工集合。
### 代理模式(Proxy)
**概念**
为其他对象**提供一种代理以控制**对这个对象的访问。
### 享元模式(Flywight)
**概念**
使用共享对象可有效地**支持大量的细粒度的对象。**
对象的信息分为两个部分： （ ） （ ）
- **内部状态：**内部状态是对象可共享出来的信息，存储在享元对象内部并且不会随环境改变而改变
- **外部状态：**外部状态是对象得以依赖的一个标记，是随环境改变而改变的、不可以共享的状态
**使用场景**
- 系统中存在大量的相似对象
- 细粒度的对象都具备较接近的外部状态，而且内部状态与环境无关，也就是说对象没有特定身份
- 需要缓冲池的场景
### 门面模式(Facade)
**概念**
要求一个子系统的外部与其内部的通信必须**通过一个统一的对象进行。**门面模式提供一个高层次的接口，使得子系统更易于使用。
**使用场景**
- 为一个复杂的模块或子系统提供一个供外界访问的接口
- 子系统相对独立——外界对子系统的访问只要黑箱操作即可
- 预防低水平人员带来的风险扩散
### 桥接模式(Bridge)
**概念**
将**抽象和实现解耦，**使得两者可以独立地变化。
**使用场景**
- 不希望或不适用使用继承的场景
- 接口或抽象类不稳定的场景
- 重用性要求较高的场景
### 装饰器模式(Decorator)
**概念**
动态地给一个对象**添加一些额外的职责。**就增加功能来说，装饰模式相比生成子类更为灵活。
**使用场景**
- 需要扩展一个类的功能，或给一个类增加附加功能
- 需要动态地给一个对象增加功能，这些功能可以再动态地撤销
- 需要为一批的兄弟类进行改装或加装功能，当然是首选装饰模式
## 行为型模式
行为类设计模式主要用于定义和描述对象之间的交互规则和职责边界，为对象之间更好的交互提供解决方案。
### 模板方法模式(Template Method)
**概念**
定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以**不改变一个算法的结构**即可重定义该算法的某些特定步骤。
**使用场景**
- 多个子类有公有的方法，并且逻辑基本相同时
- 重要、复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能则由各个子类实现
- 重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类中，然后通过钩子函数（见“模板方法模式的扩展”）约束其行为
### 中介者模式(Mediator)
**概念**
用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其**耦合松散，**而且可以独立地改变它们之间的交互。
**使用场景**
中介者模式适用于多个对象之间紧密耦合的情况，紧密耦合的标准是：在类图中出现了蜘蛛网状结构，即每个类都与其他的类有直接的联系。
### 责任链模式(Chain)
**概念**
使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象**连成一条链，**并沿着这条链传递该请求，直到有对象处理它为止。
### 观察者模式(Observer)
**概念**
定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会**得到通知并被自动更新。**
**使用场景**
- 关联行为场景。需要注意的是，关联行为是可拆分的，而不是“组合”关系
- 事件多级触发场景
- 跨系统的消息交换场景，如消息队列的处理机制
### 策略模式(Strategy)
**概念**
定义一组算法，将**每个算法都封装起来，**并且使它们之间可以互换。
**使用场景**
- 多个类只有在算法或行为上稍有不同的场景
- 算法需要自由切换的场景
- 需要屏蔽算法规则的场景
- 具体策略数量超过 4 个，则需要考虑使用混合模式
### 命令模式(Command)
**概念**
将一个请求封装成一个对象，从而让你使用不同的请求把客户端参数化，对**请求排队或者记录请求日志，**可以提供命令的撤销和恢复功能。
**使用场景**
认为是命令的地方就可以采用命令模式，例如，在 GUI 开发中，一个按钮的点击是一个命令，可以采用命令模式；模拟 DOS 命令的时候，当然也要采用命令模式；触发－反馈机制的处理等。
### 状态模式(State)
**概念**
当一个对象**内在状态改变时允许其改变行为，**这个对象看起来像改变了其类。
**使用场景**
- 行为随状态改变而改变的场景，这也是状态模式的根本出发点，例如权限设计，人员的状态不同即使执行相同的行为结果也会不同，在这种情况下需要考虑使用状态模式
- 条件、分支判断语句的替代者
### 访问者模式(Visitor)
**概念**
封装一些**作用于某种数据结构中的各元素的操作，**它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。
**使用场景**
- 一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作，也就说是用迭代器模式已经不能胜任的情景
- 需要对一个对象结构中的对象进行很多不同并且不相关的操作，而你想避免让这些操作“污染”这些对象的类
### 解释器模式(Interpreter)
**概念**
给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器**使用该表示来解释语言中的句子。**
**使用场景**
- 重复发生的问题可以使用解释器模式
- 一个简单语法需要解释的场景
### 迭代器模式(Iterator)
**概念**
它提供一种方法**访问一个容器对象中各个元素，**而又不需暴露该对象的内部细节。
### 备忘录模式(Memento)
**概念**
在不破坏封装性的前提下，**捕获一个对象的内部状态，**并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。
**使用场景**
- 需要保存和恢复数据的相关状态场景
- 提供一个可回滚（ ）
- 需要监控的副本场景中
- 数据库连接的事务管理就是用的备忘录模式
