├── .gitignore
├── C++
    └── C++FAQ.md
├── FrontEnd
    ├── css.md
    ├── dom.md
    ├── js.md
    ├── other.md
    └── web.md
├── Java
    ├── Hibernate.md
    ├── Spring.md
    ├── 垃圾回收.md
    ├── 基础知识.md
    ├── 并发编程.md
    ├── 知识点.md
    ├── 设计模式.md
    └── 集合框架.md
├── README.md
├── image
    ├── BEM.jpg
    ├── Bellman.png
    ├── IO复用模型.png
    ├── SSL五次握手.png
    ├── TCP.jpg
    ├── block.jpg
    ├── collection api.png
    ├── collection.png
    ├── concurrent_package.png
    ├── ctr_1.png
    ├── ctr_2.png
    ├── element.jpg
    ├── ftrl_1.png
    ├── ftrl_2.png
    ├── modifier.jpg
    ├── priority.png
    ├── thread_status.png
    ├── vc_1.png
    ├── vc_2.png
    ├── vc_3.png
    ├── 信号驱动IO模型.png
    ├── 原型链图解.png
    ├── 原型链图解1.png
    ├── 原型链图解2.png
    ├── 外边距合并初衷.png
    ├── 异步IO模型.png
    ├── 阻塞式IO模型.png
    └── 非阻塞式IO模型.png
├── 分布式技术
    └── 分布式技术.md
├── 操作系统
    ├── 基础知识.md
    └── 操作系统FAQ.md
├── 数据库
    ├── NoSQL.md
    ├── SQL语句相关.md
    ├── 基础知识.md
    ├── 数据库优化与大数据量.md
    └── 数据库索引相关.md
├── 数据结构与算法
    ├── 1.LRU算法（缓存淘汰算法）.md
    ├── 2.排序算法.md
    ├── C++实现
    │   ├── Ant_Algorithm.c
    │   ├── Binary_Indexed_Tree.cpp
    │   ├── Binary_Search.cpp
    │   ├── GCD.cpp
    │   ├── LIS.cpp
    │   ├── Matrix_Fast_Power.cpp
    │   ├── Minimum_Spanning_Tree
    │   │   ├── Kruskal.cpp
    │   │   └── Prim.cpp
    │   ├── README.md
    │   ├── Segment_Tree.cpp
    │   ├── Shortest_Path
    │   │   ├── Dijkstra.cpp
    │   │   └── Floyd.cpp
    │   ├── Sort_Approaches
    │   │   ├── Bubble_Sort.c
    │   │   ├── Insert_Sort.c
    │   │   ├── Merge_Sort.c
    │   │   ├── Quick_Sort.c
    │   │   ├── README.md
    │   │   ├── Shell_Sort.c
    │   │   └── Simple_Selection_Sort.c
    │   └── Union-Find.cpp
    ├── 剑指offer
    │   ├── Java
    │   │   ├── BalancedBinaryTree.java
    │   │   ├── CommonNode.java
    │   │   ├── DeleteDuplication.java
    │   │   ├── FindContinueSequence.java
    │   │   ├── FindInTwoDimensionalArray01.java
    │   │   ├── FindSingleCharacter.java
    │   │   ├── MergeSortReversePair.java
    │   │   ├── PokerStraight.java
    │   │   ├── RegexSolution.java
    │   │   ├── ReplaceSpaceOnString02.java
    │   │   ├── ReverseTheList03.java
    │   │   ├── UglyNumber.java
    │   │   └── run.sh
    │   └── python
    │   │   ├── Convert.py
    │   │   ├── EntryNodeOfLoop.py
    │   │   ├── Fibonacci.py
    │   │   ├── FindContinuousSequence.py
    │   │   ├── FindFirstCommonNode.py
    │   │   ├── FindGreatestSumOfSubArray.py
    │   │   ├── FindKthToTail.py
    │   │   ├── FindNumbersWithSum.py
    │   │   ├── FindNumsAppearOnce.py
    │   │   ├── FindPath.py
    │   │   ├── FirstAppearingOnce.py
    │   │   ├── FirstNotRepeatingChar.py
    │   │   ├── GetLeastNumbers.py
    │   │   ├── GetMedian.py
    │   │   ├── GetNumberOfK.py
    │   │   ├── HasSubtree.py
    │   │   ├── InversePairs.py
    │   │   ├── IsBalanced_Solution.py
    │   │   ├── IsContinuous.py
    │   │   ├── IsPopOrder.py
    │   │   ├── KthNode.py
    │   │   ├── LastRemaining_Solution.py
    │   │   ├── LeftRotateString.py
    │   │   ├── MaxInWindows.py
    │   │   ├── Mirror.py
    │   │   ├── MoreThanHalfNum.py
    │   │   ├── NumberOf1.py
    │   │   ├── NumberOf1Between1AndN_Solution.py
    │   │   ├── Permutation.py
    │   │   ├── Power.py
    │   │   ├── PrintMinNumber.py
    │   │   ├── README.md
    │   │   ├── ReverseSentence.py
    │   │   ├── StrToInt.py
    │   │   ├── TreeDepth.py
    │   │   ├── UglyNum.py
    │   │   ├── VerifySquenceOfBST.py
    │   │   ├── add.py
    │   │   ├── clone.py
    │   │   ├── deleteDuplication.py
    │   │   ├── duplicate.py
    │   │   ├── getNext.py
    │   │   ├── hasPath.py
    │   │   ├── isNumeric.py
    │   │   ├── isSymmetrical.py
    │   │   ├── jumpFloor.py
    │   │   ├── jumpFloorII.py
    │   │   ├── match.py
    │   │   ├── merge.py
    │   │   ├── minNumberInRotateArray.py
    │   │   ├── min_stack.py
    │   │   ├── movingCount.py
    │   │   ├── multiply.py
    │   │   ├── print.py
    │   │   ├── print2.py
    │   │   ├── printFromToptoBottom.py
    │   │   ├── printListFromTailToHead.py
    │   │   ├── printMatrix.py
    │   │   ├── queue.py
    │   │   ├── reConstructBinaryTree.py
    │   │   ├── reOrderArray.py
    │   │   ├── rectCover.py
    │   │   ├── replaceSpace.py
    │   │   ├── reverseList.py
    │   │   ├── serialize.py
    │   │   ├── sum_solution.py
    │   │   └── twodarray.py
    ├── 图.md
    ├── 红黑树.md
    └── 背包问题.md
├── 机器学习
    ├── dkl项目相关准备.md
    ├── img
    │   ├── approximate.png
    │   ├── column_block.png
    │   ├── exact_greedy.png
    │   ├── goss.png
    │   ├── greedy_bundle.png
    │   ├── l2_loss.png
    │   ├── leaf-wise.png
    │   ├── level-wise.png
    │   ├── merge.png
    │   ├── momentum.png
    │   ├── momentum_algo.png
    │   ├── practice.png
    │   ├── regularization.png
    │   ├── sparsity.png
    │   └── theory.png
    ├── lightGBM.md
    ├── xgboost.md
    ├── 优化方法.md
    ├── 决策树.md
    ├── 支持向量机.md
    ├── 机器学习基本知识总结.md
    ├── 机器学习监督算法.md
    ├── 特征选择.md
    ├── 过拟合.md
    ├── 逻辑回归.md
    ├── 集成学习.md
    └── 非监督性算法.md
└── 计算机网络
    ├── HTTP.md
    ├── OSI7层模型.md
    ├── TCP_IP.md
    ├── 网络编程.md
    └── 计算机网络FAQ.md


/.gitignore:
--------------------------------------------------------------------------------
1 | 
2 | FrontEnd/.vscode
3 | 
4 | *.class


--------------------------------------------------------------------------------
/C++/C++FAQ.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/C++/C++FAQ.md


--------------------------------------------------------------------------------
/FrontEnd/other.md:
--------------------------------------------------------------------------------
 1 | # 关于面试
 2 | ## 1 小米面试
 3 | ### 1.1 getElementById 实现原理
 4 | Q：getElementById 实现的原理？
 5 | 
 6 | `getElementById()` 不是JavaScript语言的功能，而是浏览器作为JavaScript的host环境注册给JavaScript的host函数，由浏览器内部实现。
 7 | 
 8 | 以 Chrome 为例，底层实现的代码是：
 9 | ```cpp
10 | Element* TreeScope::getElementById(const AtomicString& elementId) const
11 | {
12 |     if (elementId.isEmpty())
13 |         return 0;
14 |     if (!m_elementsById)
15 |         return 0;
16 |     return m_elementsById->getElementById(elementId, this);
17 | }
18 | ```
19 | 所以底层原理是利用了哈希表记录 ID 到 dom 节点的映射关系，每当有一个新的 ID 添加到 dom 节点，相应的映射关系就会被加到这个哈希表里。
20 | 
21 | **延伸：其他获取 DOM 节点的方法比较**
22 | 
23 | `getElementsByClassName()` 和 `getElementsByTagName()` 遍历 DOM 树（具体如何遍历不了解），返回 Array-Like Object `HTMLCollection`，而且是 live reference。
24 | 
25 | The methods getElementsByClassName and getElementsByTagName return an HTMLCollection object that acts like an array. That collection is "live", which means the collection is updated if additional elements with tag name or class name are added to the document.
26 | 
27 | `querySelectorAll()` 返回 Array-Like Object `NodeList`，不过是静态的。
28 | 
29 | The method querySelectorAll() returns a NodeList, which also acts like an array. That list is "static", which means that the list won't update even if new matching elements are added to the page.
30 | ### 1.2 AJAX 相关
31 | Q：AJAX 产生背景，在 AJAX 出现之前一般是怎么做的？
32 | 
33 | 在应用 AJAX 之前，传统的 web 应用在不需要进行大量内容更新时也要刷新整个页面。AJAX（***Asynchronous JavaScript And XML***）的出现使得我们可以1. 在页面加载好了之后更新部分内容；2. 在页面加载好了之后向服务器请求数据或者发送数据，优化了用户体验。
34 | 
35 | AJAX 技术的核心是 `XMLHttpRequest`对象，XHR 为 web 应用和服务器通信提供了接口。具体的对象属性和方法以及通信的实现细节可以复习 `js.md` 中的`如何实现 AJAX 请求`。
36 | 
37 | 在 AJAX 出现之前，采用的一些 hack 手段：（复习`web.md`中的`跨域方法`）
38 | 1. `<iframe>`
39 | 2. JSONP
40 | 3. `<img>`
41 | 
42 | 其他：虽然 AJAX 名字里面是 xml，其实 AJAX 通信时支持的 MIME 类型包括：JSON、JSONP、text、xml、html 等。
43 | ### 1.3 jQuery 相关
44 | Q：简要介绍一下 jQuery 的大致功能，相比原生JavaScript 带来了哪些便利，项目中使用了那些功能？
45 | 
46 | jQuery 是一套跨浏览器的 JavaScript 开源库，简化了 HTML 和 JavaScript之间的操作，封装了一些常用的功能，并且可以扩展，是目前最受欢迎的 JavaScript 库。
47 | 
48 | jQuery 的功能和优势：
49 | 1. 简化了 DOM 元素选择
50 | 2. 浏览器兼容性很好
51 | 3. 内置了可自定义参数的动画效果，简化了应用动画效果的过程
52 | 4. 事件处理更加简单
53 | 5. 封装了很多功能，简化了常用的 JavaScript 操作
54 | 6. 支持 CSS3 标准
55 | 7. 提供了一整套 AJAX 相关操作的方法，大大方便了异步通信的开发和使用
56 | 8. 基于开源的 jQuery 还有很多的插件可以使用
57 | 9. 轻量级脚本，生态社区好，文档齐全，学习成本低
58 | 
59 | 项目中主要使用了 jQuery 的 DOM 选择器，以及封装好的 AJAX 方法。
60 | 
61 | 为了防止被问，总结一下：
62 | 
63 | 


--------------------------------------------------------------------------------
/Java/Hibernate.md:
--------------------------------------------------------------------------------
 1 | 
 2 | ## Hibernate中Java对象的状态有哪些 ##
 3 | 
 4 | 
 5 | 
 6 | #### Transient ####
 7 | 对象具有以下特点
 8 | 
 9 | 
10 | 1. 没有和session关联的对象
11 | 2. 在数据库中不存在与之对应的记录
12 | 
13 | 通常在下列情况下对象会进入临时状态
14 | 
15 | 
16 | 1. 刚刚创建的对象，还没有被持久化
17 | 
18 | 2. 执行delete()方法，对于游离状态的对象，delete()方法会将其与数据库中对应的记录删除，而对于持久化状态的对象，delete方法会将其与数据库中对应的记录删除，并将其在Session中的缓存删除
19 | 3. 
20 | #### Persistent ####
21 | 对象具有以下特点
22 | 
23 | 1. 和seesion关联，在session缓存中
24 | 2. 在数据库中有与之对应的记录
25 | 3. session在清理缓存的时候，会根据持久化对象的属性变化更新数据库。
26 | 
27 | 通常在下列情况下对象会进入临时状态 
28 | 
29 | 1. 执行save()或saveOrUpdate()方法，使临时对象转变为持久化对象。
30 | 2. 执行upda()或saveOrUpdate()方法，使游离对象转变为持久化对象。
31 | 3. 执行load()或get()方法，返回的对象都是持久化对象
32 | 4. 执行find()方法，返回List集合中存放的都是持久化对象
33 | 5. 在允许级联保存的情况下，Session在清理缓存时会把与持久化对象关联的临时对象转变为持久化对象
34 | 
35 | 
36 | #### Detached ####
37 | 对象具有以下特点
38 | 
39 | 1. 对象不再Session缓存中，不予任何Session实例关联
40 | 2. 在数据库中有与之对应的记录
41 | 
42 | 通常载下列情况对象会进入临时装填
43 | 
44 | 1. 执行close()方法，将Session缓存清空，缓存中的所有持久化对象将转变成游离对象
45 | 2. 执行evict()方法，能从缓存中删除一个持久化对象，使之转变成游离对象
46 | 
47 | 
48 | ## HIbernate中get和load有什么不同之处 ##
49 | 
50 | > 如果缓存中咩有找到相应的对象，get将会直接访问数据库并返回一个完全初始化好的对象，而这个过程有可能涉及到多个数据调用。而load方法在缓存中没有发现对象的情况下，只会返回一个代理对象。只有在对象getId()之外的其他方法被调用时才会真正的去访问数据库，这样就能在某些情况下大幅度提高性能。
51 | 
52 | ## SessionFactory是线程安全的吗 ##
53 | 
54 | > SessionFactory是在应用启动是就创建好的，对于单个的数据存储，一般只有一个SessionFacotory实例，所有的客户请求的线程都是通过这个工厂来获得Session，所以必须保证他是线程安全的。而Session不是线程安全的
55 | 
56 | ## 一二级缓存区别及适用情况 ##
57 | 
58 | > 一级缓存是session级别的缓存，二级缓存是SessionFactory级别的缓存。
59 |  以下数据适合放在二级缓存中
60 | 
61 | 1. 很少被修改的数据
62 | 2. 不是很重要的数据，允许出现偶尔并发的数据
63 | 3. 不会被并发访问的数据
64 | 
65 | ## 为什么Hibernate的实体类中需要提供一个无参的构造器 ##
66 | > 因为Hibernate框架需要使用Reflection API，通过调用Class.newInstance()来创建这些实体类的实例。
67 | 
68 | ## Hibernate是如何实现延迟加载的 ##
69 | Hibernate使用代理模式实现延迟加载，在load一个对象，或者存在级联对象时使用延迟加载的机制时。Hiberante会动态的创建一个这个对象的代理对象。当真正访问对象的属性时才会真正的发起数据库请求初始化对象的细节
70 | 
71 | 
72 | 
73 | 
74 | 
75 | 
76 | 
77 | 
78 | 
79 | 
80 | 
81 | 
82 | 
83 | 
84 | 


--------------------------------------------------------------------------------
/Java/垃圾回收.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/Java/垃圾回收.md


--------------------------------------------------------------------------------
/Java/基础知识.md:
--------------------------------------------------------------------------------
  1 | ## 1、Java内存模型 #
  2 | ### 1.1 程序计数器 
  3 | 程序计数器是当前线程所执行的字节码的行号指示器，每条线程都需要一个独立的程序计数器，各条线程之间计数器互不影响，独立存储。
  4 | 
  5 | ### 1.2 虚拟机栈 
  6 | 每个方法在执行的过程中都会创建一个栈帧用于存储局部变量表，操作数栈，动态链接，方法出口等信息。每个方法从调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出站的过程
  7 | 
  8 | ### 1.3 本地方法栈 
  9 | 本地方法栈与虚拟机栈类似，只不过后者为虚拟机执行Java方法服务，而本地方法栈则为虚拟机使用到的Native方法服务。
 10 | 
 11 | ### 1.4 堆 
 12 | 唯一的目的是存储对象的实例
 13 | 
 14 | ### 1.5 方法区 
 15 | 与堆一样，是各个线程共享的内存区域，他用于存储已被虚拟机加载的类信息，常量，静态变量，即时编译器编译后的代码等数据。编译器生成的各种字面量和符号引用存储在类加载后进入方法区的运行时常量池中。
 16 | 
 17 | ### 1.6 直接内存
 18 | 直接内存并不是JVM管理的内存，可以这样理解，直接内存就是JVM以为的机器内存。比如机器有4G的内存，
 19 | 占用了1G， 则其余3G就是直接内存。JDK有一种基于Channel和Buffer的内存分配方式，将由C语言实现的native函数库分配在直接内存中，用存储在JVM堆中的DirectByteBuffer来引用。
 20 | 
 21 | 
 22 | ## 2、垃圾收集机制 
 23 | 引用计数法难以处理循环引用的对象的垃圾回收问题，java C#等语言使用可达性分析来判断对象是否存活。基本思想是通过一系列的成为GC roots的对象作为起点，从这些节点开始向下搜索，搜索所走过的路径称为引用链，有如果从GC root到这个对象不可达，则证明此对象是不可用的。GC Root对象包含以下几种
 24 | 
 25 | - 虚拟机栈中的引用对象
 26 | - 方法区中类静态属性引用的对象
 27 | - 方法区中常量引用的对象
 28 | - 本地方法栈中引用的对象
 29 | 
 30 | ### 2.1 收集算法
 31 | 1. 标记-清除算法  ----GC算法的基础
 32 | 2. 停止-复制算法  Eden Survivor 8:1:1 ----年轻代回收算法  
 33 | 3. 标记整理算法  ----老年代回收算法
 34 | 
 35 | ### 2.2 收集器
 36 | *CMS收集器*
 37 | 
 38 | 用于老年代回收，致力于获取最短的回收停顿时间，使用标记清除算法，多线程，优点是并发收集，停顿小
 39 | 
 40 | *G1收集器*
 41 | 
 42 | 1. G1在压缩空间方面有优势;
 43 | 2. 通过将内存空间分成区域的方式避免内存碎片;
 44 | 3. Eden，Survivor Old区不在固定，在内存使用效率上来说更灵活;
 45 | 4. G1会在Yong GC中使用、而CMS只能在O区使用;
 46 | 
 47 | 
 48 | ### 2.3 内存分配策略:
 49 | 1. 对象优先分配在Eden中
 50 | 2. 大对象直接进入老年代
 51 | 3. 长期存活的对象将进入老年代（经历一次GC仍存活则年龄加一）
 52 | 
 53 | 
 54 | 
 55 | ## 3、类加载机制 
 56 | ### 3.1 加载过程
 57 | **加载** 
 58 | 1. 通过一个类的完全限定名蔡获取定义此类的二进制字节流
 59 | 2. 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
 60 | 3. 在内存中生成一个代表这个类的java.long.Class对象，作为方法区这个类的各种数据的访问入口
 61 | 
 62 | **验证**
 63 | 1. 文件格式的验证， 如是否以魔数开头，常量池中的常量是否有不被支持的类型等
 64 | 2. 元数据验证，如这个类是否有父类，是否实现了父类或接口中要求实现的所有方法等
 65 | 3. 字节码验证，比如抱枕跳转指令不会跳转到方法体以外的字节码指令上。保证方法体中的类型转换是有效的
 66 | 4. 符号引用验证，如符号引用的类，字段，方法的访问性是否可以被当前类访问
 67 | 
 68 | **准备**
 69 | 
 70 | 本阶段为类变量分配内存并设置类变量的初始值，注意这里指的是类变量
 71 | 
 72 | **解析**
 73 | 
 74 | 解析阶段是讲虚拟机常量池内的符号引用替换为直接引用的过程，所谓符号引用即以一组符号描述所引用的目标，如一个方法的名称，类名等。解析的过程是将这些符号解析为直接指向目标的指针，相对偏移量或者一个能间接定位到目标的句柄。
 75 | 
 76 | 1. 类或者接口的解析
 77 | 2. 字段解析
 78 | 3. 类方法解析
 79 | 4. 接口方法解析
 80 | 
 81 | **初始化**
 82 | 
 83 | `clinit`由编译器自动收集类中所有变量的赋值动作和静态语句块中的语句合并产生。
 84 | 虚拟机保证子类的`clinit`方法执行前会先执行父类的`clinit`方法，因此虚拟机中第一个被执行的`clinit`方法的类一定是Object
 85 | 
 86 | ### 3.2 双亲委派模型
 87 | 其要求除了顶层的启动类加载器之外，其余的类加载器都应该有自己的父类加载器，这里的父类加载器之间的父子关系一般不会以集成的关系来实现，而都是使用组合关系来复用父加载器。其工作过程是：如果一个类加载器收到了类加载的请求，他首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求时，自加载器才会尝试去加载。
 88 | 
 89 | 
 90 | ## 4、Collection
 91 | ### 4.1 ArrayList&LinkedList
 92 | ArrayList基于数组，LinkedList基于链表
 93 | 
 94 | ### 4.2 HashMap 
 95 | HashMap内部实现就是一个哈希表，即一个数组，数组的元素是一个链表的头结点。
 96 | 当HashMap中的元素越来越多的时候，hash冲突的几率也就越来越高。HashMap在创建时有一个负载因子，当元素的个数大于数组长度×负载因子的大小时，HashMap就会进行扩容。把数组的大小扩展2倍。然后重新计算各个元素的hash值。
 97 | 
 98 | *Fail-Fast*
 99 | 
100 | >HashMap不是线程安全的，因此如果在使用迭代器的过程中有其他线程修改了Map，那么将抛出ConcurrentModificationException，这就是Fail-Fast策略
101 | >其实现是通过modCount域，modeCount记录修改次数，迭代器在初始化的过程中会将这个值保存在expectedModCount，在迭代的过程中，判断modCount与expectedModCount是否相等，如果不相等，说明已经有其他线程修改了Map，注意这里的modCount必须声明为volatile，以保证线程之间的可见性。
102 | 
103 | ### 4.3 TreeMap 
104 | TreeMap的内部通过红黑树实现。根据键的自然顺序进行排序，或者根据创建映射时提供的Comparator进行排序，具体取决于使用的构造方法。
105 | TreeMap的基本操作containsKey，get，put和remove的时间复杂度是logn
106 | ### 4.4 HashTable  
107 | 1. HashTable基于Dictionary类，而HashMap基于AbstractMap
108 | 2. HashMap的key和value都允许为null，而HashTable的key和Value都不允许为null
109 | 3. HashTblae中急速所有的public方法都是synchronized，而有些方法也是在内部通过synchronized代码块来实现。
110 | 
111 | ## 5、NIO
112 | - 传统的IO是基于字节的，所有的IO都被视为单个字节的移动（流）；而NIO是基于块的，其性能优于流IO。
113 | - NIO中有两个概念Buffer和Channel。Buffer本质上就是一块内存区，可以用来写入数据，并在稍后读取出来。通道可以读也可以写，通道可以异步读写，且通道总是基于Buffer来读写。通道与流非常相似。
114 | - NIO基于IO复用模型，即selector模型或epoll模型，使得单个线程可以监听多个通道（IO）描述符，监听到符合条件的描述符后会进行数据的读写或链接建立等操作。
115 | 
116 | ## 6、几种引用
117 | ### 强引用
118 | 正常情况下new出来的对象的引用就是强引用，如果一个对象具有强引用，那么垃圾回收绝不会回收它。当内存空间不足，jvm宁愿抛出OutOfMemoryError错误使程序异常终止
119 | 
120 | ### 软引用
121 | 如果一个对象只具有软引用，如果内存空间不足，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可以用来实现内存敏感的告诉缓存。
122 | ### 弱引用
123 | 弱引用与软引用的区别在于，只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间是否足够，都会回收它的内存
124 | ### 虚引用
125 | 虚引用并不会决定对象的生命周期，如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
126 | 虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于，虚引用必须和引用队列联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有许引用，就会在回收对象的内存之前把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了徐应用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
127 | 
128 | ### 7、Object类常用方法
129 | 
130 | | **toString()**  | **clone()**    | **wait()**   | **notify()**    |
131 | | --------------- | -------------- | ------------ | --------------- |
132 | | **notifyAll()** | **hashcode()** | **equals()** | **finallize()** |
133 | 
134 | ### 
135 | 
136 | ### 8、重写equals()和hashcode()方法
137 | 
138 | ​	默认情况下也就是从超类Object继承而来的equals方法与‘==’是完全等价的，比较的都是对象的内存地址，但我们可以重写equals方法，使其按照我们的需求的方式进行比较，如String类重写了equals方法，使其比较的是字符的序列，而不再是内存地址。
139 | 
140 | **重写equals()需要符合以下规则：**
141 | 
142 | - **自反性**。对于任何非null的引用值x，x.equals(x)应返回true。
143 | - **对称性**。对于任何非null的引用值x与y，当且仅当：y.equals(x)返回true时，x.equals(y)才返回true。
144 | - **传递性**。对于任何非null的引用值x、y与z，如果y.equals(x)返回true，y.equals(z)返回true，那么x.equals(z)也应返回true。
145 | - **一致性**。对于任何非null的引用值x与y，假设对象上equals比较中的信息没有被修改，则多次调用x.equals(y)始终返回true或者始终返回false。
146 | 
147 | 对于任何非空引用值x，x.equal(null)应返回false。
148 | 
149 | **重写equals()的同时需重写hashCode()**
150 | 
151 | java中，可以使用hashCode()来获取对象的哈希码，其值就是对象的存储地址，这个方法在Object类中声明，因此所有的子类都含有该方法。
152 | 
153 | 在Java API文档中关于hashCode方法有以下几点规定：
154 | 
155 | - 在java应用程序执行期间，如果在equals方法比较中所用的信息没有被修改，那么在同一个对象上多次调用hashCode方法时必须一致地返回相同的整数。如果多次执行同一个应用时，不要求该整数必须相同。
156 | - 如果两个对象通过调用equals方法是相等的，那么这两个对象调用hashCode方法必须返回相同的整数。
157 | - 如果两个对象通过调用equals方法是不相等的，不要求这两个对象调用hashCode方法必须返回不同的整数。但是程序员应该意识到对不同的对象产生不同的hash值可以提供哈希表的性能。
158 | 
159 | 
160 | ### 9. session和cookie的区别
161 | 
162 | HTTP是一种无状态的协议，Cookie与Session都是常见的会话跟踪技术。Cookie通过在客户端记录信息确定用户身份，Session通过在服务器端记录信息确定用户身份。Cookie存在客户端所以用户可以看见，所以也可以编辑伪造，不安全。Session过多的时候会消耗服务器资源，所以大型网站会有专门的Session服务器，而Cookie存在客户端所以没什么问题。域的支持范围不一样，比方说a.com的Cookie在a.com下都能用，而www.a.com的Session在api.a.com下都不能用。
163 | 
164 | Session的应用需要Session_id来实现。id是存在Cookie里的，如果禁用Cookie, Session也无法正常使用，但可以通过URL地址重写实现可用。


--------------------------------------------------------------------------------
/Java/知识点.md:
--------------------------------------------------------------------------------
 1 | ArrayList&LinkedList
 2 | HashMap & TreeMap
 3 | JMM
 4 | GC 算法 与 收集器（G1）
 5 | IO NIO
 6 | 多线程
 7 | Netty相关知识，NIO， 零拷贝，内存池，责任链
 8 | CountdownLatch
 9 | IOC实现细节
10 | AOP实现细节
11 | selector， epoll
12 | reactor， preactor


--------------------------------------------------------------------------------
/Java/集合框架.md:
--------------------------------------------------------------------------------
 1 | # Java集合框架
 2 | 
 3 | ## 1.集合框架总览
 4 | 
 5 |  ![img](http://img.my.csdn.net/uploads/201205/15/1337078642_5965.jpg)
 6 | 
 7 | ​		集合接口：（短虚线表示），表示不同集合类型，是集合框架的基础。 
 8 | 
 9 | ​		抽象类：（长虚线表示），对集合接口的部分实现。可扩展为自定义集合类。 
10 | 
11 | ​		实现类：（实线表示），对接口的具体实现。 
12 | 
13 | 
14 | 
15 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # InterviewFAQ
 2 | 面试常见问题总结
 3 | 
 4 | ### 目录：
 5 | * 前端
 6 | 	* [css](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/FrontEnd/css.md)
 7 | 	* [js](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/FrontEnd/js.md)
 8 | 	* [web](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/FrontEnd/web.md)
 9 | 	* [dom](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/FrontEnd/dom.md)
10 | 	* [面试经历](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/FrontEnd/other.md)
11 | * Java开发
12 | 	* [基础知识](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/Java/%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86.md) 
13 | 	* [设计模式](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/Java/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F.md)
14 | 	* [集合框架](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/Java/%E9%9B%86%E5%90%88%E6%A1%86%E6%9E%B6.md)
15 | 	* [并发编程](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/Java/%E5%B9%B6%E5%8F%91%E7%BC%96%E7%A8%8B.md)
16 | 	* [Spring](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/Java/Spring.md)
17 | 	* [Hibernate](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/Java/Hibernate.md)
18 | 	
19 | * 数据结构与算法
20 | 	* [排序](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/2.%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95.md)
21 | 	* [图](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/%E5%9B%BE.md)
22 | 	* [红黑树](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/%E7%BA%A2%E9%BB%91%E6%A0%91.md)
23 | 	* [背包问题](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/%E8%83%8C%E5%8C%85%E9%97%AE%E9%A2%98.md)
24 | 	* [LRU算法](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/1.LRU%E7%AE%97%E6%B3%95%EF%BC%88%E7%BC%93%E5%AD%98%E6%B7%98%E6%B1%B0%E7%AE%97%E6%B3%95%EF%BC%89.md)
25 | 	* [剑指offer（python）](https://github.com/LEAGUE-OF-BME/InterviewFAQ/tree/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/%E5%89%91%E6%8C%87offer/python)
26 | 	* [基础算法C++实现](https://github.com/LEAGUE-OF-BME/InterviewFAQ/tree/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/C%2B%2B%E5%AE%9E%E7%8E%B0)
27 | * 数据库
28 | 	* [基础知识](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%95%B0%E6%8D%AE%E5%BA%93/%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86.md) 
29 | 	* [SQL语句](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%95%B0%E6%8D%AE%E5%BA%93/SQL%E8%AF%AD%E5%8F%A5%E7%9B%B8%E5%85%B3.md)
30 | 	* [索引](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%95%B0%E6%8D%AE%E5%BA%93/%E6%95%B0%E6%8D%AE%E5%BA%93%E7%B4%A2%E5%BC%95%E7%9B%B8%E5%85%B3.md)
31 | 	* [优化](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%95%B0%E6%8D%AE%E5%BA%93/%E6%95%B0%E6%8D%AE%E5%BA%93%E4%BC%98%E5%8C%96%E4%B8%8E%E5%A4%A7%E6%95%B0%E6%8D%AE%E9%87%8F.md)
32 | 	* [NoSQL](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%95%B0%E6%8D%AE%E5%BA%93/NoSQL.md)
33 | * 操作系统
34 | 	* [基础知识](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86.md) 
35 | * 计算机网络
36 | 	* [HTTP](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/HTTP.md)
37 | 	* [OSI7层模型](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/OSI7%E5%B1%82%E6%A8%A1%E5%9E%8B.md)
38 | 	* [TCP/IP](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/TCP_IP.md)
39 | 	* [IO模型](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/%E7%BD%91%E7%BB%9C%E7%BC%96%E7%A8%8B.md)
40 | * 机器学习
41 | 	* [理论知识](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E5%9F%BA%E6%9C%AC%E7%9F%A5%E8%AF%86%E6%80%BB%E7%BB%93.md) 
42 | 	* [逻辑回归](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/%E9%80%BB%E8%BE%91%E5%9B%9E%E5%BD%92.md) 
43 | 	* [支持向量机](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/%E6%94%AF%E6%8C%81%E5%90%91%E9%87%8F%E6%9C%BA.md)
44 | 	* [决策树](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/%E5%86%B3%E7%AD%96%E6%A0%91.md)
45 | 	* [集成学习](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/%E9%9B%86%E6%88%90%E5%AD%A6%E4%B9%A0.md)
46 | 	* [XGBoost](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/xgboost.md)
47 | 	* [LightGBM](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/lightGBM.md)
48 | 	* [过拟合与解决方法](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/%E8%BF%87%E6%8B%9F%E5%90%88.md)
49 | 	* [监督学习总结](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E7%9B%91%E7%9D%A3%E7%AE%97%E6%B3%95.md)
50 | 	* [非监督学习总结](https://github.com/LEAGUE-OF-BME/InterviewFAQ/edit/master/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/%E9%9D%9E%E7%9B%91%E7%9D%A3%E6%80%A7%E7%AE%97%E6%B3%95.md)
51 | 	* [优化方法](https://github.com/LEAGUE-OF-BME/InterviewFAQ/edit/master/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/%E4%BC%98%E5%8C%96%E6%96%B9%E6%B3%95.md)
52 | 
53 | 
54 | 
55 | 部分页面存在数学公式，请使用Chrome浏览器并安装插件[Github with MathJax](https://chrome.google.com/webstore/detail/github-with-mathjax/ioemnmodlmafdkllaclgeombjnmnbima)


--------------------------------------------------------------------------------
/image/BEM.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/BEM.jpg


--------------------------------------------------------------------------------
/image/Bellman.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/Bellman.png


--------------------------------------------------------------------------------
/image/IO复用模型.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/IO复用模型.png


--------------------------------------------------------------------------------
/image/SSL五次握手.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/SSL五次握手.png


--------------------------------------------------------------------------------
/image/TCP.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/TCP.jpg


--------------------------------------------------------------------------------
/image/block.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/block.jpg


--------------------------------------------------------------------------------
/image/collection api.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/collection api.png


--------------------------------------------------------------------------------
/image/collection.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/collection.png


--------------------------------------------------------------------------------
/image/concurrent_package.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/concurrent_package.png


--------------------------------------------------------------------------------
/image/ctr_1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/ctr_1.png


--------------------------------------------------------------------------------
/image/ctr_2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/ctr_2.png


--------------------------------------------------------------------------------
/image/element.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/element.jpg


--------------------------------------------------------------------------------
/image/ftrl_1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/ftrl_1.png


--------------------------------------------------------------------------------
/image/ftrl_2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/ftrl_2.png


--------------------------------------------------------------------------------
/image/modifier.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/modifier.jpg


--------------------------------------------------------------------------------
/image/priority.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/priority.png


--------------------------------------------------------------------------------
/image/thread_status.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/thread_status.png


--------------------------------------------------------------------------------
/image/vc_1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/vc_1.png


--------------------------------------------------------------------------------
/image/vc_2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/vc_2.png


--------------------------------------------------------------------------------
/image/vc_3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/vc_3.png


--------------------------------------------------------------------------------
/image/信号驱动IO模型.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/信号驱动IO模型.png


--------------------------------------------------------------------------------
/image/原型链图解.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/原型链图解.png


--------------------------------------------------------------------------------
/image/原型链图解1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/原型链图解1.png


--------------------------------------------------------------------------------
/image/原型链图解2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/原型链图解2.png


--------------------------------------------------------------------------------
/image/外边距合并初衷.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/外边距合并初衷.png


--------------------------------------------------------------------------------
/image/异步IO模型.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/异步IO模型.png


--------------------------------------------------------------------------------
/image/阻塞式IO模型.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/阻塞式IO模型.png


--------------------------------------------------------------------------------
/image/非阻塞式IO模型.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/image/非阻塞式IO模型.png


--------------------------------------------------------------------------------
/分布式技术/分布式技术.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/分布式技术/分布式技术.md


--------------------------------------------------------------------------------
/操作系统/基础知识.md:
--------------------------------------------------------------------------------
  1 | # 操作系统基础 #
  2 | 
  3 | 
  4 | ### 1. 信号量 ###
  5 | 信号量是一个用于进程间传递信息的整数值，在信号量上可以进行三种操作:初始化，递减，递增
  6 | 
  7 | 这里我们有两个函数： `semWait`将信号量递减， `semSignal`将信号量递增
  8 | 
  9 | 一个进程A执行`semWait`操作，如果信号量的结果值大于等于0，则这个进程可以继续执行，如果这个值小于0则阻塞进程A
 10 | 也就是说，信号量为正数的时候，表示发出`semWait`后即可执行的进程的数量，信号量为负值的时候，绝对值为当前阻塞的进程的数量
 11 | 如果当前的信号量为负值，一个进程B发出`semSignal`操作，将使阻塞的进程中的一个进程解禁。
 12 | 
 13 | ### 2. 二元信号量 ###
 14 | 顾名思义，二元信号量只有两个值0或1
 15 | 一个进程执行`semWaitB`操作时，检查信号量的值，如果为1，将其置0并继续执行，如果为0，则阻塞此进程
 16 | `semSignalB`操作将信号量置1并检查是否有任何进程在该信号上受阻。若有进程受阻，则通过`semWaitB`操作，受阻进程被唤醒
 17 | 
 18 | 通过信号量，可以实现进程访问资源的互斥
 19 | 
 20 | ### 3. 管程 ###
 21 | 管程是有一个或多个过程，一个初始化序列和局部数据组成的软件模块，主要特点如下
 22 | 
 23 | 1. 局部数据变量只能被管程的过程访问，任何外部过程都不能访问
 24 | 2. 一个该进程通过调用管程的一个过程进入管程
 25 | 3. 在任何时候，只能又一个进程在管程中执行，调用管程的任何其他进程都被阻塞，以等待管程可用
 26 | 
 27 | 
 28 | ### 4. 死锁的条件 ###
 29 | 
 30 | 1. 互斥           一次只能有一个进程可以使用一个资源，其他进程不能访问
 31 | 2. 占有且等待      当一个进程等待其他进程时，继续占有已分配的资源
 32 | 3. 不可抢占        不能强行抢占进程已占有的资源
 33 | 4. 循环等待        存在一个闭合的进程链，每个进程至少占有此链中下一个进程所需要的一个资源
 34 | 
 35 | #### 死锁避免 ####
 36 | 
 37 | 若一个进程的请求会导致死锁，则不启动该进程，一个非最优的策略是如果一个进程请求资源i的数量量加上已分配的资源i的数量大于系统中资源i的总量则不启动该进程
 38 | 
 39 | 若一个进程增加的资源请求会导致死锁，则不允许这一资源的分配（银行家算法）
 40 | 
 41 | ### 5. Unix进程间通信 ###
 42 | #### 管道 ####
 43 | 管道是一个环形的缓冲区，他允许两个进程以生产者/消费者的模型进行通信。这是一个先进先出的队列，由一个进程写，另一个进程读。
 44 | 管道在创建时获得一个固定大小的字节数，当一个晋城市图往管道中写时，如果有足够的空间，则立即执行写请求，否则阻塞；当一个进程试图读取的字节数多于管道中的字节数时，也被阻塞，否则立即执行读请求。操作系统强制实施互斥，一次只能有一个进程可以访问管道
 45 | 
 46 | 管道分为两类 :  命名管道和匿名管道。只有具有血缘关系的进程才可以共享匿名管道，而不相关的进程只能共享命名管道
 47 | 
 48 | #### 消息队列 ####
 49 | #### 共享内存 ####
 50 | #### 信号量 ####
 51 | 
 52 | ### 6. 内存管理 ###
 53 | 
 54 | #### 内存分区 ####
 55 | 
 56 | ##### 固定分区 #####
 57 | 会产生内部碎片
 58 | 
 59 | ##### 动态分区  #####
 60 | 会产生外部碎片
 61 | 
 62 | ##### 分页  #####
 63 | 将内存分为很小的页，称为页框，一般为1024的倍数，如4K， 进程也分为同样大小的页，放入页框中。为每一个进程维护一个页表描述使用了那些页，用来计算逻辑地址到物理地址的映射
 64 | 
 65 | ##### 分段  #####
 66 | 段是按照程序的自然分解划分的可以动态改变的区域，通常程序员把子程序，操作数，常数等不同类型的数据划分到不同的段中，并且每个程序可以有多个相同类型的段，分段通常对程序员是可见的，因而分段为组织程序和数据提供了方便。
 67 | 
 68 | 
 69 | - 优点 
 70 | 
 71 | 1. 段的逻辑独立性使其易于编译，管理，修改和保护，也便于多道程序共享 
 72 | 2. 段长可以根据需要动态改变，允许自由调度，以便有效利用主存空间
 73 | 3. 方便编程，分段共享，分段保护，动态链接，动态增长
 74 | 
 75 | 
 76 | - 缺点 
 77 | 1. 主存空间分配比较麻烦
 78 | 2. 容易在段间留下许多碎片，造成存储空间利用率降低
 79 | 
 80 | 
 81 | ### 7. 进程与线程的区别
 82 | 
 83 | - 一个进程可以包含多个线程，且至少有一个；
 84 | - 进程是系统进行资源分配的基本单位，线程是CPU调度和分派的基本单位；进程拥有独立的地址空间，其内存空间线程共享；
 85 | - 线程的划分尺度小于进程，多线程程序的并发性高；
 86 | - 线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；而进程正相反。
 87 | 
 88 | 
 89 | 
 90 | 
 91 | 
 92 | 
 93 | 
 94 | 
 95 | 
 96 | 
 97 | 
 98 | 
 99 | 
100 | 


--------------------------------------------------------------------------------
/操作系统/操作系统FAQ.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/操作系统/操作系统FAQ.md


--------------------------------------------------------------------------------
/数据库/NoSQL.md:
--------------------------------------------------------------------------------
 1 | # NoSQL
 2 | 
 3 | ## 1.NoSQL简介
 4 | 
 5 | NoSQL，指的是非关系型的数据库。NoSQL有时也称作Not Only SQL的缩写，是对不同于传统的关系型数据库的数据库管理系统的统称。
 6 | 
 7 | **主要存储方式**：键 - 值对存储，列存储，文档存储，图形数据库
 8 | 
 9 | | 类型          | 部分代表                                     | 特点                                       |
10 | | ----------- | ---------------------------------------- | ---------------------------------------- |
11 | | 列存储         | Hbase/Cassandra/Hypertable               | 顾名思义，是按列存储数据的。最大的特点是方便存储结构化和半结构化数据，方便做数据压缩，对针对某一列或者某几列的查询有非常大的IO优势。 |
12 | | 文档存储        | MongoDB/CouchDB                          | 文档存储一般用类似json的格式存储，存储的内容是文档型的。这样也就有有机会对某些字段建立索引，实现关系数据库的某些功能。 |
13 | | key-value存储 | Tokyo Cabinet / Tyrant/Berkeley DB/MemcacheDB/Redis | 可以通过key快速查询到其value。一般来说，存储不管value的格式，照单全收。（Redis包含了其他功能） |
14 | | 图存储         | Neo4J/FlockDB                            | 图形关系的最佳存储。使用传统关系数据库来解决的话性能低下，而且设计使用不方便。  |
15 | | 对象存储        | db4o/Versant                             | 通过类似面向对象语言的语法操作数据库，通过对象的方式存取数据。          |
16 | | xml数据库      | Berkeley DB XML/BaseX                    | 高效的存储XML数据，并支持XML的内部查询语法，比如XQuery,Xpath。 |
17 | 
18 | NoSQL的优势：
19 | 
20 | - **易扩展**    数据之间无关系
21 | - **大数据量，高性能**    具有非常高的读写性能
22 | - **灵活的数据模型**    需事先为要存储的数据建立字段，随时可以存储自定义的数据格式
23 | - **高可用**    可以方便地实现高可用的架构
24 | 
25 | NoSQL数据库的出现，弥补了关系数据（比如MySQL）在某些方面的不足，在某些方面能极大的节省开发成本和维护成本。
26 | 
27 | ## 2.redis和memcached区别
28 | 
29 | 1、Redis和Memcache都是将数据存放在内存中，都是内存数据库。不过memcache还可用于缓存其他东西，例如图片、视频等等；
30 | 
31 | 2、Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，hash等数据结构的存储；
32 | 
33 | 3、虚拟内存--Redis当物理内存用完时，可以将一些很久没用到的value 交换到磁盘；
34 | 
35 | 4、过期策略--memcache在set时就指定，例如set key1 0 0 8,即永不过期。Redis可以通过例如expire 设定，例如expire name 10；
36 | 
37 | 5、分布式--设定memcache集群，利用magent做一主多从;redis可以做一主多从。都可以一主一从；
38 | 
39 | 6、存储数据安全--memcache挂掉后，数据没了；redis可以定期保存到磁盘（持久化）；
40 | 
41 | 7、灾难恢复--memcache挂掉后，数据不可恢复; redis数据丢失后可以通过aof恢复；
42 | 
43 | 8、Redis支持数据的备份，即master-slave模式的数据备份；
44 | 
45 | 9、应用场景不一样：Redis出来作为NoSQL数据库使用外，还能用做消息队列、数据堆栈和数据缓存等；Memcached适合于缓存SQL语句、数据集、用户临时性数据、延迟查询数据和session等。


--------------------------------------------------------------------------------
/数据库/基础知识.md:
--------------------------------------------------------------------------------
 1 | ## 1 事务与隔离级别
 2 | 
 3 | ### 1.1 ACID ##
 4 | 
 5 | |属性|说明|
 6 | |----|----|
 7 | |Atomitity|一个事务的所有操作，要么全部完成，要么全部不完成，不会结束在中间的某个环节。|
 8 | |Consistency|一致性属性确保任何事务将数据库从一个有效状态带到另一个有效状态。写入数据库的任何数据必须根据所有定义的规则（包括约束，级联，触发器及其任何组合）有效。这不保证程序员可能想要的所有方式的事务的正确性（那是应用程序代码的责任），但只是任何编程错误不能违背定义好的规则|
 9 | |Islation|数据库允许多个并发事务同时对数据进行读写和修改，隔离性可以防止多个并发事务执行时由于交叉执行而导致的数据不一致。事务的隔离级别下文会讲到|
10 | |Durability|事务树立结束后，对数据的修改是永久的，即便系统故障也不会丢失|
11 | 
12 | 
13 | ### 1.2 Read phenomenon ##
14 | 
15 | |问题 | 说明|
16 | |----|-----|
17 | |**Dirty read** |指一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时另外一个事务也访问使用了这个数据|
18 | |**Non-repeatable reads**|指在一个事务内，多次读同一个数据。在这个事务还没有结束时，另外一个事务也访问该同一个数据并作出提交。那么第一个事务中两次读数据可能是不一样的。他与脏读的区别是，脏读读取到了其他事务还未提交的数据，而这里读取的是另一个事务提交的数据|
19 | |**Phantom reads**| 第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部行。同时，第二个事务向表中插入一行新数据。那么，操作第一个事务的用户发现表中还有没有修改的数据行，就好像发生了幻觉一样。他和不可重复读的区别是，不可重复读查询的都是同一项数据，而幻读针对的是一批数据的整体|
20 | 
21 | 
22 | ###  1.3 Isolation levels ##
23 | |隔离级别 | 解释|
24 | |-------|----|
25 | |Serializable|所有的事务串行化执行，每次读都需要获得表级共享锁，读写相互都会阻塞，这是最强的隔离级别，不会出现上述的三种问题|
26 | |Repeatable Read|在同一个事务中内的多次查询和事务开始时刻都是一致的，该隔离级别消除了不可重复读，但是可能还会出现幻读（可以理解为，可重复读只是保证了针对这一条数据的update事务会被当前可重复读的事务阻塞，而对insert操作的事务则不会被阻塞）|
27 | |Read Committed|只能读取已经提交的数据。即如果两个事务并发，允许读事务过程中发生写事务的提交。这不能保证可重复读|
28 | |Read Uncommitted| 允许脏读，也就是可能读取到其他会话中未提交事务修改的数据|
29 | 
30 | ### 1.4 Isolation levels & Read phenomenon ###
31 | |Isolation levels|Dirty reads|Non-repeatable reads|Phantoms|
32 | |--|--|--|--|
33 | |Read Uncommitted|may occur|may occur|may occur|
34 | |Read Committed|don't occur|may occur|may occur|
35 | |Repeatable Read|don't occur|don't occur|may occur|
36 | |Serializable|don't occur|don't occur|don't occur|
37 | 
38 | ***
39 | ## 2 数据库索引
40 | 我们常见的数据库系统，其索引使用的数据结构多是B-Tree(此处的横线不是减，只是连接符而已)或者B+Tree。MySql使用的是B+Tree，Oracle使用的是B-Tree。
41 | B-Tree的结构是是一个多叉树，树中的每一个节点的内容是具体的数据（或者指向数据的指针）
42 | B+Tree的结构也是一个多叉树，不同的是树中非叶子节点中存储的是一个范围，而不是具体的数据或指针，树的叶子节点存储真实的数据，并且叶子节点构成一个链表，以方便范围类型的查找
43 | 
44 | ### 2.1 为什么使用多叉结构?
45 | 这与磁盘的读写有关，由于磁盘特殊的机械结构，在进行读写的时候都是直接读取一个扇区，数据是以块为单位，这就导致如果我们一个节点中的数据量很少，那就会读取到许多不需要的数据。而如果节点数据很少，每个节点都需要进行磁盘读取将会耗费大量的磁盘IO时间。我们知道磁盘IO是性能的瓶颈所在，所以我们为了减少磁盘读取操作，使用多叉树存储数据，每次读取都是读取树中的一个节点的数据（通常是1K到4K）。这样每次的读取不会出现冗余的数据，而且读取次数也大大减少。
46 | ### 2.2 索引分类
47 | ##### 聚集与否
48 | 
49 | |类别|解释|
50 | |--|--|
51 | |聚集索引|表数据按照索引的顺序来存储，叶子节点即存储了真实的数据行|
52 | |非聚集索引|表数据存储与索引顺序无关，叶子节点包含索引字段值及指向数据页数据行的逻辑指针|
53 | 
54 | ##### MySql索引类别 普通维度
55 | 
56 | |类别|解释|
57 | |--|--|
58 | |普通索引|基本的数据库索引|
59 | |唯一索引|数据库索引列的值必须唯一，如果是组合索引，列值的组合必须唯一|
60 | |主键索引|一种特殊的唯一索引，不允许为空值，一般在建表的时候同时创建主键索引|
61 | |组合索引|多列组合在一起构成的索引，查询时，只有顺序条件才会生效，如对于A，B, C构成的索引，只有A，AB，ABC这样的顺序条件才会起作用|
62 | 
63 | ##### Mysql索引分类 复杂维度
64 | 索引是在Mysql的存储引擎层实现的，而不是在服务层实现的。所以每种存储引擎的索引并不完全相同
65 | 
66 | |类别|解释|
67 | |--|--|
68 | |B-Tree索引|最常见的索引类型，大部分引擎都支持B-Tree索引|
69 | |Hash索引|即使用列的Hash值作为索引查找，只用Memory引擎支持，使用场景简单|
70 | |R-Tree索引|MyISAM的一种特殊索引，主要用于地理空间数据类型|
71 | |Full-text|全文索引，MyISAM 和 InnoDB 支持|
72 | ***
73 | 
74 | ## 3 锁
75 | 只介绍乐观与悲观锁
76 | 
77 | ##### 悲观锁 
78 | 对数据被外界修改持保守态度，因此，在整个数据处理过程中，数据处于锁定状态。悲观锁的实现往往依靠数据库提供的锁机制，在对任意记录进行修改前，先尝试为该记录加上排它锁，如果加锁失败，说明该记录正在被修改，那么当前查询可能要等待或者抛出异常。如果成功则执行修改，完成后解锁。在效率方面，处理枷锁的机制会让数据库产生额外的开销，尤其在几乎没有锁竞争的情况下加锁是在做无用功。
79 | 
80 | ##### 乐观锁
81 | 
82 | 乐观锁假定数据一般情况下不会发生锁冲突，所以在数据进行提交更新时，使用CAS操作监测是否有冲突发生，如果发生了冲突则返回错误信息，让用户决定如何去做（如回滚等）。实现乐观锁的一般有两种方式，一个使用版本号，一个是使用时间戳。乐观锁并发控制相信事务之间的竞争比较少，因此尽可能直接做下去，直到提交的时候才去检查。所以不会产生任何锁和死锁。但是这样对于存在并发的情况下会出现问题。
83 | 
84 | ## 数据库范式
85 | |范式|内容|
86 | |--|--|
87 | |第一范式|数据库表中的字段都是单一属性的，不可再分|
88 | |第二范式|数据库表中不存在非关键字段对任一候选关键字段的部分函数依赖，也即所有非关键字段都完全以阿里与任一组候选关键字。比如对于（学号，姓名，年龄，课程名称，成绩，学分）的关系，存在如下决定关系（学号，课程名称）->(姓名，年龄，成绩，学分)，还存在如下决定关系（学号）->(姓名，年龄)。这就不符合第二范式
89 | |第三范式|每个非关键字都不传递依赖于关系中的候选主键|
90 | 
91 | 
92 | 
93 | 
94 | 
95 | 


--------------------------------------------------------------------------------
/数据库/数据库优化与大数据量.md:
--------------------------------------------------------------------------------
  1 | # 数据库优化与大数据量
  2 | 
  3 | ## 1.MySQL调优
  4 | 
  5 | MySQL数据库是常见的两个瓶颈是CPU和I/O的瓶颈，CPU在饱和的时候一般发生在数据装入内存或从磁盘上读取数据时候。磁盘I/O瓶颈发生在装入数据远大于内存容量的时候。对于MySQL系统本身，可以使用工具来优化数据库的性能，通常有三种：使用索引，使用EXPLAIN分析查询以及调整MySQL的内部配置。
  6 | 
  7 | 在优化MySQL时，通常需要对数据库进行分析，常见的分析手段有**慢查询日志**，**EXPLAIN 分析查询**，**profiling分析**以及show命令查询系统状态及系统变量，通过定位分析性能的瓶颈，才能更好的优化数据库系统的性能。
  8 | 
  9 | 通过慢日志查询可以知道哪些SQL语句执行效率低下，通过explain我们可以得知SQL语句的具体执行情况，索引使用等，还可以结合show命令查看执行状态。
 10 | 
 11 | **通过explain命令可以得到:**
 12 | 
 13 | - 表的读取顺序
 14 | - 数据读取操作的操作类型
 15 | - 哪些索引可以使用
 16 | - 哪些索引被实际使用
 17 | - 表之间的引用
 18 | - 每张表有多少行被优化器查询
 19 | 
 20 | 如果觉得explain的信息不够详细，可以同通过profiling命令得到更准确的SQL执行消耗系统资源的信息。
 21 | 
 22 | 
 23 | 
 24 | ## 2.MySQL 对于千万级的大表要怎么优化
 25 | 
 26 | **可依次进行以下优化：**
 27 | 
 28 | - 优化SQL和索引
 29 | - 应用缓存机制 (memcached,redis)
 30 | - 进行主从复制或主主复制，读写分离
 31 | - 应用MySQL自带的分区表
 32 | - 垂直拆分
 33 | - 水平拆分
 34 | 
 35 | 
 36 | 
 37 | ## 3.MySQL数据库复制（主从、主主）
 38 | 
 39 | #### MySQL复制解决的问题
 40 | 
 41 | - 数据分布
 42 | - 负载平衡
 43 | - 备份
 44 | - 高可用性和容错行
 45 | 
 46 | #### 主从复制：
 47 | 
 48 | ![105353509.jpg](http://jbcdn2.b0.upaiyun.com/2015/11/8412e33ef81f950e8052fafad041731c.jpg)
 49 | 
 50 | **主从复制的原理：**
 51 | 
 52 | 分为同步复制和异步复制，实际复制架构中大部分为异步复制。 复制的基本过程如下：
 53 | 
 54 | 1).Slave上面的IO进程连接上Master，并请求从指定日志文件的指定位置（或者从最开始的日志）之后的日志内容；
 55 | 
 56 | 2).Master接收到来自Slave的IO进程的请求后，通过负责复制的IO进程根据请求信息读取制定日志指定位置之后的日志信息，返回给Slave 的IO进程。返回信息中除了日志所包含的信息之外，还包括本次返回的信息已经到Master端的bin-log文件的名称以及bin-log的位置；
 57 | 
 58 | 3).Slave的IO进程接收到信息后，将接收到的日志内容依次添加到Slave端的relay-log文件的最末端，并将读取到的Master端的 bin-log的文件名和位置记录到master-info文件中，以便在下一次读取的时候能够清楚的告诉Master“我需要从某个bin-log的哪个位置开始往后的日志内容，请发给我”；
 59 | 
 60 | 4).Slave的Sql进程检测到relay-log中新增加了内容后，会马上解析relay-log的内容成为在Master端真实执行时候的那些可执行的内容，并在自身执行。
 61 | 
 62 | **对于主从复制，Mysql数据库的版本，两个数据库版本要相同，或者slave比master版本低。**
 63 | 
 64 | #### 主主复制
 65 | 
 66 | 互为对方的从服务器，每台服务器即是对方的主服务器，又是对方的从服务器。但可能会面对主键重复等问题。
 67 | 
 68 | 
 69 | 
 70 | ## 4.读写分离
 71 | 
 72 | 读写分离，基本的原理是让主数据库(Master)处理事务性增、改、删操作（INSERT、UPDATE、DELETE），而从数据库(Slave)处理SELECT查询操作。数据库复制被用来把事务性操作导致的变更同步到集群中的从数据库。
 73 | 
 74 | 通过数据库**主从复制**实现读写分离，
 75 | 
 76 | **为什么读写分离可以提高提高性能？**
 77 | 
 78 | - 物理服务器增加，负荷能力增加
 79 | - 主从只负责各自的写和读，极大程度的缓解X锁和S锁争用
 80 | - 从库可配置myisam引擎，提升查询性能以及节约系统开销
 81 | - 读写分离适用与读远大于写的场景
 82 | - 分摊读取
 83 | - 可以增加冗余，提高可用性(一台数据库服务器宕机后能通过调整另外一台从库来以最快的速度恢复服务)
 84 | 
 85 | 
 86 | 
 87 | ## 5.数据库分库分表策略
 88 | 
 89 | 通过集群方案，解决了数据库宕机带来的单点数据库不能访问的问题；通过读写分离策略更是最大限度了提高了应用中读取 （Read）数据的速度和并发量。水平切分数据库，可以降低单台机器的负载，同时最大限度的降低了了宕机造成的损失。
 90 | 
 91 | 数据切分可以是物理 上的，对数据通过一系列的切分规则将数据分布到不同的DB服务器上，通过路由规则路由访问特定的数据库，这样一来每次访问面对的就不是单台服务器了，而是N台服务器，这样就可以降低单台机器的负载压力**（分库）**。数 据切分也可以是数据库内的 ，对数据通过一系列的切分规则，将数据分布到一个数据库的不同表中**（分表）**。
 92 | 
 93 | **分库分表方式和规则：**
 94 | 
 95 | - 设置分割区间（1-1000,1001-2000...）
 96 | 
 97 |   **优点：可部分迁移**
 98 | 
 99 |   **缺点：数据分布不均**
100 | 
101 | - hash取模（%4）
102 | 
103 |   **优点：数据分布均匀**
104 | 
105 |   **缺点：数据迁移的时候麻烦，不能按照机器性能分摊数据**
106 | 
107 | - 设置认证库保存数据映射关系
108 | 
109 |   **优点：灵活性强，一对一关系**
110 | 
111 |   **缺点：每次查询之前都要多一次查询，性能大打折扣**
112 | 
113 | 
114 | 
115 | 


--------------------------------------------------------------------------------
/数据库/数据库索引相关.md:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | # 数据库索引
  4 | 
  5 | 
  6 | 
  7 | ## 1. 什么是索引?
  8 | 
  9 | **数据库索引**，是数据库管理系统中一个排序的数据结构，以协助快速查询和排序。索引的实现通常使用B-树或其变种的B+树。
 10 | 
 11 | ## 2. 为什么要创建索引？
 12 | 
 13 | - 通过建立唯一索引，可以保证数据库表中每一行数据的唯一性；
 14 | - 可以大大加快数据检索速度（主要原因）；
 15 | - 可以加速表与表之间的连接，特别是在实现数据的参考完整性方面有重要作用；
 16 | - 可以在检索数据时，大大减少查询中分组和排序花费的时间；
 17 | - 使用索引可以在查询过程中使用优化隐藏器，提高系统性能。
 18 | 
 19 | ## 3. 索引存在不利的方面
 20 | 
 21 | - 创建和维护索引需要耗费时间，且会随着数据量的增加而增加；
 22 | - 创建索引需要占物理空间，聚集索引占空间更大；
 23 | - 对表中的数据进行增删改时，索引也需要动态维护。
 24 | 
 25 | ## 4. 索引的使用场景
 26 | 
 27 | | **需要创建索引**      | **不应该创建索引**                 |
 28 | | :-------------- | :-------------------------- |
 29 | | 1.经常需要搜索的列      | 1.查询中很少使用或者参考的列             |
 30 | | 2.经常用在连接上的列     | 2.只有很少数值的列（如：性别）            |
 31 | | 3.作为主键的列        | 3.定义为text, image, bit数据类型的列 |
 32 | | 4.经常需要根据范围搜索的列  | 4.修改性能远远大于检索性能时             |
 33 | | 5.经常需要排序的列      |                             |
 34 | | 6.经常在Where子句中的列 |                             |
 35 | 
 36 | ## 5. 索引的分类
 37 | 
 38 | - **普通索引**
 39 | 
 40 |   最基本的数据库索引，没有任何限制；
 41 | 
 42 | - **唯一索引**
 43 | 
 44 |   要求索引列的值必须唯一，但允许空值；
 45 | 
 46 | -  **主键索引**
 47 | 
 48 |   是一种特殊的唯一索引，不允许空值，一般在创建表的时候同时创建主键索引；
 49 | 
 50 | - **聚集索引**
 51 | 
 52 |   聚集索引中，各行的物理顺序与索引键值的逻辑顺序一致，且每张表最多只能有一个聚集索引。创建聚集索引要花更长的时间。（A,B,C）相当于分别建立了（A,B,C）,（A,B）, (A) 三种组合的索引。
 53 | 
 54 | ##### 聚集与否
 55 | 
 56 | | 类别    | 解释                                     |
 57 | | ----- | -------------------------------------- |
 58 | | 聚集索引  | 表数据按照索引的顺序来存储，叶子节点即存储了真实的数据行           |
 59 | | 非聚集索引 | 表数据存储与索引顺序无关，叶子节点包含索引字段值及指向数据页数据行的逻辑指针 |
 60 | 
 61 | ##### Mysql索引分类 复杂维度
 62 | 
 63 | 索引是在Mysql的存储引擎层实现的，而不是在服务层实现的。所以每种存储引擎的索引并不完全相同
 64 | 
 65 | | 类别        | 解释                                   |
 66 | | --------- | ------------------------------------ |
 67 | | B-Tree索引  | 最常见的索引类型，大部分引擎都支持B-Tree索引            |
 68 | | Hash索引    | 即使用列的Hash值作为索引查找，只用Memory引擎支持，使用场景简单 |
 69 | | R-Tree索引  | MyISAM的一种特殊索引，主要用于地理空间数据类型           |
 70 | | Full-text | 全文索引，MyISAM 和 InnoDB 支持              |
 71 | 
 72 | ## 6. 为什么索引数据结构选择B-树或B+树？
 73 | 
 74 | ​	索引文件很大，一般存储在磁盘上，而磁盘I/O十分耗时。使用索引的过程中要尽可能地减少查找过程中磁盘I/O的次数。B+树作为多路查找树，高度小，磁盘I/O次数少。数据库系统巧妙地应用磁盘预读原理，将一个结点的大小设置为一页，所以每个节点一次I/O就可以完全载入。而红黑树类似的结构，高度更深，且逻辑上很近的节点物理上也可能很远，无法利用局部性。
 75 | 
 76 | 
 77 | 
 78 | ## 7. 如何创建索引？
 79 | 
 80 | ```mysql
 81 | CREATE INDEX indexName ON mytable(username(length));                                  //普通索引
 82 | CREATE UNIQUE INDEX indexName ON mytable(username(length));                           //唯一索引
 83 | CREATE TABLE mytable(ID INT NOT NULL,username VARCHAR(16) NOT NULL,PRIMARY KEY(ID) ); //主键索引
 84 | ALTER TABLE mytable ADD INDEX indexName (username(16),time(10))                       //聚集索引
 85 | ```
 86 | 
 87 | ## 8. 何时会发生索引失效？
 88 | 
 89 | - 隐式转换导致索引失效；
 90 | - 对索引列进行计算导致索引失效；
 91 | - like "%_" 百分号在前；
 92 | - 索引字段进行判空查询时；
 93 | - 复合索引中的前导列没有被作为查询条件；
 94 | - 判断索引列是否不等于某个值时。
 95 | 
 96 | ## 9. MySQL存储引擎
 97 | 
 98 | | 特点   | MyISAM | InnoDB |
 99 | | ---- | ------ | ------ |
100 | | 存储限制 | 无      | 64TB   |
101 | | 事务安全 |        | 支持     |
102 | | 锁机制  | 表锁     | 行锁     |
103 | | B树索引 | 支持     | 支持     |
104 | | 哈希索引 |        | 支持     |
105 | | 全文索引 | 支持     |        |
106 | | 数据缓存 |        | 支持     |
107 | | 支持外键 |        | 支持     |
108 | | 操作效率 | 高      | 低      |
109 | 
110 | 备注：最新版本的MySQL默认的存储引擎是InnoDB。count(*)操作，因为MyISAM内置了计数器，所以更快，InnnoDB需要扫描全表。


--------------------------------------------------------------------------------
/数据结构与算法/1.LRU算法（缓存淘汰算法）.md:
--------------------------------------------------------------------------------
  1 | # 缓存淘汰算法--LRU算法
  2 | 
  3 | **LRU**是Least Recently Used的缩写，即最近最少使用页面置换算法，是为虚拟页式存储管理服务的，是根据页面调入内存后的使用情况进行决策了。由于无法预测各页面将来的使用情况，只能利用“最近的过去”作为“最近的将来”的近似，因此，LRU算法就是将最近最久未使用的页面予以淘汰。
  4 | 
  5 | 可以用一个特殊的栈来保存当前正在使用的各个页面的页面号。当一个新的进程访问某页面时，便将该页面号压入栈顶，其他的页面号往栈底移，如果内存不够，则将栈底的页面号移除。这样，栈顶始终是最新被访问的页面的编号，而栈底则是最近最久未访问的页面的页面号。
  6 | 
  7 | 如输入以下序列时：4,7,0,7,1,0,1,2,1,2,6
  8 | 
  9 |  结果为：
 10 | 
 11 | 4        
 12 | 4        7        
 13 | 4        7        0        
 14 | 4        0        7        
 15 | 4        0        7        1        
 16 | 4        7        1        0        
 17 | 4        7        0        1        
 18 | 4        7        0        1        2        
 19 | 4        7        0        2        1        
 20 | 4        7        0        1        2       
 21 | 7        0        1        2        6        
 22 | 
 23 | **用java代码实现LRU算法如下：**
 24 | 
 25 | ```
 26 | import java.util.ArrayList;
 27 | import java.util.List;
 28 | 
 29 | 
 30 | public class LRU {
 31 | 	/**
 32 | 	 * 内存块的个数
 33 | 	 */
 34 | 	public static final int N = 5;
 35 | 	/**
 36 | 	 * 内存块数组
 37 | 	 */
 38 | 	Object[] array = new Object[N];
 39 | 	private int size;
 40 | 	
 41 | 	public LRU() {
 42 | 	}
 43 | 	/**
 44 | 	 * 判断内存区是否为空
 45 | 	 * @return
 46 | 	 */
 47 | 	public boolean isEmpty() {
 48 | 		if(size == 0) {
 49 | 			return true;
 50 | 		} else {
 51 | 			return false;
 52 | 		}
 53 | 	}
 54 | 	/**
 55 | 	 * 判断内存区是否达到最大值
 56 | 	 * @return
 57 | 	 */
 58 | 	public boolean isOutOfBoundary() {
 59 | 		if(size >=N) {
 60 | 			return true;
 61 | 		} else {
 62 | 			return false;
 63 | 		}
 64 | 	}
 65 | 	/**
 66 | 	 * 查找元素o在数组中的位置
 67 | 	 * @param o
 68 | 	 * @return
 69 | 	 */
 70 | 	public int indexOfElement(Object o) {
 71 | 		for(int i=0; i<N; i++) { 
 72 | 			if(o == array[i]) {
 73 | 				return i;
 74 | 			}
 75 | 		}
 76 | 		return -1;
 77 | 	}	
 78 | 	/**
 79 | 	 * 有新的数据o需要申请内存
 80 | 	 * @param o
 81 | 	 * @return 移出内存区的数据
 82 | 	 */
 83 | 	public Object push(Object o) {
 84 | 		int t = -1;
 85 | 		if(!isOutOfBoundary() && indexOfElement(o) == -1){
 86 | 			array[size] = o;
 87 | 			size ++;
 88 | 		} else if(isOutOfBoundary() && indexOfElement(o) == -1){
 89 | 			for(int i=0; i<size-1; i++) {
 90 | 				array[i] = array[i+1];				
 91 | 			}
 92 | 			array[size-1] = o;
 93 | 		} else {
 94 | 			t = indexOfElement(o);
 95 | 			for(int i=t; i<size-1; i++) {
 96 | 				array[i] = array[i+1];
 97 | 			}
 98 | 			array[size-1] = o;
 99 | 		}
100 | 		if( -1 == t) {
101 | 			return null;
102 | 		} else {
103 | 			return array[t];
104 | 		}
105 | 	}
106 | 	/**
107 | 	 * 输出内存区中的各数据
108 | 	 */
109 | 	public void showMemoryBlock() {
110 | 		for(int i=0; i<size; i++) {
111 | 			System.out.print(array[i] + "\t");
112 | 		}
113 | 	}
114 | 
115 | 	/**
116 | 	 * @param args
117 | 	 */
118 | 	public static void main(String[] args) {
119 | 		Integer iter[] = {4,7,0,7,1,0,1,2,1,2,6};
120 | 		LRU lru = new LRU();
121 | 		for(int i=0; i<iter.length; i++) {
122 | 			lru.push(iter[i]);
123 | 			lru.showMemoryBlock();
124 | 			System.out.println();
125 | 		}
126 | 	}
127 | 
128 | }
129 | ```
130 | 
131 |  LRU算法也可以用于一些实际的应用中，如你要做一个浏览器，或类似于淘宝客户端的应用的就要用到这个原理。大家都知道浏览器在浏览网页的时候会把下载的图片临时保存在本机的一个文件夹里，下次再访问时就会，直接从本机临时文件夹里读取。但保存图片的临时文件夹是有一定容量限制的，如果你浏览的网页太多，就会一些你最不常使用的图像删除掉，只保留最近最久使用的一些图片。这时就可以用到LRU算法 了，这时上面算法里的这个特殊的栈就不是保存页面的序号了，而是每个图片的序号或大小；所以**上面这个栈的元素都用Object类来表示，这样的话这个栈就可以保存的对像了。**


--------------------------------------------------------------------------------
/数据结构与算法/2.排序算法.md:
--------------------------------------------------------------------------------
  1 | # 排序 #
  2 | 
  3 | ## 插入排序 ##
  4 | 插入排序与现实生活中打扑克的抓牌的过程是一样的。对于一个新的值A[i],从i-1逐个向前检查，直到遇到比A[i]更小的元素将其插入，当然，需要把目标位置以后的所有项向后移动。代码如下
  5 | ```java
  6 |   public void InsertSort(int[] A) {
  7 |         for (int i = 2; i < A.length; i++) {
  8 |             int key = A[i];
  9 |             int j = i - 1;
 10 |             while (j >= 0 && A[j] > key) {
 11 |                 A[j + 1] = A[j];
 12 |                 j--;
 13 |             }
 14 |             A[j + 1] = key;
 15 |         }
 16 |     }
 17 | ```
 18 | 可以发现，插入排序在本身数组排序较好的情况所有的元素都不需要移动，执行过程只是顺序的访问数组元素，所以时间复杂度是O(n)，而在最坏情况下，即所有的元素倒序排列时，由于每一个元素都要移动到已排序数组的顶端，所以时间复杂度为O(n2)。插入排序一般不使用。
 19 | 
 20 | * 平均时间复杂度 O(n^2)
 21 | * 最好时间复杂度 O(n)
 22 | * 最坏时间复杂度 O(n^2)
 23 | * 空间复杂度 O(1)
 24 | * 稳定
 25 | 
 26 | 
 27 | ## 归并排序 ##
 28 | 归并排序基于分治的思想，将一个大的问题分解为多个子问题，分别求解子问题，最后合并子问题得到原问题的解
 29 | ```java
 30 |  public void MergeSort(int[] A, int p, int r) {
 31 |         if (p < r) {
 32 |             int q = (p + r) / 2;
 33 |             MergeSort(A, p, q);
 34 |             MergeSort(A, q + 1, r);
 35 |             Merge(A, p, q, r);
 36 |         }
 37 |     }
 38 | 
 39 |     public void Merge(int[] A, int p, int q, int r) {
 40 |         int n1 = q - p + 1;
 41 |         int n2 = r - q;
 42 | 
 43 |         int[] left = new int[n1 + 1];
 44 |         int[] right = new int[n2 + 1];
 45 | 
 46 |         for (int i = 0; i < n1; i++) {
 47 |             left[i] = A[p + i];
 48 |         }
 49 |         left[n1] = Integer.MAX_VALUE;
 50 | 
 51 |         for (int j = 0; j < n2; j++) {
 52 |             right[j] = A[q + 1 + j];
 53 |         }
 54 |         right[n2] = Integer.MAX_VALUE;
 55 | 
 56 | 
 57 |         int x = 0;
 58 |         int y = 0;
 59 | 
 60 |         for (int k = p; k <= r; k++) {
 61 |             if (left[x] < right[y]) {
 62 |                 A[k] = left[x];
 63 |                 x++;
 64 |             } else {
 65 |                 A[k] = right[y];
 66 |                 y++;
 67 |             }
 68 |         }
 69 |     }
 70 | ```
 71 | 以上Merge函数为了能够正常处理边界情况，在每个待Merge的数组的末尾添加了一个无穷大的哨兵。这几假设所有的值都不会大于0x7fffffff
 72 | 归并排序的时间复杂度是O(nlgn)，由于每一次归并，都需要建立额外的数组，所以空间复杂度也为O(n)
 73 | 
 74 | * 平均时间复杂度 O(nlgn)
 75 | * 最好时间复杂度 O(nlgn)
 76 | * 最坏时间复杂度 O(nlgn)
 77 | * 空间复杂度 O(n)
 78 | * 稳定
 79 | 
 80 | ## 堆排序 ##
 81 | 
 82 | 堆排序基于一种最大堆，最大堆的父节点大于两个子节点。堆的数据存储在一个数组中，通过数组的下标可以计算出父子兄弟节点。所以最大堆一定是平衡二叉树。在介绍堆排序算法之前，我们先看一下如何维持最大堆的性质，因为对于一个给定地数组，我们首先需要将其转化为一个最大堆才能使用堆排序
 83 | 
 84 | 简单的获取父子节点函数
 85 | ```java
 86 | 
 87 |     public int parent(int i) {
 88 |         return (i-1) / 2;
 89 |     }
 90 | 
 91 |     public int left(int i) {
 92 |         return 2 * (i+1) -1;
 93 |     }
 94 | 
 95 |     public int right(int i) {
 96 |         return 2 * (i + 1);
 97 |     }
 98 | 
 99 | ```
100 | 
101 | 维护最大堆性质的思想是，对于给定的i，比较i与其两个子节点，选出最大的值放在i位置，如果发生交换，则递归向下维护交换后的节点最大堆性质
102 | 代码如下
103 | ```java
104 |  public void MaxHeapify(int[] A, int i) {
105 |         int l = left(i);
106 |         int r = right(i);
107 | 
108 |         int largest = i;
109 |         if (l < A.length && A[l] > A[i]) {
110 |             largest = l;
111 |         }
112 | 
113 |         if (r < A.length && A[r] > A[largest]) {
114 |             largest = r;
115 |         }
116 | 
117 |         if(largest != i){
118 |             int temp = A[i];
119 |             A[i] = A[largest];
120 |             A[largest] = temp;
121 | 
122 |             MaxHeapify(A, largest);
123 |         }
124 |  }
125 | ```
126 | 到此，对于任意给定的数组A,其长度为n，我们发现数组中(n/2)-n都是叶节点，所以我们可以不对其进行性质维持。代码如下
127 | ```java
128 |     public void BuildMaxHeap(int[] A) {
129 |         for (int i = (A.length-1) / 2; i >= 0; i--) {
130 |             MaxHeapify(A, i);
131 |         }
132 |     }
133 | ```
134 | 堆排序算法的思想是将堆中的最后一个元素与第一个元素交换，这样最大的元素位与堆的尾部。针对第一个元素维护最大堆的性质，依次循环。
135 | 代码如下
136 | ```java
137 |     public void HeapSort(int[] A){
138 |         BuildMaxHeap(A);
139 |         for(int i = A.length-1; i>0; i--){
140 |             int temp = A[i];
141 |             A[i] = A[0];
142 |             A[0] = temp;
143 |             MaxHeapify(A,0, i);
144 |         }
145 |     }
146 | ```
147 | 每次调用MaxHeapify的复杂度是O(lgn), 共有n个元素所以复杂度为O(nlgn)。而建堆的过程是对n/2个元素依次调用MaxHeapify，所以其时间复杂度也是O(nlgn)
148 | 
149 | * 平均时间复杂度 O(nlgn)
150 | * 最好时间复杂度 O(nlgn)
151 | * 最坏时间复杂度 O(nlgn)
152 | * 空间复杂度 O(1)
153 | * 不稳定
154 | 
155 | ## 快速排序 ##
156 | 快速排序的基本思想是选取数组中的一个值x，将所有大于x的项移动到x右边，所有小于x的项移动到x的左边。然后对于两边的两个子数组递归的执行此步骤。代码如下
157 | ```java
158 | public void quickSort(int[] A, int left, int right) {
159 |         if (left >= right) {
160 |             return;
161 |         }
162 | 
163 |         int midIndex = (left + right) / 2;
164 |         int pivot = A[midIndex];
165 | 
166 |         int i = left;
167 |         int j = right;
168 | 
169 |         while (i <= j) {
170 |             while (A[i] < pivot) {
171 |                 i++;
172 |             }
173 |             while (A[j] > pivot) {
174 |                 j--;
175 |             }
176 | 
177 |             if (i <= j) {
178 |                 int temp = A[i];
179 |                 A[i] = A[j];
180 |                 A[j] = temp;
181 |                 i++;
182 |                 j--;
183 |             }
184 |         }
185 | 
186 |         quickSort(A, left, j);
187 |         quickSort(A, i, right);
188 |     }
189 | ```
190 | 快速排序的时间复杂度的分析与归并排序类似，对于元素x的左右分化，只要其分化的分数是常数比例，递归树的深度就是lgn，而每次调用都会处理n个元素，所以时间复杂度是O(nlgn)。比例划分越均衡，每一层处理的项数cn中的c越小，比例越不均衡，每一层处理的项数越多，也即复杂度常数项越大。可以考虑当数组为降序排列，我们选择的划分元素是数组的最后一个元素，则第i此循环需要移动n-i个元素，总和为n/2,总共n次，所以在这种最坏情况下其复杂度为O(n2)
191 | 
192 | 在数组规模较小的情况下，快速排序还需要进行多次的递归调用，比较浪费资源，所以对快速排序的一种优化方法是在子数组的规模较小时选择其他的排序方式代替。
193 | 
194 | 实际应用中，由于序列往往是有一定顺序的，快速排序是上述排序算法中速度最快的。
195 | 
196 | * 平均时间复杂度 O(nlgn)
197 | * 最好时间复杂度 O(nlgn)
198 | * 最坏时间复杂度 O(n^2)
199 | * 空间复杂度 O(lgn)
200 | * 不稳定
201 | 
202 | 
203 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Ant_Algorithm.c:
--------------------------------------------------------------------------------
  1 | //蚁群算法关于简单的TSP问题求解//
  2 | #include <stdio.h>
  3 | #include <stdlib.h>
  4 | #include <string.h>
  5 | #include <math.h>
  6 | #include <time.h>
  7 | 
  8 | #define M 13  //蚂蚁的数量
  9 | #define N 52  //城市的数量
 10 | #define R 1000 //迭代次数
 11 | #define IN 1  //初始化的信息素的量
 12 | #define MAX 0x7fffffff //定义最大值
 13 | 
 14 | struct coordinate
 15 | {
 16 | 	char city[15];  //城市名
 17 | 	int x;          //城市相对横坐标
 18 | 	int y;          //城市相对纵坐标
 19 | }coords[N];
 20 | 
 21 | double graph[N][N];   //储存城市之间的距离的邻接矩阵,自己到自己记作MAX
 22 | double phe[N][N];  //每条路径上的信息素的量
 23 | double add[N][N];  //代表相应路径上的信息素的增量
 24 | double yita[N][N]; //启发函数,yita[i][j]=1/graph[i][j]
 25 | 
 26 | int vis[M][N];  //标记已经走过的城市
 27 | int map[M][N];  //map[K][N]记录第K只蚂蚁走的路线
 28 | double solution[M]; //记录某次循环中每只蚂蚁走的路线的距离
 29 | int bestway[N]; //记录最近的那条路线
 30 | double bestsolution=MAX;
 31 | int NcMax; //代表迭代次数,理论上迭代次数越多所求的解更接近最优解,最具有说服力
 32 | double alpha,betra,rou,Q;
 33 | 
 34 | void Initialize(); //信息初始化
 35 | void Inputcoords(FILE *fp); //将文件中的坐标信息读入
 36 | void GreateGraph(); //根据坐标信息建图
 37 | double Distance(int *p); //计算蚂蚁所走的路线的总长度
 38 | void Result(); //将结果保存到out.txt中
 39 | 
 40 | void Initialize()//初始化参数和迭代次数
 41 | {
 42 | 	alpha=2; betra=4; rou=0.5; Q=50;
 43 |     NcMax=R;
 44 | 	return ;
 45 | }
 46 | //从文件读入城市坐标
 47 | void Inputcoords(FILE *fp)
 48 | {
 49 | 	int i;
 50 | 	int number;
 51 | 	if(fp==NULL)
 52 | 	{
 53 | 		printf("Sorry,the file is not exist\n");
 54 | 		exit(1);
 55 | 	}
 56 | 	else
 57 | 	{
 58 | 		for(i=0; i<N; ++i)
 59 | 		{
 60 | 			fscanf(fp,"%d,%d,%d,%s",&number,&coords[i].x,&coords[i].y,coords[i].city);
 61 | 		}
 62 | 	}
 63 | }
 64 | //初始化任意两个城市间的距离
 65 | void GreateGraph( )
 66 | {
 67 | 	int i,j;
 68 | 	double d;
 69 | 	for(i=0; i<N-1; ++i)
 70 | 	{
 71 | 		graph[i][i]=MAX;   //自己到自己标记为无穷大
 72 | 		for(j=i+1; j<N; ++j)
 73 | 		{
 74 | 			d=(double)((coords[i].x-coords[j].x)*(coords[i].x-coords[j].x)+(coords[i].y-coords[j].y)*(coords[i].y-coords[j].y));
 75 | 			graph[j][i]=graph[i][j]=sqrt(d);
 76 | 		}
 77 | 	}
 78 | 	graph[N-1][N-1]=MAX;
 79 | 	return ;
 80 | }
 81 | //计算环路的最小代价
 82 | double Distance(int *p)
 83 | {
 84 | 	double d=0;
 85 | 	int i;
 86 | 	for(i=0; i<N-1; ++i)
 87 | 	{
 88 | 		d+=graph[*(p+i)][*(p+i+1)];
 89 | 	}
 90 | 	d+=graph[*(p+i)][*(p)];
 91 | 	return d;
 92 | }
 93 | //输出各个结果
 94 | void Result()
 95 | {
 96 | 	FILE *fl;
 97 | 	int i;
 98 | 	fl = fopen("out.txt","a");  //将结果保存在out.txt这个文件里面
 99 | 	fprintf(fl,"%s\n","本次算法中的各参数如下:");
100 | 	fprintf(fl,"alpha=%.3lf, betra=%.3lf, rou=%.3lf, Q=%.3lf\n",alpha,betra,rou,Q);
101 | 	fprintf(fl,"%s %d\n","本次算法迭代次数为:",NcMax);
102 | 	fprintf(fl,"%s %.4lf\n","本算法得出的最短路径长度为:",bestsolution);
103 | 	fprintf(fl,"%s\n","本算法求得的最短路径为:");
104 | 	for(i=0; i<N; ++i)
105 | 		fprintf(fl,"%s →  ",coords[bestway[i]].city);
106 | 	fprintf(fl,"%s",coords[bestway[0]].city);
107 | 	fprintf(fl,"\n\n\n");
108 | 	fclose(fl);
109 | 	return ;
110 | }
111 | 
112 | int main()
113 | {
114 | 	int NC=0;//迭代次数
115 | 	int i,j,k;
116 | 	int s;
117 | 	double drand,pro,psum;
118 | 	FILE *fp;
119 | 	Initialize();
120 | 	fp = fopen("coords.txt","r+");
121 | 	Inputcoords(fp);
122 | 	GreateGraph();
123 | 	fclose(fp);
124 | 	for(i=0; i<N; ++i)//初始化
125 | 	{
126 | 		for(j=0; j<N; ++j)
127 | 		{
128 | 			phe[i][j]=IN; //信息素初始化
129 | 			if(i!=j)
130 | 			yita[i][j]=100.0/graph[i][j];  //期望值,与距离成反比
131 | 		}
132 | 	}
133 | 	memset(map,-1,sizeof(map));  //把蚂蚁走的路线置空
134 | 	memset(vis,0,sizeof(vis));  //0表示未访问,1表示已访问
135 | 	srand(time(NULL));
136 | 	while(NC++<=NcMax)//迭代次数小于等于最大值
137 | 	{
138 | 		for(k=0; k<M; ++k)
139 | 		{
140 | 			map[k][0]=(k+NC)%N; //给每只蚂蚁分配一个起点,并且保证起点在N个城市里
141 | 			vis[k][map[k][0]]=1; //将起点标记为已经访问，第k个蚂蚁第1个点标记为访问。每个蚂蚁都有一个map
142 | 		}
143 | 		s=1;//当前每个蚂蚁应该走的第几个城市，下标从0开始，0是每个蚂蚁的起点且已经走过
144 | 		while(s<N)
145 | 		{
146 | 			for(k=0; k<M; ++k)//为第k个蚂蚁选择下一个城市
147 | 			{
148 | 				psum=0;//Pij（概率）的分母部分，按照公式来计算
149 | 				for(j=0; j<N; ++j)
150 | 				{
151 | 					if(vis[k][j]==0)
152 | 					{
153 | 						psum+=pow(phe[map[k][s-1]][j],alpha)*pow(yita[map[k][s-1]][j],betra);
154 | 					}
155 | 				}
156 | 				drand=(double)(rand()%5000);
157 | 				drand/=5000.0;  //生成一个小于1的随机数（轮盘随机）
158 | 				pro=0;//累计的概率之和，当和大于随机数的时候，代表选中当前城市，很形象的模拟
159 | 				for(j=0; j<N; ++j)
160 | 				{
161 | 					if(vis[k][j]==0)
162 | 					pro+=pow(phe[map[k][s-1]][j],alpha)*pow(yita[map[k][s-1]][j],betra)/psum;
163 | 					if(pro>drand)
164 | 					break;
165 | 				}
166 | 				vis[k][j]=1;  //将走过的城市标记起来（选中j，将j标记）
167 | 				map[k][s]=j;  //记录城市的顺序
168 | 			}
169 | 			s++;
170 | 		}//一次迭代完成
171 | 		memset(add,0,sizeof(add));
172 | 		for(k=0; k<M; ++k)  //计算本次中的最短路径//
173 | 		{
174 | 			solution[k]=Distance(map[k]);  //蚂蚁k所走的路线的总长度
175 | 			if(solution[k]<bestsolution)
176 | 			{
177 | 				bestsolution=solution[k];
178 | 				for(i=0; i<N; ++i)
179 | 					bestway[i]=map[k][i];//记录当前最好的路径
180 | 			}
181 | 		}
182 | 		for(k=0; k<M; ++k)
183 | 		{
184 | 			for(j=0; j<N-1; ++j)//计算路径上信息素的增量
185 | 			{
186 | 				add[map[k][j]][map[k][j+1]]+=Q/solution[k];
187 | 			}
188 | 			add[N-1][0]+=Q/solution[k];//首尾相接
189 | 		}
190 | 		for(i=0; i<N; ++i)
191 | 		{
192 | 			for(j=0; j<N; ++j)
193 | 			{
194 | 				phe[i][j]=phe[i][j]*rou+add[i][j];//更新信息素
195 | 				if(phe[i][j]<0.0001)  //设立一个下界
196 | 					phe[i][j]=0.0001;
197 | 				else if(phe[i][j]>20)  //设立一个上界,防止启发因子的作用被淹没
198 | 					phe[i][j]=20;
199 | 			}
200 | 		}
201 | 		memset(vis,0,sizeof(vis));
202 | 		memset(map,-1,sizeof(map));
203 | 	}
204 | 
205 | 	Result();
206 | 	printf("Result is saved in out.txt\n");
207 | 	return 0;
208 | }
209 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Binary_Indexed_Tree.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | TreeArray.h
  3 | 树状数组，一维和二维都有。数组必须从1开始
  4 | 
  5 | 问题：
  6 | 已知数组a[],元素个数为n,现在更改a中的元素,要求得新的a数组中i到j区间内的和
  7 | 
  8 | 解决方法：
  9 | 从图中不难发现,c[k]存储的实际上是从k开始向前数k的二进制表示中右边第一个1所代表的数字
 10 | 个元素的和(这么说可能有点拗口,令lowbit为k的二进制表示中右边第一个1所代表的数字,然后
 11 | c[k]里存的就是从a[k]开始向前数lowbit个元素之和)
 12 | C1 = A1
 13 | C2 = A1 + A2
 14 | C3 = A3
 15 | C4 = A1 + A2 + A3 + A4
 16 | C5 = A5
 17 | C6 = A5 + A6
 18 | C7 = A7
 19 | C8 = A1 + A2 + A3 + A4 + A5 + A6 + A7 + A8
 20 | 
 21 | 这么存的好处：
 22 | 无论是树状数组还是线段树,都用到了分块的思想
 23 | 方便计算,我们可以用位运算轻松地算出lowbit.
 24 | 
 25 | 时间复杂度:
 26 | 对于更改元素来说,如果第i个元素被修改了,可以直接在c数组里面进行相应的更改,如图中的例子,
 27 | 假设更改的元素是a[2],那么它影响到得c数组中的元素只有c[2],c[4],c[8],我们只需一层一层往
 28 | 上修改就可以了,这个过程的最坏的复杂度也不过O(logN);
 29 | 对于查找来说,如查找s[k],只需查找k的二进制表示中1的个数次就能得到最终结果,比如查找s[7],7的二进制表示中有3个1,也就是要查
 30 | 找3次,到底是不是呢,我们来看上图,s[7]=c[7]+c[6]+c[4]
 31 | 
 32 | 怎么实现这个过程：
 33 | 还以7为例,二进制为0111,右边第一个1出现在第0位上,也就是说要从a[7]开始向前数1个元素(只
 34 | 有a[7]),即c[7];
 35 | 然后将这个1舍掉,得到6,二进制表示为0110,右边第一个1出现在第1位上,也就是说要从a[6]开始
 36 | 向前数2个元素(a[6],a[5]),即c[6];
 37 | 然后舍掉用过的1,得到4,二进制表示为0100,右边第一个1出现在第2位上,也就是说要从a[4]开始
 38 | 向前数4个元素(a[4],a[3],a[2],a[1]),即c[4].
 39 | */
 40 | #include<iostream>  
 41 | using namespace std; 
 42 | 
 43 | #define MAX 1002
 44 | 
 45 | class TreeArray
 46 | {
 47 | public:
 48 | 	int **s;
 49 | 	int type;
 50 | public:
 51 | 	TreeArray(int t);
 52 | 	~TreeArray();
 53 | 	void clear();
 54 | 	int lowbit(int x){return x&(-x);};
 55 | 	void modify(int x, int value);
 56 | 	void modify(int x, int y, int value);
 57 | 	int sum(int x);
 58 | 	int sum(int x, int y);
 59 | };
 60 | TreeArray::TreeArray(int t):type(t)
 61 | {
 62 | 	int i;
 63 | 	s = new int*[MAX+1];
 64 | 	//一维
 65 | 	if(type == 1)
 66 | 	{
 67 | 		for(i = 0; i <= MAX; i++)
 68 | 			s[i] = new int;
 69 | 	}
 70 | 	//二维
 71 | 	else if(type == 2)
 72 | 	{
 73 | 		for(i = 0; i <= MAX; i++)
 74 | 			s[i] = new int[MAX+1];
 75 | 	}
 76 | }
 77 | TreeArray::~TreeArray()
 78 | {
 79 | 	int i;
 80 | 	for(i = 0; i <= MAX; i++)
 81 | 		delete []s[i];
 82 | 	delete []s;
 83 | }
 84 | void TreeArray::clear()
 85 | {
 86 | 	int i, j;
 87 | 	for(i = 0; i <= MAX; i++)
 88 | 	{
 89 | 		if(type == 1)
 90 | 			s[i][0] = 0;
 91 | 		else
 92 | 		{
 93 | 			for(j = 0; j <= MAX; j++)
 94 | 				s[i][j] = 0;
 95 | 		}
 96 | 	}
 97 | }
 98 | void TreeArray::modify(int x, int value)
 99 | {
100 | 	while(x <= MAX)
101 | 	{
102 | 		s[x][0] += value;
103 | 		x += lowbit(x);
104 | 	}
105 | }
106 | void TreeArray::modify(int x,int y,int value)
107 | {  
108 | 	int temp = y;
109 | 	while(x <= MAX)
110 | 	{
111 | 		y = temp;
112 | 		while(y <= MAX)
113 | 		{
114 | 			s[x][y] += value;
115 | 			y = y + lowbit(y);
116 | 		}
117 | 		x = x + lowbit(x);
118 |     }     
119 | }  
120 | int TreeArray::sum(int x)
121 | {
122 | 	int ans=0;
123 | 	while(x > 0)
124 | 	{
125 | 		ans += s[x][0];
126 | 		x -= lowbit(x);
127 | 	}
128 | 	return ans;
129 | }
130 | int TreeArray::sum(int x,int y)
131 | {  
132 |     int ans=0, temp = y;  
133 | 	while(x > 0)
134 | 	{
135 | 		y = temp;
136 | 		while(y > 0)
137 | 		{
138 | 			ans += s[x][y];
139 | 			y = y - lowbit(y);
140 | 		}
141 | 		x = x - lowbit(x);
142 | 	}
143 |     return ans;  
144 | }  
145 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Binary_Search.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <algorithm>
 3 | using namespace std;
 4 | const int N = 7;
 5 | int Binary_Search(int a[], int low, int high, int key)//二分查找
 6 | {
 7 |     while(low <= high)
 8 |     {
 9 |         int mid = (low+high)/2;
10 |         if(a[mid] == key)
11 |         {
12 |             return mid;
13 |         }
14 |         else if(a[mid] > key)
15 |         {
16 |             high = mid -1;
17 |         }
18 |         else
19 |         {
20 |             low = mid + 1;
21 |         }
22 |     }
23 |     return -1;
24 | }
25 | int main()
26 | {
27 |     int a[N] = {1,4,6,9,22,34,100};//数组元素可自定义
28 |     int n;
29 |     //sort(a, a+N);
30 |     while(1)
31 |     {
32 |         printf("Search number:");
33 |         scanf("%d", &n);
34 |         if(!n)//输入0表示不再查询，循环终止
35 |         {
36 |             break;
37 |         }
38 |         if(Binary_Search(a, 0, N-1, n) == -1)
39 |         {
40 |             printf("No such a number!\n");
41 |             continue;
42 |         }
43 |         printf("The position of number %d is %d\n", n, Binary_Search(a, 0, N-1, n)+1);
44 |     }
45 |     return 0;
46 | }
47 | 
48 | 
49 | //-------------------------------------------------------------------------------------------------------------------------------------
50 | #include <stdio.h>
51 | const int N = 10;
52 | int Binary_Search(int a[], int low, int high, int key)//二分查找
53 | {
54 |     while(low <= high)
55 |     {
56 |         int mid = (low+high)/2;
57 |         if(a[mid] == key)
58 |         {
59 |             return mid;
60 |         }
61 |         else if(a[mid] > key)
62 |         {
63 |             high = mid -1;
64 |         }
65 |         else
66 |         {
67 |             low = mid + 1;
68 |         }
69 |     }
70 |     return -1;
71 | }
72 | int main()
73 | {
74 | 	int a[N], n;
75 | 	for(int i = 0; i < N; i++)
76 | 	{
77 | 		a[i] = i;
78 | 	}
79 | 	char *name[N] = {"Xu", "Li", "Zhang", "Chen", "He", "Liu", "Zhu", "Zhao", "Zhu", "Wu"};
80 | 	while(1)
81 | 	{
82 | 		printf("Input the student number:");
83 | 		scanf("%d", &n);
84 | 		n %= 10;
85 | 		n = Binary_Search(a, 0, N-1, n);
86 | 		printf("Name: %s\n", name[n]);
87 | 	}
88 | 	return 0;
89 | }
90 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/GCD.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int GCD(int n, int m)
 3 | {
 4 |     return n % m == 0 ? m : GCD(m, n % m);
 5 | }
 6 | int main()
 7 | {
 8 |     int n, m;
 9 |     while(scanf("%d%d", &n, &m) && n && m)
10 |     {
11 |         printf("The Greatest Common Divisor of %d and %d is %d\n", n, m, GCD(n, m));
12 |     }
13 |     return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/LIS.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | 参考: http://qiemengdao.iteye.com/blog/1660229
  3 | 
  4 | 
  5 | //DP:
  6 | #include <stdio.h>
  7 | #include <iostream>
  8 | #include <algorithm>
  9 | using namespace std;
 10 | #define len(a) (sizeof(a) / sizeof(a[0])) //数组长度
 11 | int lis1(int arr[], int len)//最长递增子序列
 12 | {
 13 |     int longest1[len];
 14 |     for (int i=0; i<len; i++)
 15 |     {
 16 |         longest1[i] = 1;
 17 |     }
 18 |     for (int j=1; j<len; j++)
 19 |     {
 20 |         for (int i=0; i<j; i++) 
 21 |         {
 22 |             if (arr[j]>arr[i] && longest1[j]<longest1[i]+1)
 23 |             { //注意longest[j]<longest[i]+1这个条件，不能省略。
 24 |                 longest1[j] = longest1[i] + 1; //计算以arr[j]结尾的序列的最长递增子序列长度
 25 |             }
 26 |         }
 27 |     }
 28 |     int mmax = 0;
 29 |     for (int j=0; j<len; j++)
 30 |     {
 31 |         if (longest1[j] > mmax) 
 32 |         {
 33 |             mmax = longest1[j]; 
 34 |         } //从longest[j]中找出最大值
 35 |     }
 36 |     return mmax;
 37 | }
 38 | int lis2(int arr[], int len)//最长递减子序列
 39 | {
 40 |     int longest2[len];
 41 |     for (int i=0; i<len; i++)
 42 |     {
 43 |         longest2[i] = 1;
 44 |     }
 45 |     for (int j=1; j<len; j++) 
 46 |     {
 47 |         for (int i=0; i<j; i++) 
 48 |         {
 49 |             if (arr[j]<arr[i] && longest2[j]<longest2[i]+1)
 50 |             { //注意longest[j]<longest[i]+1这个条件，不能省略。
 51 |                 longest2[j] = longest2[i] + 1; //计算以arr[j]结尾的序列的最长递增子序列长度
 52 |             }
 53 |         }
 54 |     }
 55 |     int mmax = 0;
 56 |     for (int j=0; j<len; j++)
 57 |     {
 58 |         if (longest2[j] > mmax) 
 59 |         {
 60 |             mmax = longest2[j]; 
 61 |         } //从longest[j]中找出最大值
 62 |     }
 63 |     return mmax;
 64 | }
 65 | int main()
 66 | {
 67 |     int t, n;
 68 |     int arr[100010];
 69 |     scanf("%d", &t);
 70 |     while(t--)
 71 |     {
 72 |         scanf("%d", &n);
 73 |         for(int i = 0; i < n; i++)
 74 |         {
 75 |             scanf("%d", &arr[i]);
 76 |         }
 77 |         if(n - max(lis1(arr, n), lis2(arr, n)) <= 1)
 78 |         {
 79 |             printf("YES\n");
 80 |         }
 81 |         else
 82 |         {
 83 |             printf("NO\n");
 84 |         }
 85 |     }
 86 |     return 0;
 87 | }
 88 | 
 89 | 
 90 | 
 91 | //二分查找优化:
 92 | #include <stdio.h>
 93 | #include <stdlib.h>
 94 | #include <string.h>
 95 | #include <algorithm>
 96 | #define N 100010
 97 | #define INF 0x3f3f3f3f
 98 | using namespace std;
 99 | int len, a[N], aa[N], b[N];
100 | int BiSearch(int *b, int len, int w)
101 | {
102 |     int left = 0, right = len-1;
103 |     int mid;
104 |     while(left <= right)
105 |     {
106 |         mid = (right + left) / 2;
107 |         if(b[mid] > w)
108 |         {
109 |             right = mid - 1;
110 |         }
111 |         else
112 |         {
113 |             left = mid + 1;
114 |         }
115 |     }
116 |     return left;
117 | }
118 | int lis(int array[], int n)
119 | {
120 |     len = 1;
121 |     memset(b, INF, sizeof(b));
122 |     b[0] = array[0];
123 |     int i, pos = 0;
124 |     for(i = 1; i < n; i++)
125 |     {
126 |         if(array[i] >= b[len-1])
127 |         {
128 |             b[len] = array[i];
129 |             len++;
130 |         }
131 |         else
132 |         {
133 |             pos = BiSearch(b, len, array[i]);
134 |             b[pos] = array[i];
135 |         }
136 |     }
137 |     return len;
138 | }
139 | /*
140 | int main()
141 | {
142 |     int t, n;
143 |     scanf("%d", &t);
144 |     while(t--)
145 |     {
146 |         scanf("%d", &n);
147 |         for(int i = 0; i < n; i++)
148 |         {
149 |             scanf("%d", &a[i]);
150 |             aa[n - i - 1] = a[i];
151 |         }
152 |         if(n - max(lis(a, n), lis(aa, n)) <= 1)
153 |         {
154 |             printf("YES\n");
155 |         }
156 |         else
157 |         {
158 |             printf("NO\n");
159 |         }
160 |     }
161 |     return 0;
162 | }
163 | */
164 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Matrix_Fast_Power.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstring>
 3 | #include <iostream>
 4 | #include <algorithm>
 5 | using namespace std;
 6 | const int N = 10;
 7 | typedef long long lint;
 8 | int k , MOD;
 9 | int arr[N] , f[N];
10 | struct Matrix
11 | {
12 |     lint mat[N][N];
13 |     Matrix operator*(const Matrix &m)const
14 |     {
15 |         Matrix tmp;
16 |         for(int i = 0 ; i < N ; i++)
17 |         {
18 |             for(int j = 0 ; j < N ; j++)
19 |             {
20 |                 tmp.mat[i][j] = 0;
21 |                 for(int k = 0 ; k < N ; k++)
22 |                 {
23 |                     tmp.mat[i][j] += mat[i][k]*mat.m[k][j]%MOD;
24 |                     tmp.mat[i][j] %= MOD;
25 |                 }
26 |             } 
27 |         }
28 |         return tmp;
29 |     }
30 | };
31 | 
32 | lint Pow(Matrix &m , int k)
33 | {
34 |     Matrix ans;
35 |     memset(ans.mat , 0, sizeof(ans.mat));
36 |     for(int i = 0 ; i < N ; i++)
37 |         ans.mat[i][i] = 1;
38 |     k -= 9;
39 |     while(k)
40 |     {
41 |         if(k & 1)
42 |            ans = ans*m;
43 |         k >>= 1;
44 |         m = m*m;
45 |     } 
46 |     lint sum = 0;
47 |     for(int i = 0 ; i < N ; i++)
48 |     {
49 |         sum += ans.mat[0][i]*f[N-i-1]%MOD;
50 |         sum %= MOD;
51 |     }
52 |     return sum;
53 | }
54 | void init(Matrix &m)
55 | {
56 |     memset(mat.m , 0 , sizeof(mat.m));
57 |     for(int i = 0 ; i < N ; i++)
58 |     {
59 |         mat.m[0][i] = arr[i];
60 |         f[i] = i;
61 |         if(i != N-1)
62 |         {
63 |         	mat.m[i+1][i] = 1;
64 |         }
65 |     }   
66 | }
67 | int main()
68 | {
69 |     Matrix m;
70 |     while(scanf("%d%d" , &k , &MOD) != EOF)
71 |     {
72 |         for(int i = 0 ; i < N ; i++)
73 |         {
74 |             scanf("%d" , &arr[i]);
75 |         }
76 |         init(m);
77 |         if(k < 10)
78 |         {
79 |             printf("%d\n" , k%MOD);
80 |         }
81 |         else
82 |         {
83 |             printf("%lld\n" , Pow(m ,k));
84 |         }
85 |     }
86 |     return 0;
87 | }
88 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Minimum_Spanning_Tree/Kruskal.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <algorithm>
 3 | using namespace std;
 4 | typedef struct          
 5 | {        
 6 |     char vertex[VertexNum];                                //顶点表         
 7 |     int edges[VertexNum][VertexNum];                       //邻接矩阵,可看做边表         
 8 |     int n,e;                                               //图中当前的顶点数和边数         
 9 | }MGraph; 
10 |  
11 | typedef struct node  
12 | {  
13 |     int u;                                                 //边的起始顶点   
14 |     int v;                                                 //边的终止顶点   
15 |     int w;                                                 //边的权值   
16 | }Edge; 
17 | 
18 | void kruskal(MGraph G)  
19 | {  
20 |     int i,j,u1,v1,sn1,sn2,k;  
21 |     int vset[VertexNum];                                    //辅助数组，判定两个顶点是否连通   
22 |     Edge E[EdgeNum];                                         //存放所有的边   
23 |     k=0;                                                    //E数组的下标从0开始   
24 |     for (i=0;i<G.n;i++)  
25 |     {  
26 |         for (j=0;j<G.n;j++)  
27 |         {  
28 |             if (G.edges[i][j]!=0 && G.edges[i][j]!=INF)  
29 |             {  
30 |                 E[k].u=i;  
31 |                 E[k].v=j;  
32 |                 E[k].w=G.edges[i][j];  
33 |                 k++;  
34 |             }  
35 |         }  
36 |     }     
37 |     heapsort(E,k,sizeof(E[0]));                            //堆排序，按权值从小到大排列       
38 |     for (i=0;i<G.n;i++)                                    //初始化辅助数组   
39 |     {  
40 |         vset[i]=i;  
41 |     }  
42 |     k=1;                                                   //生成的边数，最后要刚好为总边数   
43 |     j=0;                                                   //E中的下标   
44 |     while (k<G.n)  
45 |     {   
46 |         sn1=vset[E[j].u];  
47 |         sn2=vset[E[j].v];                                  //得到两顶点属于的集合编号   
48 |         if (sn1!=sn2)                                      //不在同一集合编号内的话，把边加入最小生成树   
49 |         {
50 |             printf("%d ---> %d, %d",E[j].u,E[j].v,E[j].w);       
51 |             k++;  
52 |             for (i=0;i<G.n;i++)  
53 |             {  
54 |                 if (vset[i]==sn2)  
55 |                 {  
56 |                     vset[i]=sn1;  
57 |                 }  
58 |             }             
59 |         }  
60 |         j++;  
61 |     }  
62 | }
63 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Minimum_Spanning_Tree/Prim.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <string.h>
 3 | #include <stdlib.h>
 4 | #include <algorithm>
 5 | #define MAX 999
 6 | #define VNUM 5
 7 | using namespace std;
 8 | int edge[VNUM][VNUM];
 9 | int lowcost[VNUM] = {0};
10 | int addvnew[VNUM];
11 | int adjecent[VNUM] = {0};
12 | void Prim(int start)
13 | {
14 | 	int sumweight = 0;
15 | 	int i, j, k = 0;
16 | 	for(i = 1; i < VNUM; i++)
17 | 	{
18 | 		lowcost[i] = edge[start][i];
19 | 		addvnew[i] = -1;
20 | 	}
21 | 	addvnew[start] = 0;
22 | 	/*for(i = 1; i < VNUM; i++)//初始化adjecent数组
23 | 	{
24 | 		adjecent[i] = start;
25 | 	}*/
26 | 	fill(adjecent, adjecent+VNUM, start);
27 | 	for(i = 1; i < VNUM-1; i++)
28 | 	{
29 | 		int min = MAX;
30 | 		int v = -1;
31 | 		for(j = 1; j < VNUM; j++)
32 | 		{
33 | 			if(addvnew[j] == -1 && lowcost[j] < min)
34 | 			{
35 | 				min = lowcost[j];
36 | 				v = j;
37 | 			}
38 | 		}
39 | 		if(v != -1)
40 | 		{
41 | 			printf("%d %d %d\n", adjecent[v], v, lowcost[v]);
42 | 			addvnew[v] = 0;
43 | 			sumweight += lowcost[v];
44 | 			for(j = 1; j < VNUM; j++)
45 | 			{
46 | 				if(addvnew[j] == -1 && edge[v][j] < lowcost[j])
47 | 				{
48 | 					lowcost[j] = edge[v][j];
49 | 					adjecent[j] = v;
50 | 				}
51 | 			}
52 | 		}
53 | 	}
54 | 	printf("The minmum weight is %d\n", sumweight);
55 | }
56 | int main()
57 | {
58 | 	for(int i = 1; i < VNUM; i++)
59 | 	{
60 | 		for(int j = 1; j < VNUM; j++)
61 | 		{
62 | 			scanf("%d", &edge[i][j]);
63 | 		}
64 | 	}
65 | 	Prim(1);
66 | 	return 0;
67 | }
68 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/README.md:
--------------------------------------------------------------------------------
1 | # Algorithms (C/C++)


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Segment_Tree.cpp:
--------------------------------------------------------------------------------
  1 | #include <cstdio>
  2 | const int N = 100010;
  3 | int n, p, a, b, m, x, y, ans;
  4 | struct node
  5 | {
  6 | 	int l, r, w, f;
  7 | }tree[N<<2];
  8 | inline void Up(int k)
  9 | {
 10 | 	tree[k].w = tree[k<<1].w + tree[k<<1|1].w;
 11 | }
 12 | inline void Down(int k)
 13 | {
 14 | 	tree[k<<1].f += tree[k].f;
 15 | 	tree[k<<1|1].f += tree[k].f;
 16 | 	tree[k<<1].w += tree[k].f * (tree[k<<1].r-tree[k<<1].l+1);
 17 | 	tree[k<<1|1].w += tree[k].f * (tree[k<<1|1].r-tree[k<<1|1].l+1);
 18 | 	tree[k].f = 0;
 19 | }
 20 | void Build(int l, int r, int k)
 21 | {
 22 | 	tree[k].l = l;
 23 | 	tree[k].r = r;
 24 | 	if(tree[k].l == tree[k].r)
 25 | 	{
 26 | 		scanf("%d", &tree[k].w);
 27 | 		return;
 28 | 	}
 29 | 	int m = (l + r) >> 1;
 30 | 	Build(l, m, k<<1);
 31 | 	Build(m+1, r, k<<1|1);
 32 | 	Up(k);
 33 | }
 34 | void Query_point(int k)
 35 | {
 36 | 	if(tree[k].l == tree[k].r)
 37 | 	{
 38 | 		ans = tree[k].w;
 39 | 		return;
 40 | 	}
 41 | 	if(tree[k].f)
 42 | 	{
 43 | 		Down(k);
 44 | 	}
 45 | 	int m = (tree[k].l + tree[k].r) >> 1;
 46 | 	if(x <= m)
 47 | 	{
 48 | 		Query_point(k<<1);
 49 | 	}
 50 | 	else
 51 | 	{
 52 | 		Query_point(k<<1|1);
 53 | 	}
 54 | }
 55 | void Update_point(int k)
 56 | {
 57 | 	if(tree[k].l == tree[k].r)
 58 | 	{
 59 | 		tree[k].w += y;
 60 | 		return;
 61 | 	}
 62 | 	if(tree[k].f)
 63 | 	{
 64 | 		Down(k);
 65 | 	}
 66 | 	int m = (tree[k].l + tree[k].r) >> 1; 
 67 | 	if(x <= m)
 68 | 	{
 69 | 		Update_point(k<<1);
 70 | 	}
 71 | 	else
 72 | 	{
 73 | 		Update_point(k<<1|1);
 74 | 	}
 75 | 	Up(k);
 76 | }
 77 | void Query_Interval(int k)
 78 | {
 79 | 	if(a <= tree[k].l && b >= tree[k].r)//if(tree[k].l == tree[k].r)
 80 | 	{
 81 | 		ans += tree[k].w;
 82 | 		return;
 83 | 	}
 84 | 	if(tree[k].f)
 85 | 	{
 86 | 		Down(k);
 87 | 	}
 88 | 	int m = (tree[k].l + tree[k].r) >> 1;
 89 | 	if(a <= m)
 90 | 	{
 91 | 		Query_Interval(k<<1);
 92 | 	}
 93 | 	if(b > m)
 94 | 	{
 95 | 		Query_Interval(k<<1|1);
 96 | 	}
 97 | }
 98 | void Update_interval(int k)
 99 | {
100 | 	if(a <= tree[k].l && b >= tree[k].r)
101 | 	{
102 | 		tree[k].w += (tree[k].r-tree[k].l+1)*y;
103 | 		tree[k].f += y;
104 | 		return;
105 | 	}
106 | 	if(tree[k].f)
107 | 	{
108 | 		Down(k);
109 | 	}
110 | 	int m = (tree[k].l + tree[k].r) >> 1;
111 | 	if(a <= m)
112 | 	{
113 | 		Update_interval(k<<1);
114 | 	}
115 | 	if(b > m)
116 | 	{
117 | 		Update_interval(k<<1|1);
118 | 	}
119 | 	Up(k);
120 | }
121 | int main()
122 | {
123 | 	scanf("%d", &n);//n nodes
124 | 	Build(1, n, 1);
125 | 	scanf("%d", &m);//m operations
126 | 	for(int i = 1; i <= m; i++)
127 | 	{
128 | 		scanf("%d", &p);
129 | 		ans = 0;
130 | 		if(p == 1)
131 | 		{
132 | 			scanf("%d", &x);
133 | 			Query_point(1);//output the xth number
134 | 			printf("%d\n", ans);
135 | 		}
136 | 		else if(p == 2)
137 | 		{
138 | 			scanf("%d%d", &x, &y);
139 | 			Update_point(1);
140 | 		}
141 | 		else if(p == 3)
142 | 		{
143 | 			scanf("%d%d", &a, &b);
144 | 			Query_Interval(1);
145 | 			printf("%d\n", ans);
146 | 		}
147 | 		else
148 | 		{
149 | 			scanf("%d%d%d", &a, &b, &y);
150 | 			Update_interval(1);
151 | 		}
152 | 	}
153 | 	return 0;
154 | }
155 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Shortest_Path/Dijkstra.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstring>
 3 | #include <algorithm>
 4 | #define M 0x3f3f3f3f
 5 | #define N 1010
 6 | using namespace std;
 7 | int map[N][N];//城市之间的邻接矩阵表示法
 8 | int dist[N];//  起点到各个点的最短路径
 9 | int pre[N];//存储最短路径
10 | bool vis[N];//标记是否访问过
11 | int t, s, d;
12 | int a, b, tim;
13 | int nn, minn;
14 | void Dijkstra(int v0)//计算单源最短路径, v0为起点
15 | {
16 |     for(int i = 1; i <= nn; i++)//初始化
17 |     {
18 |         dist[i] = map[v0][i];
19 |         vis[i] = false;//所有城市都未访问过
20 |         if(dist[i] == M)
21 |         {
22 |             pre[i] = -1;//与起点之间没有路径，设它的前一座城市为-1, 否则就是起点
23 |         }
24 |         else
25 |         {
26 |             pre[i] = v0;
27 |         }
28 |     }
29 |     dist[v0] = 0;//起点到自身的距离为0
30 |     vis[v0] = true;//标记为访问过
31 |     for(int i = 2; i <= nn; i++)
32 |     {
33 |         minn = M;
34 |         int pos = v0;
35 |         for(int j = 1; j <= nn; j++)//寻找已存在路径中的最短路径
36 |         {
37 |             if(!vis[j] && dist[j] < minn)
38 |             {
39 |                 minn = dist[j];
40 |                 pos = j;
41 |             }
42 |         }
43 |         vis[pos] = true;//加入到访问过的集合中去
44 |         for(int j = 1;j <= nn; j++)//松弛---经过pos这座城市且以之为中心点的最短路径
45 |         {
46 |             if(!vis[j] && map[pos][j] < M)
47 |             {
48 |                 if(dist[pos] + map[pos][j] < dist[j])
49 |                 {
50 |                     dist[j] = dist[pos] + map[pos][j];
51 |                     pre[j] = pos;
52 |                 }
53 |             }
54 |         }
55 |     }
56 | }
57 | /*
58 | int main()
59 | {
60 |     while(~scanf("%d%d%d", &t, &s, &d))
61 |     {
62 |         nn = 0;
63 |         memset(map, M, sizeof(map));
64 |         for(int i = 0; i < t; i++)
65 |         {
66 |             scanf("%d%d%d", &a, &b, &tim);
67 |             nn = max(nn, max(a, b));
68 |             map[a][b] = map[b][a] = min(tim, map[a][b]);
69 |         }
70 |         for(int i = 0; i < s; i++)
71 |         {
72 |             scanf("%d", &a);
73 |             map[0][a] = 0;
74 |         }
75 |         int m = M;
76 |         Dijkstra(0);
77 |         for(int i = 0; i < d; i++)
78 |         {
79 |             scanf("%d", &a);
80 |             m = min(m, dist[a]);
81 |         }
82 |         printf("%d\n", m);
83 |     }
84 |     return 0;
85 | }
86 | */
87 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Shortest_Path/Floyd.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #define VertexNum 10
 3 | typedef struct
 4 | {
 5 |     int vertex[VertexNum];
 6 |     int edge[VertexNum][VertexNum];
 7 |     int cntv, cnte;
 8 | }Graph;
 9 | int path[VertexNum][VertexNum];
10 | void Floyd(Graph g, int n)
11 | {
12 |     for(int k = 0; k < n; k++)
13 |     {
14 |         for(int i = 0; i < n; i++)
15 |         {
16 |             for(int j = 0;j < n; j++)
17 |             {
18 |                 if(g.edge[i][j] > g.edge[i][k] + g.edge[k][j])
19 |                 {
20 |                     g.edge[i][j] = g.edge[i][k] + g.edge[k][j];
21 |                     path[i][j] = k;
22 |                 }
23 |             }
24 |         }
25 |     }
26 | }
27 | /*
28 | int main()
29 | {
30 |     Graph g;
31 |     scanf("%d%d", &g.cntv, &g.cnte);
32 |     int n = g.cntv;
33 |     for(int i = 0; i < n; i++)
34 |     {
35 |         scanf("%d", &g.vertex[i]);
36 |     }
37 |     for(int i = 0; i < n; i++)
38 |     {
39 |         for(int j = 0; j < n; j++)
40 |         {
41 |             scanf("%d", &g.edge[i][j]);
42 |         }
43 |     }
44 |     Floyd(g, g.cntv);
45 |     for(int i = 0; i < n; i++)
46 |     {
47 |         for(int j = 0; j < n; j++)
48 |         {
49 |             printf("%d ", g.edge[i][j]);
50 |         }
51 |         printf("\n");
52 |     }
53 |     return 0;
54 | }
55 | */
56 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Sort_Approaches/Bubble_Sort.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #define N 7
 3 | void Bubble_Sort(int *a, int n)//冒泡排序-----时间复杂度:O(n^2)   空间复杂度:O(1)    稳定
 4 | {
 5 |     for(int i = 0; i < n; i++)
 6 |     {
 7 |         for(int j = i+1; j < n; j++)
 8 |         {
 9 |             if(a[i] > a[j])
10 |             {
11 |                 int temp = a[i] ;
12 |                 a[i] = a[j] ;
13 |                 a[j] = temp ;
14 |             }
15 |         }
16 |     }
17 | }
18 | void Print_Arr(int *a, int n)
19 | {
20 |     for(int i = 0; i<N; i++)
21 |     {
22 |         if(i)
23 |             printf(" ") ;
24 |         printf("%d", a[i]) ;
25 |         if(i == n-1)
26 |             printf("\n") ;
27 |     }
28 | }
29 | int main()
30 | {
31 |     int a[N] = {1,7,5,4,2,3,6} ;
32 |     printf("Before sorting:\n") ;
33 |     Print_Arr(a, N);
34 |     Bubble_Sort(a, N);
35 |     printf("After sorting:\n") ;
36 |     Print_Arr(a, N);
37 |     return 0 ;
38 | }
39 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Sort_Approaches/Insert_Sort.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #define N 7
 3 | void Insert_Sort(int a[])//直接插入排序--------时间复杂度:O(n^2)    空间复杂度:O(1)    稳定
 4 | {
 5 |     for(int i = 1; i<N; i++)
 6 |     {
 7 |         if(a[i] < a[i-1])
 8 |         {
 9 |             int j, temp = a[i] ;
10 |             for(j = i-1; a[j] > temp; j--)
11 |             {
12 |                 a[j+1] = a[j] ;
13 |             }
14 |             a[j+1] = temp ;
15 |         }
16 |     }
17 | }
18 | void Print_Arr(int *a, int n)
19 | {
20 |     for(int i = 0; i<N; i++)
21 |     {
22 |         if(i)
23 |             printf(" ") ;
24 |         printf("%d", a[i]) ;
25 |         if(i == n-1)
26 |             printf("\n") ;
27 |     }
28 | }
29 | int main()
30 | {
31 |     int a[N] = {1,2,7,5,3,4,6} ;
32 |     printf("Before sorting:\n") ;
33 |     Print_Arr(a, N);
34 |     Insert_Sort(a) ;
35 |     printf("After sorting:\n") ;
36 |     Print_Arr(a, N);
37 |     return 0;
38 | }
39 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Sort_Approaches/Merge_Sort.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | #define N 7
 4 | void Merge(int a[], int low, int mid, int high)//合并
 5 | {
 6 |     int left_low = low ;
 7 |     int left_high = mid ;
 8 |     int right_low = mid+1 ;
 9 |     int right_high = high ;
10 |     int *temp = (int *)malloc((high-low+1)*sizeof(int)) ;
11 |     int k = 0 ;
12 |     for(;left_low <= left_high && right_low <= right_high;)
13 |     {
14 |         if(a[left_low] < a[right_low])
15 |         {
16 |             temp[k++] = a[left_low++] ;
17 |         }
18 |         else
19 |         {
20 |             temp[k++] = a[right_low++] ;
21 |         }
22 |     }
23 |     while(left_low <= left_high)
24 |     {
25 |         temp[k++] = a[left_low++] ;
26 |     }
27 |     while(right_low <= right_high)
28 |     {
29 |         temp[k++] = a[right_low++] ;
30 |     }
31 |     for(int i = 0; i<high-low+1; i++)
32 |     {
33 |         a[low+i] = temp[i] ;
34 |     }
35 |     free(temp) ;
36 | }
37 | void Merge_Sort(int a[], int start, int end)//归并排序-------时间复杂度:O(n*logn)   空间复杂度:O(n)    稳定
38 | {
39 |     if(start < end)
40 |     {
41 |         int mid = (start+end)/2 ;
42 |         Merge_Sort(a, start, mid) ;
43 |         Merge_Sort(a, mid+1, end) ;
44 |         Merge(a, start, mid, end) ;
45 |     }
46 | }
47 | void Print_Arr(int *a, int n)
48 | {
49 |     for(int i = 0; i < n; i++)
50 |     {
51 |         if(i)
52 |             printf(" ") ;
53 |         printf("%d", a[i]) ;
54 |         if(i == n-1)
55 |             printf("\n") ;
56 |     }
57 | }
58 | int main()
59 | {
60 |     int a[N] = {1,4,3,2,5,7,6} ;
61 |     printf("Before sorting:\n") ;
62 |     Print_Arr(a, N);
63 |     Merge_Sort(a, 0, N-1) ;
64 |     printf("After sorting:\n") ;
65 |     Print_Arr(a, N);
66 |     return 0;
67 | }
68 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Sort_Approaches/Quick_Sort.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #define N 7
 3 | void Quick_Sort(int s[], int l, int r)//快速排序--------时间复杂度:O(n*logn)   空间复杂度:O(logn)   不稳定
 4 | {
 5 |     if(l < r)
 6 |     {
 7 |         int i = l, j = r, x = s[l];
 8 |         while(i < j)
 9 |         {
10 |             while(i < j && s[j] >= x)
11 |             {
12 |                 j--;
13 |             }
14 |             if(i < j)
15 |             {
16 |                 s[i++] = s[j];
17 |             }
18 |             while(i < j && s[i] < x)
19 |             {
20 |                 i++;
21 |             }
22 |             if(i < j)
23 |             {
24 |                 s[j--] = s[i];
25 |             }
26 |         }
27 |         s[i] = x;
28 |         Quick_Sort(s, l, i-1);
29 |         Quick_Sort(s, i+1, r);
30 |     }
31 | }
32 | void Print_Arr(int *a, int n)
33 | {
34 |     for(int i = 0; i < n; i++)
35 |     {
36 |         if(i)
37 |             printf(" ") ;
38 |         printf("%d", a[i]) ;
39 |         if(i == n-1)
40 |             printf("\n") ;
41 |     }
42 | }
43 | int main()
44 | {
45 |     int s[N] = {1,7,5,2,4,3,6};
46 |     printf("Before sorting:\n") ;
47 |     Print_Arr(s, N);
48 |     Quick_Sort(s, 0, N-1);
49 |     printf("After sorting:\n") ;
50 |     Print_Arr(s, N);
51 |     return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Sort_Approaches/README.md:
--------------------------------------------------------------------------------
1 | # Sort-approaches
2 | 
3 | 排序算法
4 | 
5 | 参考:</br>
6 | http://blog.csdn.net/MoreWindows/article/category/859207</br>
7 | http://ccc013.github.io/2016/11/20/排序算法总结/?ref=myread
8 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Sort_Approaches/Shell_Sort.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #define N 7
 3 | void Shell_Sort1(int a[], int n)//希尔排序--------时间复杂度:O(n*logn)~O(n*n)   空间复杂度:O(1)   不稳定
 4 | {
 5 |     int i, j, gap;
 6 |     for(gap = n /2; gap > 0; gap /= 2)//增量
 7 |     {
 8 |         for(i = 0; i < gap; i++)//直接插入排序
 9 |         {
10 |             for(j = i + gap; j < n; j += gap)
11 |             {
12 |                 if(a[j] < a[j - gap])
13 |                 {
14 |                     int temp = a[j];
15 |                     int k = j - gap;
16 |                     while(k >= 0 && a[k] > temp)
17 |                     {
18 |                         a[k + gap] = a[k];
19 |                         k -= gap;
20 |                     }
21 |                     a[k + gap] = temp;
22 |                 }
23 |             }
24 |         }
25 |     }
26 | }
27 | void Shell_Sort2(int a[], int n)
28 | {
29 |     int i, gap;
30 |     for(gap = n /2; gap > 0; gap /= 2)
31 |     {
32 |         for(i = gap; i < n; i++)
33 |         {
34 |             if(a[i] < a[i - gap])//每个元素与自己组内的数据进行直接插入排序
35 |             {
36 |                 int temp = a[i];
37 |                 int k = i - gap;
38 |                 while(k >= 0 && a[k] > temp)
39 |                 {
40 |                     a[k + gap] = a[k];
41 |                     k -= gap;
42 |                 }
43 |                 a[k + gap] = temp;
44 |             }
45 |         }
46 |     }
47 | }
48 | void Shell_Sort3(int a[], int n)
49 | {
50 |     int i, j, gap;
51 |     for(gap = n / 2; gap > 0; gap /= 2)
52 |     {
53 |         for(i = gap; i < n; i++)
54 |         {
55 |             for(j = i - gap; j >= 0 && a[j] > a[j + gap]; j -= gap)
56 |             {
57 |                 int temp = a[j];
58 |                 a[j] = a[j + gap];
59 |                 a[j + gap] = temp;
60 |             }
61 |         }
62 |     }
63 | }
64 | void Print_Arr(int a[], int n)
65 | {
66 |     for(int i = 0; i < n; i++)
67 |     {
68 |         if(i)
69 |         {
70 |             printf(" ");
71 |         }
72 |         printf("%d", a[i]);
73 |         if(i == n-1)
74 |         {
75 |             printf("\n");
76 |         }
77 |     }
78 | }
79 | int main()
80 | {
81 |     int a[N] = {1, 7, 5, 3, 4, 6, 2};
82 |     printf("Before sorting:\n") ;
83 |     Print_Arr(a, N);
84 |     Shell_Sort1(a, N);
85 |     //Shell_Sort2(a, N);
86 |     //Shell_Sort3(a, N);
87 |     printf("After sorting:\n") ;
88 |     Print_Arr(a, N);
89 |     return 0;
90 | }
91 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Sort_Approaches/Simple_Selection_Sort.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #define N 7
 3 | void Swap(int a[], int p1, int p2)//交换数据
 4 | {
 5 |     int temp = a[p1] ;
 6 |     a[p1] = a[p2] ;
 7 |     a[p2] = temp ;
 8 | }
 9 | void Simple_Selection_Sort(int *a, int n)//简单选择排序-------时间复杂度:O(n^2)   空间复杂度:O(1)    稳定
10 | {
11 |     for(int i = 0; i < n; i++)
12 |     {
13 |         int min = i ;
14 |         for(int j = i+1; j < n; j++)
15 |         {
16 |             if(a[min] > a[j])
17 |                 min = j ;
18 |         }
19 |         if(min-i)
20 |             Swap(a, i, min) ;
21 |     }
22 | }
23 | void Print_Arr(int *a, int n)
24 | {
25 |     for(int i = 0; i<N; i++)
26 |     {
27 |         if(i)
28 |             printf(" ") ;
29 |         printf("%d", a[i]) ;
30 |         if(i == n-1)
31 |             printf("\n") ;
32 |     }
33 | }
34 | int main()
35 | {
36 |     int a[N] = {1,7,3,5,6,2,4} ;
37 |     printf("Before sorting:\n") ;
38 |     Print_Arr(a, N);
39 |     Simple_Selection_Sort(a, N);
40 |     printf("After sorting:\n") ;
41 |     Print_Arr(a, N);
42 |     return 0 ;
43 | }
44 | 


--------------------------------------------------------------------------------
/数据结构与算法/C++实现/Union-Find.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <string.h>
 3 | #include <stdlib.h>
 4 | #define N 5010
 5 | int p[N] ;
 6 | int rank[N];
 7 | void InitSet(int p[])
 8 | {
 9 |     for(int i = 0; i<N; i++)
10 |     {
11 |         p[i] = i ;
12 |     }
13 |     memset(rank, 0, sizeof(rank));
14 | }
15 | int Find(int x)             //查(+路径压缩)
16 | {
17 |     if(x != p[x])
18 |         p[x] = Find(p[x]) ;
19 |     return p[x] ;
20 | }
21 | void Union(int x, int y)     //并
22 | {
23 |     int t1 = Find(x) ;
24 |     int t2 = Find(y) ;
25 |     if(t1 > t2)
26 |     {
27 |         p[t1] = t2 ;
28 |         rank[t2]++;
29 |     }
30 |     else if(t1 < t2)
31 |     {
32 |         p[t2] = t1 ;
33 |         rank[t1]++;
34 |     }
35 |     else
36 |         return ;
37 | }
38 | int main()
39 | {
40 |     int n, m, x, y;
41 |     bool flag;
42 |     int gro = 0;
43 |     while(~scanf("%d %d", &n, &m))
44 |     {
45 |         InitSet(p);
46 |         while(m--)
47 |         {
48 |             scanf("%d%d", &x, &y);
49 |             Union(x, y);
50 |         }
51 |         gro = 0;
52 |         flag = true;
53 |         for(int i = 1; i <= n; i++)
54 |         {
55 |             if(rank[i] != 0)
56 |             {
57 |                 gro++;
58 |                 if((rank[i]+1)%3)
59 |                 {
60 |                     flag = false;
61 |                 }
62 |             }
63 |         }
64 |         if(n >= 3 && n % 3 == 0 && gro >= 1 && gro <= n/3 && flag)
65 |         {
66 |             printf("Yes\n");
67 |         }
68 |         else
69 |         {
70 |             printf("No\n");
71 |         }
72 |     }
73 |     return 0 ;
74 | }
75 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/Java/BalancedBinaryTree.java:
--------------------------------------------------------------------------------
 1 | // 输入一棵二叉树，判断该二叉树是否是平衡二叉树。
 2 | // 平衡二叉树是空树，或者左右两个子树的高度差不超过1的树
 3 | public class Solution {
 4 |     
 5 |     public int maxBranchNumber (TreeNode node, int depth) {
 6 |         if (node == null) return depth;
 7 |         return Math.max(maxBranchNumber(node.right, depth + 1), maxBranchNumber(node.left, depth + 1));
 8 |     }
 9 |     // 二叉树是很经典的可以用递归分析的数据结构
10 |     // 每个结点下可以看做一个新的二叉树，判断其左右的最深深度是否相差大于1，若是，则不满足平衡的条件
11 |     public boolean IsBalanced_Solution(TreeNode root) {
12 |         
13 |         if(root == null) return true;
14 |         
15 |         int right = maxBranchNumber(root.right, 1);
16 |         int left = maxBranchNumber(root.left, 1);
17 |         if (right > left + 1 || left > right + 1) return false;
18 |         return IsBalanced_Solution(root.right) && IsBalanced_Solution(root.left);
19 |     }
20 | }


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/Java/CommonNode.java:
--------------------------------------------------------------------------------
 1 | import java.util.ArrayList;
 2 | public class Solution {
 3 |     public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
 4 |         if (pHead1 == null || pHead2 == null) return null;
 5 |         ArrayList<ListNode> list = new ArrayList<ListNode>();
 6 |         while(pHead1 != null) {
 7 |             list.add(pHead1);
 8 |             pHead1 = pHead1.next;
 9 |         }
10 |         while(pHead2 != null) {
11 |             if (list.contains(pHead2)) return pHead2;
12 |             pHead2 = pHead2.next;
13 |         }
14 |         return null;
15 |     }
16 | }
17 | 
18 | // 方法2
19 | // 计算出两链表的长度差，即为交汇前的长度差，让多出的链表先走多出的长度，在一起向下遍历即可找到公共结点
20 | class Solution {
21 |     public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
22 |         if (pHead1 == null || pHead2 == null) return null;
23 |         int len1 = 0, len2 = 0;
24 |         ListNode head1 = pHead1, head2 = pHead2;
25 |         while (head1 != null) {
26 |             len1++;
27 |             head1 = head1.next;
28 |         }
29 |         while (head2 != null) {
30 |             len2++;
31 |             head2 = head2.next;
32 |         }
33 |         
34 |         if (len1 >= len2) {
35 |             for(int i = 0; i < len1-len2; i++) pHead1 = pHead1.next;
36 |         } else {
37 |             for(int i = 0; i < len2-len1; i++) pHead2 = pHead2.next;
38 |         }
39 |         
40 |         while (pHead1 != null && pHead2 != null) {
41 |             if (pHead1 == pHead2) return pHead1;
42 |             pHead1 = pHead1.next; pHead2 = pHead2.next;
43 |         }
44 |         return null;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/Java/DeleteDuplication.java:
--------------------------------------------------------------------------------
 1 | /**
 2 | 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 
 3 | 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
 4 |  */
 5 | /*
 6 |  public class ListNode {
 7 |     int val;
 8 |     ListNode next = null;
 9 | 
10 |     ListNode(int val) {
11 |         this.val = val;
12 |     }
13 | }
14 | */
15 | public class DeleteDuplication {
16 |     public ListNode deleteDuplication(ListNode pHead)
17 |     {
18 |         if (pHead == null) return null;
19 |         // 模拟一个已经确定的链表开头
20 |         ListNode result = new ListNode(pHead.val);
21 |         // 下一个从pHead开始
22 |         result.next = pHead;
23 |         // lastHead指向一个确定唯一的链表结点。
24 |         ListNode lastHead = result;
25 |         
26 |         while (pHead != null && pHead.next != null) {
27 |             // 如果从此结点，开始后面有连续的相等结点，则找到下一个不连续的结点开始试探。
28 |             if (pHead.val == pHead.next.val) {
29 |                 int val = pHead.val;
30 |                 ListNode tmp = pHead.next;
31 |                 while(tmp != null) {
32 |                     if (tmp.val != val) break;
33 |                     tmp = tmp.next;
34 |                 }
35 |                 pHead = tmp;
36 |                 lastHead.next = tmp;
37 |             } else {
38 |                 // 如果不确定结点是独立的，则列为确定结点
39 |                 // 注意区分，当前结点和历史结点 
40 |                 lastHead = pHead;
41 |                 pHead = pHead.next;
42 |             }
43 |         }
44 |         return result.next;
45 |     }
46 | }


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/Java/FindContinueSequence.java:
--------------------------------------------------------------------------------
 1 | // 小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,
 2 | // 他马上就写出了正确答案是100。但是他并不满足于此,
 3 | // 他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。
 4 | // 没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。
 5 | // 现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
 6 | 
 7 | /**
 8 |  * 解题思路：连续字段的中部肯定是总数与某个数的商，同时还分这个除数的奇偶，以及左右序列的间距问题
 9 |  * 因此分为两种情况判断，通知注意Java除法向下取整的问题即可。
10 |  */
11 | import java.util.ArrayList;
12 | public class Solution {
13 |     public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
14 |         ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>(); 
15 |         int num = 2;
16 |         while( 2*sum - num*num >= 0 ) {
17 |             if( num % 2 == 0 ) {
18 |                 if (sum%num == num/2) {
19 |                     ArrayList<Integer> temp = new ArrayList<Integer>();
20 |                     for (int i = (sum/num) - num/2 + 1; i <= (sum/num) + num/2; i++) {
21 |                         temp.add(i);
22 |                     }
23 |                     result.add(0, temp);
24 |                 }
25 |             } else {
26 |                 if (sum%num == 0) {
27 |                     ArrayList<Integer> temp = new ArrayList<Integer>();
28 |                     for (int i = (sum/num) - num/2; i <= (sum/num) + num/2; i++) {
29 |                         temp.add(i);
30 |                     }
31 |                     result.add(0, temp);
32 |                 }
33 |             }
34 |             num ++;
35 |         }
36 |         return result;
37 |     }
38 | }


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/Java/FindInTwoDimensionalArray01.java:
--------------------------------------------------------------------------------
 1 | public class FindInTwoDimensionalArray01 {
 2 |     public boolean Find(int target, int [][] array) {
 3 |         int rowLength = array.length;
 4 |         if (rowLength == 0) return false;
 5 |         int columnLength = array[0].length;
 6 |         
 7 |         // 从二维数组的左下角开始找起
 8 |         // 原则是比当前点大往右找，比当前点小往上找
 9 |         int curRow = rowLength - 1;
10 |         int curColumn = 0;
11 |         
12 |         while(curColumn < columnLength && curRow >= 0) {
13 |             int val = array[curRow][curColumn];
14 |             if (target == val) return true;
15 |             else if (target < val) {
16 |                 curRow --;
17 |             }
18 |             else curColumn ++;
19 |         }
20 |         return false;
21 |     }
22 | 
23 |     public static void main(String[] args) {
24 |         int[][] array = {{1,2,3,4,5}, {3,4,5,6,7}, {4,5,6,7,8}, {5,7,8,10,13}};
25 |         int target1 = 7;
26 |         int target2 = 20;
27 |         FindInTwoDimensionalArray01 f = new FindInTwoDimensionalArray01();
28 |         System.out.println(f.Find(target1, array)); // true
29 |         System.out.println(f.Find(target2, array)); // false
30 |     }
31 | }


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/Java/FindSingleCharacter.java:
--------------------------------------------------------------------------------
 1 | import java.util.HashMap;
 2 | 
 3 | public class Solution {
 4 |     public int FirstNotRepeatingChar(String str) {
 5 |         StringBuffer strbuf = new StringBuffer(str);
 6 |         HashMap<Character, Integer> map = new HashMap<Character, Integer>();
 7 |         // 通过map记录每个字符出现的次数
 8 |         for (int i = 0; i < strbuf.length(); i++) {
 9 |             char c = strbuf.charAt(i);
10 |             if (!map.containsKey(c)) {
11 |                 map.put(c, 1);
12 |             } else {
13 |                 map.put(c, map.get(c) + 1);
14 |             }
15 |         }
16 |         // 因为java map会排序，需要手动遍历找到最小的字符位置
17 |         // indexOf 是返回第一个字符出现的位置
18 |         int min = str.length() - 1;
19 |         for (char c:map.keySet()){
20 |             if (map.get(c) == 1) min = str.indexOf(c) < min ? str.indexOf(c) : min;
21 |         }
22 |         return min;
23 |     }
24 | }


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/Java/MergeSortReversePair.java:
--------------------------------------------------------------------------------
 1 | /**
 2 | 在数组中的两个数字，如果前面一个数字大于后面的数字，
 3 | 则这两个数字组成一个逆序对。
 4 | 输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 
 5 | 即输出P%1000000007
 6 |  */
 7 | public class Solution {
 8 | 
 9 |     public int count = 0;
10 | 
11 |     public void merge(int[] array, int start, int end) { // ≥start <end
12 |         if(start >= end-1 ) return;
13 |         int mid = (start + end) >> 1;
14 | 
15 |         merge(array, start, mid);
16 |         merge(array, mid, end);
17 | 
18 |         int left = mid - 1, right = end - 1;
19 |         int[] copyArray = new int[end-start];
20 |         int pos = end - start - 1;
21 |         while (left >= start && right >= mid) {
22 |             if (array[left] > array[right]) {
23 |                 copyArray[pos--] = array[left--];
24 |                 // Core: 每当前面的数大于后面，就记录为一个逆数对
25 |                 count += right - mid + 1;
26 |             } else {
27 |                 copyArray[pos--] = array[right--];
28 |             }
29 |         }
30 |         if (right < mid) {
31 |             while(pos >= 0) copyArray[pos--] = array[left--];
32 |         } else if (left < start) {
33 |             while(pos >= 0) copyArray[pos--] = array[right--];
34 |         }
35 |         for (int i = 0; i < end-start; i++) array[start+i] = copyArray[i];
36 |     }
37 | 
38 |     public int InversePairs(int [] array) {
39 |         // 通过归并排序，几次置换位置，就有几个逆数对
40 |         if (array.length == 0) return count;
41 |         merge(array, 0, array.length);
42 |         return count;
43 |     }
44 | 
45 |     public static void main(String[] args) {
46 |         int[] array = {364,637,341,406,747,995,234,971,571,219,993,407,416,366,315,301,601,650,418,355,460,505,360,965,516,648,727,667,465,849,455,181,486,149,588,233,144,174,557,67,746,550,474,162,268,142,463,221,882,576,604,739,288,569,256,936,275,401,497,82,935,983,583,523,697,478,147,795,380,973,958,115,773,870,259,655,446,863,735,784,3,671,433,630,425,930,64,266,235,187,284,665,874,80,45,848,38,811,267,575};
47 |         Solution solution = new Solution();
48 | 
49 |         if (array.length == 0) System.out.println(solution.count);
50 |         solution.merge(array, 0, array.length);
51 | //        System.out.println(array);
52 | //        for (int i=0; i < array.length ;i++ ) {
53 | //            System.out.println(array[i]);
54 | //        }
55 |         System.out.println(solution.count);
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/Java/PokerStraight.java:
--------------------------------------------------------------------------------
 1 | public class Solution {
 2 |     public boolean isContinuous(int [] numbers) {
 3 |         // 5张牌，一定有一张是有花色
 4 |         int len = numbers.length;
 5 |         if (len < 5) return false;
 6 |         
 7 |         // 模仿一般的思路，先排序，然后将0插空看看
 8 |         for (int i = 0; i < len - 1; i++) {
 9 |             for (int j = i+1; j < len; j++){
10 |                 if (numbers[j] < numbers[i]) {
11 |                     int tmp = numbers[i];
12 |                     numbers[i] = numbers[j];
13 |                     numbers[j] = tmp;
14 |                 }
15 |             }
16 |         }
17 |         // 统计0的个数
18 |         int count = 0;
19 |         for (int i = 0; i < len; i++) if (numbers[i] == 0) count++;
20 |         
21 |         // 判断从非0数开始，中间需不需要插入0以完成顺子，若需要则消耗0，最后0的数目不应该小于0
22 |         for (int i = count + 1; i < len; i++) {
23 |             if (numbers[i] - numbers[i-1] > 1) {
24 |                 count -= numbers[i] - numbers[i-1] - 1;
25 |             } else if (numbers[i] - numbers[i-1] == 0) {
26 |                 return false;
27 |             }
28 |         }
29 |         return count >= 0 ? true : false;
30 |     }
31 | }


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/Java/RegexSolution.java:
--------------------------------------------------------------------------------
 1 | /**
 2 | 请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次）。
 3 |  在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配
 4 |  */
 5 | public class Solution {
 6 |     public boolean match(char[] str, char[] pattern)
 7 |     {
 8 |         if (str == null || pattern == null ) return true;
 9 | 
10 |         int strIndex = 0;
11 |         int patternIndex = 0;
12 |         
13 |         return matchHelper(str, strIndex, pattern, patternIndex);
14 |   }
15 |     
16 |    public boolean matchHelper(char[] str, int strIndex, char[] pattern, int patternIndex)
17 |    {
18 |       // 如果字符串和模式都匹配到头，则返回匹配成功
19 |        if (strIndex >= str.length && patternIndex >= pattern.length) return true;
20 |        // 如果模式先于字符串匹配完，则返回false
21 |        if (strIndex < str.length && patternIndex >= pattern.length) return false;
22 |        
23 |        // 如果第二个字符为'*'，则进行前一个字符的比较
24 |        // 1. 字符相等，（完全相等，或模式='.'） 则有三种选择：模式跳过此对+2，字符串向后走1，字符串和模式向后同时走位
25 |        // 2. 字符串不相等，则模式跳过此对
26 |        if (patternIndex + 1 < pattern.length && pattern[patternIndex + 1] == '*') {
27 |            if ( (strIndex != str.length && str[strIndex] == pattern[patternIndex]) 
28 |                || (strIndex != str.length && pattern[patternIndex] == '.')) {
29 |                return matchHelper(str, strIndex, pattern, patternIndex + 2) 
30 |                    || matchHelper(str, strIndex + 1, pattern, patternIndex) 
31 |                    || matchHelper(str, strIndex + 1, pattern, patternIndex + 2);
32 |            } else {
33 |                return matchHelper(str, strIndex, pattern, patternIndex + 2);
34 |            }
35 |        }
36 |        // 如果模式和字符串相等（完全相等，或模式='.'），则模式和字符串向后跳1
37 |        else if ( (strIndex != str.length && str[strIndex] == pattern[patternIndex]) 
38 |                || (strIndex != str.length && pattern[patternIndex] == '.')) {
39 |            return matchHelper(str, strIndex + 1, pattern, patternIndex + 1);
40 |        }
41 |        return false;
42 |    }
43 | }


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/Java/ReplaceSpaceOnString02.java:
--------------------------------------------------------------------------------
 1 | public class Solution {
 2 |     public String replaceSpace(StringBuffer str) {
 3 |        // 通过String/StringBuilder/StringBuffer中的replace(start, end, str)进行替换
 4 |        for (int i = 0; i < str.length(); i++) {
 5 |            if (str.charAt(i) == ' ' ) {
 6 |                str.replace(i, i+1, "%20");
 7 |            }
 8 |        }
 9 |        return str.toString();
10 |     }
11 | }


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/Java/ReverseTheList03.java:
--------------------------------------------------------------------------------
 1 | /**
 2 | *    public class ListNode {
 3 | *        int val;
 4 | *        ListNode next = null;
 5 | *
 6 | *        ListNode(int val) {
 7 | *            this.val = val;
 8 | *        }
 9 | *    }
10 | *
11 | */
12 | import java.util.ArrayList;
13 | public class ReverseTheList03 {
14 |     public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
15 |         ArrayList<Integer> result = new ArrayList<Integer>();
16 |         // 在最前面插入即可
17 |         while(listNode != null) {
18 |             result.add(0, listNode.val);
19 |             listNode = listNode.next;
20 |         }
21 |         return result;
22 |     }
23 | }


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/Java/UglyNumber.java:
--------------------------------------------------------------------------------
 1 | import java.util.ArrayList;
 2 | 
 3 | public class Solution {
 4 |     public int GetUglyNumber_Solution(int index) {
 5 |         
 6 |         if (index <= 0) return 0;
 7 |         if (index < 7) return index;
 8 |         
 9 |         ArrayList<Integer> uglyList = new ArrayList<Integer>();
10 |         uglyList.add(1);
11 |         
12 |         int i2 = 0, i3 = 0, i5 = 0;
13 |         
14 |         // 丑数一定由另一个丑数x2或x3或x5得到
15 |         while(uglyList.size() <= index) {
16 |             int m2 = 2*uglyList.get(i2);
17 |             int m3 = 3*uglyList.get(i3);
18 |             int m5 = 5*uglyList.get(i5);
19 |             int m = Math.min(m2, Math.min(m3,m5));
20 |             if (m == m2) i2++;
21 |             if (m == m3) i3++;
22 |             if (m == m5) i5++;
23 |             uglyList.add(m);
24 |         }
25 |         
26 |         return uglyList.get(index - 1);
27 |     }
28 | }


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/Java/run.sh:
--------------------------------------------------------------------------------
1 | javac -d ./output *.java


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/Convert.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class TreeNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.left = None
 6 | #         self.right = None
 7 | class Solution:
 8 |     # https://www.nowcoder.com/practice/947f6eb80d944a84850b0538bf0ec3a5?tpId=13&tqId=11179&tPage=2&rp=2&ru=%2Fta%2Fcoding-interviews&qru=%2Fta%2Fcoding-interviews%2Fquestion-ranking
 9 |     """
10 |     输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
11 |     """
12 |     def process(self, root, ls):
13 |         """
14 |         中序遍历
15 |         """
16 |         if root == None:
17 |             return
18 |         self.process(root.left, ls)
19 |         ls.append(root)
20 |         self.process(root.right, ls)
21 | 
22 |     def Convert(self, pRootOfTree):
23 |         # write code here
24 |         if pRootOfTree == None:
25 |             return None
26 |         ls = []
27 |         self.process(pRootOfTree, ls)
28 |         for i in range(len(ls)-1):
29 |             node1 = ls[i]
30 |             node2 = ls[i+1]
31 |             node1.right = node2
32 |             node2.left = node1
33 |         return ls[0]
34 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/EntryNodeOfLoop.py:
--------------------------------------------------------------------------------
 1 | def EntryNodeOfLoop(self, pHead): # 26ms 5732K
 2 |     # write code here
 3 |     ls = []
 4 |     count = 0
 5 |     head = pHead
 6 |     while True:
 7 |         if head == None:
 8 |             return None
 9 |         if head in ls:
10 |             count = ls.index(head)
11 |             break
12 |         ls.append(head)
13 |         head = head.next
14 |     while count > 0:
15 |         pHead = pHead.next
16 |         count -= 1
17 |     return pHead
18 | 
19 | def EntryNodeOfLoop(self, pHead): # 21ms 5860K
20 |         # write code here
21 |         count = 0
22 |         p1 = pHead
23 |         p2 = pHead
24 |         while True:
25 |             p2 = p2.next
26 |             if p2 == None:
27 |                 return None
28 |             p2 = p2.next
29 |             if p2 == None:
30 |                 return None
31 |             p1 = p1.next
32 |             count += 1
33 |             if p1 == p2:
34 |                 break
35 |         n = count # 环的长度
36 |         p1 = pHead
37 |         p2 = pHead
38 | 
39 |         while n > 0:
40 |             p2 = p2.next
41 |             n -= 1
42 | 
43 |         while True:
44 |             if p2 == p1:
45 |                 break
46 |             p2 = p2.next
47 |             p1 = p1.next
48 | 
49 |         return p1
50 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/Fibonacci.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def Fibonacci(self, n):
 4 |         # write code here
 5 |         if n == 0:
 6 |             return 0
 7 |         a = 0
 8 |         b = 1
 9 |         while n > 1:
10 |             a, b = b, a+b
11 |             n -= 1
12 |         return b
13 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/FindContinuousSequence.py:
--------------------------------------------------------------------------------
 1 | def FindContinuousSequence(tsum):
 2 |     # write code here
 3 |     if tsum < 2:
 4 |         return []
 5 |     results = []
 6 |     end = int(tsum / 2) + 1
 7 |     for i in range(1, end):
 8 |         n = ((i-0.5)**2 + 2*tsum)**0.5 - i + 0.5 # i: 正整数序列第一个数； n: 序列长度 解二次方程得到n
 9 |         if n % 1 == 0:
10 |             results.append([x for x in range(i, i+n)])
11 |     return results
12 | 
13 | if __name__ == '__main__':
14 |     FindContinuousSequence(3)
15 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/FindFirstCommonNode.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class ListNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.next = None
 6 | class Solution:
 7 |     def FindFirstCommonNode(self, pHead1, pHead2):
 8 |         # write code here
 9 |         if pHead1 == None or pHead2 == None:
10 |             return None
11 |         p1 = pHead1
12 |         p2 = pHead2
13 |         a = 1
14 |         b = 1
15 |         while p1 and p1.next:
16 |             a += 1
17 |             p1 = p1.next
18 |         while p2 and p2.next:
19 |             p2 = p2.next
20 |             b += 1
21 |         if p1 != p2:
22 |             return None
23 |         if a > b:
24 |             p1,p2 = pHead1,pHead2
25 |         else:
26 |             p1,p2 = pHead2, pHead1
27 |         for i in range(abs(a-b)):
28 |             p1 = p1.next
29 |         while p1!=p2:
30 |             p1 = p1.next
31 |             p2 = p2.next
32 |         return p1
33 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/FindGreatestSumOfSubArray.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def FindGreatestSumOfSubArray(self, array):
 4 |         # write code here
 5 |         if len(array) == 0:
 6 |             return 0
 7 |         num = array[0] # 以当前元素结尾的最大子数组和
 8 |         result = array[0] # 当前所有子数组的最大和
 9 |         for i in array[1:]:
10 |             num = max(i, num+i)
11 |             result = max(result, num)
12 |             print("num: {}, result:{}".format(num, result))
13 |         return result
14 | 
15 | if __name__ == '__main__':
16 |     solution = Solution()
17 |     array = [1,-2,3,10,-4,7,2,-5]
18 |     print(solution.FindGreatestSumOfSubArray(array))
19 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/FindKthToTail.py:
--------------------------------------------------------------------------------
 1 | def FindKthToTail(self, head, k):
 2 |     # write code here
 3 |     num = k
 4 |     first = head
 5 |     second = head
 6 |     while num > 0 and first != None:
 7 |         first = first.next
 8 |         num -= 1
 9 |     if num > 0:
10 |         return None
11 |     while first != None:
12 |         first = first.next
13 |         second = second.next
14 |     return second
15 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/FindNumbersWithSum.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def FindNumbersWithSum(self, array, tsum):
 4 |         # write code here
 5 |         dic = {}
 6 |         candidate = []
 7 |         for i in array:
 8 |             if tsum - i in dic:
 9 |                 candidate.append(i)
10 |             else:
11 |                 dic[i] = 1
12 |         if len(candidate) == 0:
13 |             return []
14 |         candidate.sort(key=lambda x: x * (tsum-x))
15 |         num1 = candidate[0]
16 |         num2 = tsum - candidate[0]
17 |         return min(num1, num2), max(num1, num2)
18 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/FindNumsAppearOnce.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     # 返回[a,b] 其中ab是出现一次的两个数字
 4 |     def FindNumsAppearOnce(self, array):
 5 |         # write code here
 6 |         dic = {}
 7 |         for i in array:
 8 |             if i not in dic:
 9 |                 dic[i] = 1
10 |             else:
11 |                 dic[i] += 1
12 |         result = []
13 |         for i in array:
14 |             if dic[i] == 1:
15 |                 result.append(i)
16 |         return result
17 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/FindPath.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class TreeNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.left = None
 6 | #         self.right = None
 7 | class Solution:
 8 |     # 返回二维列表，内部每个列表表示找到的路径
 9 |     def __init__(self):
10 |         self.result = []
11 |         self.path = []
12 | 
13 |     def FindPath(self, root, expectNumber):
14 |         # write code here
15 |         if root == None:
16 |             return []
17 |         self.path.append(root)
18 |         if root.val == expectNumber and root.left == None and root.right == None:
19 |             self.result.append([node.val for node in self.path])
20 |         else:
21 |             self.FindPath(root.left, expectNumber - root.val)
22 |             self.FindPath(root.right, expectNumber - root.val)
23 |         self.path.pop()
24 | 
25 |         return self.result
26 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/FirstAppearingOnce.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     """
 4 |     请实现一个函数用来找出字符流中第一个只出现一次的字符。
 5 |     例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。
 6 |     当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
 7 |     如果当前字符流没有存在出现一次的字符，返回#字符。
 8 |     """
 9 |     def __init__(self):
10 |         self.dic = {}
11 |         self.s = ""
12 |     # 返回对应char
13 |     def FirstAppearingOnce(self):
14 |         for c in self.s:
15 |             if c in self.dic and self.dic[c] == 1:
16 |                 return c
17 |         return '#'
18 |         # write code here
19 |     def Insert(self, char):
20 |         # write code here
21 |         ls = list(self.s)
22 |         ls.append(char)
23 |         self.s = ''.join(ls)
24 |         if char in self.dic:
25 |             self.dic[char] +=1
26 |         else:
27 |             self.dic[char] = 1
28 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/FirstNotRepeatingChar.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def FirstNotRepeatingChar(self, s):
 4 |         # write code here
 5 |         ls = list(s)
 6 |         dic = {}
 7 |         for i in ls:
 8 |             if i in dic:
 9 |                 dic[i] += 1
10 |             else:
11 |                 dic[i] = 1
12 |         for i in ls:
13 |             if i in dic and dic[i] == 1:
14 |                 return ls.index(i)
15 |         return -1
16 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/GetLeastNumbers.py:
--------------------------------------------------------------------------------
1 | # -*- coding:utf-8 -*-
2 | class Solution:
3 |     def GetLeastNumbers_Solution(self, tinput, k):
4 |         # write code here
5 |         if k > len(tinput):
6 |             return []
7 |         tinput.sort()
8 |         return tinput[:k]
9 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/GetMedian.py:
--------------------------------------------------------------------------------
  1 | # -*- coding:utf-8 -*-
  2 | class Solution:
  3 |     """
  4 |     如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。
  5 |     如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
  6 |     排序实现：插入复杂度O(1), 得到中位数复杂度O(nlogn)
  7 |     """
  8 |     def __init__(self):
  9 |         self.ls = []
 10 | 
 11 |     def Insert(self, num):
 12 |         # write code here
 13 |         self.ls.append(num)
 14 |     def GetMedian(self, flag=True):
 15 |         # write code here
 16 |         self.ls.sort()
 17 |         n = len(self.ls)
 18 |         if n % 2 == 0:
 19 |             return (self.ls[n/2] + self.ls[n/2 -1]) / 2.0
 20 |         else:
 21 |             return self.ls[n/2]
 22 | 
 23 | # -*- coding:utf-8 -*-
 24 | class SolutionHeap:
 25 |     """
 26 |     维护最大堆、最小堆，保证最大堆中的数小于最小堆中的所有数
 27 |     插入复杂度O(logn), 得到中位数复杂度O(1)
 28 |     """
 29 |     def __init__(self):
 30 |         self.max_heap = []
 31 |         self.min_heap = []
 32 | 
 33 |     def max_heapify(self):
 34 |         n = len(self.max_heap)
 35 |         k = n - 1
 36 |         while k > 0 and self.max_heap[(k-1)/2] < self.max_heap[k]:
 37 |             self.max_heap[(k-1)/2], self.max_heap[k] = self.max_heap[k], self.max_heap[(k-1)/2]
 38 |             k = (k-1) / 2
 39 | 
 40 |     def min_heapify(self):
 41 |         n = len(self.min_heap)
 42 |         k = n - 1
 43 |         while k > 0 and self.min_heap[(k-1)/2] > self.min_heap[k]:
 44 |             self.min_heap[(k-1)/2], self.min_heap[k] = self.min_heap[k], self.min_heap[(k-1)/2]
 45 |             k = (k-1) / 2
 46 | 
 47 |     def del_max(self):
 48 |         self.max_heap[0], self.max_heap[-1] = self.max_heap[-1], self.max_heap[0]
 49 |         val = self.max_heap.pop()
 50 |         k = 0
 51 |         while 2*k + 1 < len(self.max_heap):
 52 |             j = 2*k + 1
 53 |             if j + 1 < len(self.max_heap) and self.max_heap[j] < self.max_heap[j+1]:
 54 |                 j += 1
 55 |             if self.max_heap[k] < self.max_heap[j]:
 56 |                 self.max_heap[k], self.max_heap[j] = self.max_heap[j], self.max_heap[k]
 57 |                 k = j
 58 |             else:
 59 |                 break
 60 |         return val
 61 | 
 62 |     def del_min(self):
 63 |         self.min_heap[0], self.min_heap[-1] = self.min_heap[-1], self.min_heap[0]
 64 |         val = self.min_heap.pop()
 65 |         k = 0
 66 |         while 2*k + 1 < len(self.max_heap):
 67 |             j = 2*k + 1
 68 |             if j + 1 < len(self.max_heap) and self.max_heap[j] > self.max_heap[j+1]:
 69 |                 j += 1
 70 |             if self.max_heap[k] > self.max_heap[j]:
 71 |                 self.max_heap[k], self.max_heap[j] = self.max_heap[j], self.max_heap[k]
 72 |                 k = j
 73 |             else:
 74 |                 break
 75 |         return val
 76 | 
 77 |     def Insert(self, num):
 78 |         # write code here
 79 |         if len(self.min_heap) == 0:
 80 |             self.min_heap.append(num)
 81 |             self.min_heapify()
 82 |             return
 83 | 
 84 |         if (len(self.max_heap) + len(self.min_heap)) % 2 == 0:
 85 |             # 偶数插入最小堆
 86 |             if num < self.max_heap[0]:
 87 |                 a = self.del_max()
 88 |                 self.max_heap.append(num)
 89 |                 self.max_heapify()
 90 |                 self.min_heap.append(a)
 91 |                 self.min_heapify()
 92 |             else:
 93 |                 self.min_heap.append(num)
 94 |                 self.min_heapify()
 95 |         else:
 96 |             # 奇数插入最大堆
 97 |             if num > self.min_heap[0]:
 98 |                 a = self.del_min()
 99 |                 self.min_heap.append(num)
100 |                 self.min_heapify()
101 |                 self.max_heap.append(a)
102 |                 self.max_heapify()
103 |             else:
104 |                 self.max_heap.append(num)
105 |                 self.max_heapify()
106 | 
107 |     def GetMedian(self, flag=True):
108 |         # write code here
109 |         if (len(self.max_heap) + len(self.min_heap)) % 2 == 0:
110 |             return (self.max_heap[0] + self.min_heap[0]) / 2.0
111 |         else:
112 |             return self.min_heap[0]
113 | 
114 | if __name__ == '__main__':
115 |     solution = Solution()
116 |     for i in range(5):
117 |         solution.Insert(i)
118 |         print(solution.GetMedian())
119 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/GetNumberOfK.py:
--------------------------------------------------------------------------------
1 | # -*- coding:utf-8 -*-
2 | class Solution:
3 |     def GetNumberOfK(self, data, k):
4 |         # write code here
5 |         return data.count(k)
6 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/HasSubtree.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class TreeNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.left = None
 6 | #         self.right = None
 7 | class Solution:
 8 |     def isSub(self, pRoot1, pRoot2):
 9 |         if pRoot2 == None:
10 |             return True
11 |         if pRoot1 != None:
12 |             if pRoot1.val != pRoot2.val:
13 |                 return False
14 |             else:
15 |                 return self.isSub(pRoot1.left, pRoot2.left) and self.isSub(pRoot1.right, pRoot2.right)
16 |         return False
17 | 
18 |     def HasSubtree(self, pRoot1, pRoot2):
19 |         # write code here
20 |         if pRoot2 == None:
21 |             return False
22 |         if pRoot1 == None:
23 |             return False
24 |         if self.isSub(pRoot1, pRoot2):
25 |             return True
26 |         else:
27 |             return self.isSub(pRoot1.left, pRoot2) or self.isSub(pRoot1.right, pRoot2)
28 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/InversePairs.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     """
 4 |     在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。
 5 |     输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
 6 |     牛客网上python超时无法通过
 7 |     """
 8 |     def InversePairs(self, data):
 9 |         # write code here
10 |         self.count = 0
11 |         def merge(a, b):
12 |             result = []
13 |             i = 0
14 |             j = 0
15 |             while i < len(a) and j < len(b):
16 |                 if a[i] < b[j]:
17 |                     result.append(a[i])
18 |                     i += 1
19 |                 else:
20 |                     result.append(b[j])
21 |                     j += 1
22 |                     self.count += len(a) - i
23 |             result.extend(a[i:])
24 |             result.extend(b[j:])
25 |             return result
26 | 
27 | 
28 |         def merge_sort(data):
29 |             if len(data) <= 1:
30 |                 return data
31 |             mid = len(data)/2
32 |             left = merge_sort(data[:mid])
33 |             right = merge_sort(data[mid:])
34 |             return merge(left, right)
35 | 
36 |         merge_sort(data)
37 |         return self.count % 1000000007
38 | 
39 | 
40 | 
41 | 
42 | if __name__ == '__main__':
43 |     s = Solution()
44 |     data = [364,637,341,406,747,995,234,971,571,219,993,407,416,366,315,301, \
45 |     601,650,418,355,460,505,360,965,516,648,727,667,465,849,455,181,486,149, \
46 |     588,233,144,174,557,67,746,550,474,162,268,142,463,221,882,576,604,739, \
47 |     288,569,256,936,275,401,497,82,935,983,583,523,697,478,147,795,380,973, \
48 |     958,115,773,870,259,655,446,863,735,784,3,671,433,630,425,930,64,266,235, \
49 |     187,284,665,874,80,45,848,38,811,267,575]
50 |     print(s.InversePairs(data))
51 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/IsBalanced_Solution.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class TreeNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.left = None
 6 | #         self.right = None
 7 | class Solution:
 8 |     def length(self, root):
 9 |         if root == None:
10 |             return 0
11 |         left = self.length(root.left) + 1
12 |         right = self.length(root.right) + 1
13 |         return max(left, right)
14 | 
15 |     def IsBalanced_Solution(self, pRoot):
16 |         # write code here
17 |         if pRoot == None:
18 |             return True
19 |         left = self.length(pRoot.left)
20 |         right = self.length(pRoot.right)
21 |         if left - right > 1 or left - right < -1:
22 |             return False
23 |         return self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.left)
24 |         
25 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/IsContinuous.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def IsContinuous(self, numbers):
 4 |         # write code here
 5 |         if len(numbers) != 5:
 6 |             return False
 7 |         lo = 14
 8 |         hi = -1
 9 |         for i in numbers:
10 |             if i!=0 and numbers.count(i) > 1:
11 |                 return False
12 |             lo = i if i < lo and i > 0 else lo
13 |             hi = i if i > hi else hi
14 |         if hi - lo > 4:
15 |             return False
16 |         return True
17 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/IsPopOrder.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def IsPopOrder(self, pushV, popV):
 4 |         # write code here
 5 |         while len(popV) > 0:
 6 |             n = popV.pop(0)
 7 |             if n not in pushV:
 8 |                 return False
 9 |             index = pushV.index(n)
10 |             if index > 0 and popV[0] in pushV[:index-1]:
11 |                 return False
12 |             else:
13 |                 pushV.pop(index)
14 |         return True
15 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/KthNode.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class TreeNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.left = None
 6 | #         self.right = None
 7 | class Solution:
 8 |     # 返回对应节点TreeNode
 9 |     def KthNode(self, pRoot, k):
10 |         """
11 |         给定一颗二叉搜索树，请找出其中的第k大的结点
12 |         """
13 |         # write code here
14 |         ls = []
15 |         def traversal(node):
16 |             if node == None:
17 |                 return
18 |             traversal(node.left)
19 |             ls.append(node)
20 |             traversal(node.right)
21 | 
22 |         traversal(pRoot)
23 |         if k <= 0 or k > len(ls):
24 |             return None
25 |         else:
26 |             return ls[k-1]
27 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/LastRemaining_Solution.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def LastRemaining_Solution(self, n, m):
 4 |         # write code here
 5 |         if n == 0:
 6 |             return -1
 7 |         index = 0
 8 |         array = range(n)
 9 |         while len(array) > 1:
10 |             index = (index+m) % len(array) - 1
11 |             array.pop(index)
12 |             if index == -1:
13 |                 index = 0
14 |         return array[0]
15 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/LeftRotateString.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def LeftRotateString(self, s, n):
 4 |         # write code here
 5 |         ls = list(s)
 6 |         length = len(ls)
 7 |         if length == 0:
 8 |             return s
 9 |         num = n % length
10 |         return ''.join(ls[num:] + ls[:num])
11 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/MaxInWindows.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     """
 4 |     给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。
 5 |     例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}；
 6 |     """
 7 |     def maxInWindows(self, num, size):
 8 |         # write code here
 9 |         if size == 0 or size > len(num):
10 |             return []
11 | 
12 |         result = []
13 |         for i in range(len(num) - size + 1):
14 |             result.append(max(num[i:i+size]))
15 |         return result
16 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/Mirror.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class TreeNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.left = None
 6 | #         self.right = None
 7 | class Solution:
 8 |     # 返回镜像树的根节点
 9 |     def Mirror(self, root):
10 |         # write code here
11 |         if root == None:
12 |             return None
13 |         left = root.left
14 |         right = root.right
15 |         root.left = self.Mirror(right)
16 |         root.right = self.Mirror(left)
17 |         return root
18 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/MoreThanHalfNum.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def MoreThanHalfNum_Solution(self, numbers):
 4 |         # write code here
 5 |         if len(numbers) == 0:
 6 |             return 0
 7 |         n = len(numbers) / 2
 8 |         for i in list(set(numbers)):
 9 |             if numbers.count(i) > n:
10 |                 return i
11 |         return 0
12 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/NumberOf1.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def NumberOf1(self, n):
 4 |         # Python 中，整数是没有范围限制的，不会溢出（overflow），需要人工限定范围。
 5 |         INT_BITS = 32
 6 |         MAX_INT = (1 << (INT_BITS - 1)) - 1
 7 |         count = 0
 8 |         while n:
 9 |             if n < - MAX_INT- 1 or n > MAX_INT:
10 |                 break
11 |             n = n & (n - 1)
12 |             count += 1
13 |         return count
14 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/NumberOf1Between1AndN_Solution.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def NumberOf1Between1AndN_Solution(self, n):
 4 |         #https://www.nowcoder.com/practice/bd7f978302044eee894445e244c7eee6?tpId=13&tqId=11184&tPage=2&rp=1&ru=%2Fta%2Fcoding-interviews&qru=%2Fta%2Fcoding-interviews%2Fquestion-ranking
 5 |         # write code here
 6 |         """
 7 |         按每一位求，例如12345: 求0-10000，0-2000，0-300，0-40，0-5之和
 8 |         a表示除去最高位后的位数
 9 |         int(10 ** a * a/10)表示除去最高位后出现1的个数，如果最高位大于1，再加上10**a；如果最高位等于1，再加上此后所有数（10000-12345）
10 |         """
11 |         result = 0
12 |         if n < 0:
13 |             return 0
14 |         length = len(str(n))
15 |         listN = list(str(n))
16 |         for i, v in enumerate(listN):
17 |             a = length - i -1
18 |             if i == length - 1 and int(v) >=1:
19 |                 result += 1
20 |                 break
21 |             if int(v) > 1:
22 |                 result += int(10 ** a * a/10) * int(v) + 10**a
23 |             if int(v) == 1:
24 |                 result += (int(10 ** a * a /10) + int("".join(listN[i+1:])) + 1)
25 |         return result
26 | 
27 | if __name__ == '__main__':
28 |     solution = Solution()
29 |     print(solution.NumberOf1Between1AndN_Solution(200))
30 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/Permutation.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     # https://www.nowcoder.com/practice/fe6b651b66ae47d7acce78ffdd9a96c7?tpId=13&tqId=11180&tPage=2&rp=1&ru=%2Fta%2Fcoding-interviews&qru=%2Fta%2Fcoding-interviews%2Fquestion-ranking
 4 |     # 字符串的排列
 5 |     def add(self, ls, ind, result):
 6 |         """
 7 |         递归确定一个位置的字符
 8 |         """
 9 |         if ind == len(ls)-1:
10 |             result.append(''.join(ls))
11 |         else:
12 |             for i in range(ind, len(ls)):
13 |                 ls[ind], ls[i] = ls[i], ls[ind]
14 |                 self.add(ls, ind+1, result)
15 |                 ls[ind], ls[i] = ls[i], ls[ind]
16 | 
17 |     def Permutation(self, ss):
18 |         # write code here
19 |         if len(ss) == 0:
20 |             return []
21 |         ls = list(ss)
22 |         result = []
23 |         self.add(ls, 0, result)
24 |         result = list(set(result))
25 |         result.sort()
26 |         return result
27 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/Power.py:
--------------------------------------------------------------------------------
1 | # -*- coding:utf-8 -*-
2 | class Solution:
3 |     def Power(self, base, exponent):
4 |         # write code here
5 |         return base ** exponent
6 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/PrintMinNumber.py:
--------------------------------------------------------------------------------
 1 | def PrintMinNumber(numbers):
 2 |     #https://www.nowcoder.com/practice/8fecd3f8ba334add803bf2a06af1b993?tpId=13&tqId=11185&tPage=2&rp=1&ru=%2Fta%2Fcoding-interviews&qru=%2Fta%2Fcoding-interviews%2Fquestion-ranking
 3 |     # write code here
 4 |     if len(numbers) == 0:
 5 |         return ''
 6 |     numbers = [str(x) for x in numbers]
 7 |     numbers.sort(cmp=lambda x,y: cmp(x+y, y+x))
 8 |     return ''.join(numbers).lstrip('0')
 9 | 
10 | if __name__ == '__main__':
11 |     seq = [4,32,325,0]
12 |     print(PrintMinNumber(seq))
13 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/ReverseSentence.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def ReverseSentence(self, s):
 4 |         # write code here
 5 |         ls = s.split(" ")
 6 |         if len(ls)<= 1:
 7 |             return s
 8 |         return " ".join(ls[::-1])
 9 |         
10 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/StrToInt.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def StrToInt(self, s):
 4 |         # write code here
 5 |         ls = list(s)
 6 |         if len(s) == 0:
 7 |             return 0
 8 |         if ls[0] == '+' and len(ls) > 1:
 9 |             for i in ls[1:]:
10 |                 if i < '0' or i > '9':
11 |                     return 0
12 |             return int(''.join(ls[1:]))
13 |         elif ls[0] == '-' and len(ls) > 1:
14 |             for i in ls[1:]:
15 |                 if i < '0' or i > '9':
16 |                     return 0
17 |             return -int(''.join(ls[1:]))
18 |         else:
19 |             for i in ls:
20 |                 if i < '0' or i > '9':
21 |                     return 0
22 |             return int(''.join(ls))
23 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/TreeDepth.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class TreeNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.left = None
 6 | #         self.right = None
 7 | class Solution:
 8 |     def TreeDepth(self, pRoot):
 9 |         # write code here
10 |         if pRoot == None:
11 |             return 0
12 |         left = self.TreeDepth(pRoot.left)
13 |         right = self.TreeDepth(pRoot.right)
14 |         return 1 + max(left, right)
15 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/UglyNum.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def GetUglyNumber_Solution(self, index):
 4 |         # write code here
 5 |         if index == 0:
 6 |             return 0
 7 |         a1 = 0
 8 |         a2 = 0
 9 |         a3 = 0
10 |         result = [1]
11 |         for i in range(1, index):
12 |             num = min([2*result[a1], 3*result[a2], 5*result[a3]])
13 |             result.append(num)
14 |             if num == 2*result[a1]:
15 |                 a1 += 1
16 |             if num == 3*result[a2]:
17 |                 a2 += 1
18 |             if num == 5*result[a3]:
19 |                 a3 += 1
20 |         return result[-1]
21 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/VerifySquenceOfBST.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def VerifySquenceOfBST(self, sequence):
 4 |         # write code here
 5 |         if len(sequence) == 0:
 6 |             return False
 7 |         root = sequence[-1]
 8 |         left = []
 9 |         right = []
10 |         for i, x in enumerate(sequence):
11 |             if x > root:
12 |                 left = sequence[:i]
13 |                 right = sequence[i: len(sequence)-1]
14 |                 break
15 |         for x in right:
16 |             if x < root:
17 |                 return False
18 |         l = True if len(left) == 0 else self.VerifySquenceOfBST(left)
19 |         r = True if len(right) == 0 else self.VerifySquenceOfBST(right)
20 |         return l and r 
21 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/add.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def Add(self, num1, num2):
 4 |         # write code here
 5 |         while num2:
 6 |             s = (num1 ^ num2) & 0xFFFFFFFF # 设置最大位数32
 7 |             c = (num1 & num2) << 1
 8 |             num1 = s
 9 |             num2 = c
10 |         return num1 if num1 <= 0x7FFFFFFF else num1 - 2**32 # 最高位是1表示负数
11 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/clone.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class RandomListNode:
 3 | #     def __init__(self, x):
 4 | #         self.label = x
 5 | #         self.next = None
 6 | #         self.random = None
 7 | class Solution:
 8 |     # https://www.nowcoder.com/practice/f836b2c43afc4b35ad6adc41ec941dba?tpId=13&tqId=11178&tPage=2&rp=2&ru=%2Fta%2Fcoding-interviews&qru=%2Fta%2Fcoding-interviews%2Fquestion-ranking
 9 |     # 返回 RandomListNode
10 |     def Clone(self, pHead):
11 |         # write code here
12 |         if pHead == None:
13 |             return None
14 |         origin = pHead
15 |         origin_nodes = [pHead]
16 |         new_head = RandomListNode(pHead.label)
17 |         new_nodes = [new_head]
18 |         temp = new_head
19 |         while pHead.next:
20 |             pHead = pHead.next
21 |             origin_nodes.append(pHead)
22 |             node = RandomListNode(pHead.label)
23 |             new_nodes.append(node)
24 |             temp.next = node
25 |             temp = temp.next
26 | 
27 |         pHead = origin
28 |         temp = new_head
29 |         while pHead:
30 |             random = pHead.random
31 |             if random == None:
32 |                 temp.random = None
33 |             else:
34 |                 temp.random = new_nodes[origin_nodes.index(random)]
35 |             pHead = pHead.next
36 |             temp = temp.next
37 | 
38 |         return new_head
39 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/deleteDuplication.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class ListNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.next = None
 6 | class Solution:
 7 |     def deleteDuplication(self, pHead):
 8 |         """
 9 |         在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。
10 |         例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
11 |         """
12 |         # write code here
13 |         if pHead == None:
14 |             return None
15 |         if not pHead.next:
16 |             return pHead
17 |         temp = pHead.next
18 |         if pHead.val == temp.val: # 头指针重复，找到第一个不重复的节点，递归
19 |             while temp and temp.val == pHead.val:
20 |                 temp = temp.next
21 |             return self.deleteDuplication(temp)
22 |         else: # 头指针不重复，直接递归下一个节点
23 |             pHead.next = self.deleteDuplication(pHead.next)
24 |             return pHead
25 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/duplicate.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     # 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
 4 |     # 函数返回True/False
 5 |     def duplicate(self, numbers, duplication):
 6 |         # write code here
 7 |         dic = {}
 8 |         for i in numbers:
 9 |             if i in dic:
10 |                 duplication[0] = i
11 |                 return True
12 |             else:
13 |                 dic[i] = 1
14 |         return False
15 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/getNext.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class TreeLinkNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.left = None
 6 | #         self.right = None
 7 | #         self.next = None
 8 | class Solution:
 9 |     """
10 |     给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。
11 |     注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
12 |     """
13 |     def GetNext(self, pNode):
14 |         # write code here
15 |         def left_most(p):
16 |             if p == None:
17 |                 return None
18 |             while p.left:
19 |                 p = p.left
20 |             return p
21 | 
22 |         if pNode == None:
23 |             return None
24 |         if pNode.right:
25 |             return left_most(pNode.right)
26 |         else:
27 |             temp = pNode
28 |             while temp.next:
29 |                 if temp.next.left == temp:
30 |                     # pNode在某节点的左子树中
31 |                     return temp.next
32 |                 temp = temp.next
33 |             # 退到根节点
34 |             return None
35 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/hasPath.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     """
 4 |     请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。
 5 |     路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。
 6 |     如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。
 7 |     例如 a b c e s f c s a d e e 矩阵中包含一条字符串"bcced"的路径，
 8 |     但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
 9 |     """
10 |     def __init__(self):
11 |         self.flag = False
12 |     def hasPath(self, matrix, rows, cols, path):
13 | 
14 |         # write code here
15 |         def neighbours(x, y):
16 |             result = []
17 |             if x > 0:
18 |                 result.append((x-1, y))
19 |             if x < rows - 1:
20 |                 result.append((x+1, y))
21 |             if y > 0:
22 |                 result.append((x, y-1))
23 |             if y < cols - 1:
24 |                 result.append((x, y + 1))
25 |             return result
26 | 
27 |         def dfs(i, j, visited, ls, path):
28 |             if visited[i][j] == 0:
29 |                 ls.append(matrix[i][j])
30 |                 visited[i][j] = 1
31 |                 if ls == path:
32 |                     self.flag = True
33 |                 if len(ls) < len(path) and ls == path[:len(ls)]:
34 |                     for (x, y) in neighbours(i,j):
35 |                         dfs(x, y, visited, ls, path)
36 |                 ls.pop()
37 |                 visited[i][j] = 0
38 | 
39 | 
40 |         path = list(path)
41 |         if rows == 0 or cols == 0:
42 |             return False
43 |         matrix = [matrix[i*cols:i*cols+cols] for i in range(rows)]
44 |         print(matrix)
45 |         visited = [[0]*cols for k in range(rows)]
46 |         ls = []
47 |         for i in range(rows):
48 |             for j in range(cols):
49 |                 visited = [[0]*cols for k in range(rows)]
50 |                 ls = []
51 |                 flag = False
52 |                 dfs(i,j, visited, ls, path)
53 |                 if self.flag:
54 |                     return True
55 |         return False
56 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/isNumeric.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     # s字符串
 4 |     def isNumeric(self, s):
 5 |         """
 6 |         请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。
 7 |         例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。
 8 |         但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。
 9 |         """
10 |         # write code here
11 |         def isNum(ls):
12 |             """
13 |             判断是否为不带E的数字
14 |             """
15 |             print(ls)
16 |             if len(ls) == 0:
17 |                 return False
18 |             if ls.count('.') > 1:
19 |                 return False
20 |             for i, c in enumerate(ls):
21 |                 if c < '0' or c > '9':
22 |                     if (c == '+' or c == '-') and i == 0:
23 |                         continue
24 |                     elif c == '.' and i > 0 and i < len(ls)-1:
25 |                         continue
26 |                     else:
27 |                         return False
28 |             return True
29 | 
30 |         def isInt(ls):
31 |             """
32 |             判断是否为整数
33 |             """
34 |             if len(ls) == 0:
35 |                 return False
36 |             for i, c in enumerate(ls):
37 |                 if c < '0' or c > '9':
38 |                     if c == '+' or c == '-' and i == 0:
39 |                         continue
40 |                     else:
41 |                         return False
42 |             return True
43 | 
44 |         if len(s) == 0:
45 |             return False
46 |         ls = s.lower().split('e')
47 |         if len(ls) == 1:
48 |             return isNum(list(ls[0]))
49 |         else:
50 |             return isNum(list(ls[0])) and isInt(list(ls[1]))
51 | 
52 | if __name__ == '__main__':
53 |     solution = Solution()
54 |     print solution.isNumeric("1+23")
55 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/isSymmetrical.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class TreeNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.left = None
 6 | #         self.right = None
 7 | class Solution:
 8 |     """
 9 |     请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
10 |     """
11 |     def isSymmetrical(self, pRoot):
12 |         # write code here
13 |         def isSame(p1, p2):
14 |             """
15 |             比较两个节点是否相同
16 |             """
17 |             if p1==None and p2==None:
18 |                 return True
19 |             if p1 and p2 and p1.val == p2.val:
20 |                 return True
21 |             else:
22 |                 return False
23 | 
24 |         if pRoot == None:
25 |             return True
26 |         left = [pRoot.left] # 从左到右的顺序
27 |         right = [pRoot.right] # 从右到左的顺序
28 |         while len(left)>0:
29 |             pLeft = left.pop(0)
30 |             pRight = right.pop(0)
31 |             if not isSame(pLeft, pRight):
32 |                 return False
33 |             else:
34 |                 if pLeft: # pLeft非空，pRight必定非空，否则比较的时候已经返回False
35 |                     left.append(pLeft.left)
36 |                     left.append(pLeft.right)
37 |                     right.append(pRight.right)
38 |                     right.append(pRight.left)
39 |         return True
40 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/jumpFloor.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def jumpFloor(self, number):
 4 |         # write code here
 5 |         if number < 1:
 6 |             return 0
 7 |         a = [0,1,2]
 8 |         for i in range(3, number + 1):
 9 |             a.append(a[i-1] + a[i-2])
10 |         return a[number]
11 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/jumpFloorII.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def jumpFloorII(self, number):
 4 |         # write code here
 5 |         if number <= 0:
 6 |             return 0
 7 |         a = [0] * number
 8 |         a[0] = 1
 9 |         for i in range(1, number):
10 |             a[i] = sum(a[:i]) + 1
11 |         return a[number - 1]
12 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/match.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     """
 4 |     请实现一个函数用来匹配包括'.'和'*'的正则表达式。
 5 |     模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次）。
 6 |     在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配
 7 |     """
 8 |     # s, pattern都是字符串
 9 |     def match(self, s, pattern):
10 |         # write code here
11 |         if len(pattern) == 0 and len(s) == 0:
12 |             return True
13 |         elif len(pattern) > 0 and len(s) == 0:
14 |             if len(pattern) > 1 and pattern[1] == "*":
15 |                 return self.match(s, pattern[2:])
16 |             else:
17 |                 return False
18 |         elif len(pattern) == 0 and len(s) > 0:
19 |             return False
20 |         else:
21 |             if pattern[0] == s[0]:
22 |                 if len(pattern)>1 and pattern[1] == '*':
23 |                     # a*不匹配，a*匹配s[0]
24 |                     return self.match(s, pattern[2:]) or self.match(s[1:], pattern)
25 |                 return self.match(s[1:], pattern[1:])
26 |             else:
27 |                 if pattern[0] == '.':
28 |                     if len(pattern)> 1 and pattern[1] == '*':
29 |                         # a*不匹配，a*匹配s[0]
30 |                         return self.match(s, pattern[2:]) or self.match(s[1:], pattern)
31 |                     return self.match(s[1:], pattern[1:])
32 |                 elif len(pattern) > 1 and pattern[1] == '*':
33 |                     return self.match(s, pattern[2:])
34 |                 else:
35 |                     return False
36 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/merge.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class ListNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.next = None
 6 | class Solution:
 7 |     # 返回合并后列表
 8 |     def Merge(self, pHead1, pHead2):
 9 |         # write code here
10 |         if pHead1 == None:
11 |             return pHead2
12 |         if pHead2 == None:
13 |             return pHead1
14 |         if pHead1.val < pHead2.val:
15 |             pHead1.next = self.Merge(pHead1.next, pHead2)
16 |             return pHead1
17 |         else:
18 |             pHead2.next = self.Merge(pHead1, pHead2.next)
19 |             return pHead2
20 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/minNumberInRotateArray.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def minNumberInRotateArray(self, rotateArray):
 4 |         # write code here
 5 |         if len(rotateArray) == 0:
 6 |             return 0
 7 |         for i in range(1, len(rotateArray)):
 8 |             if i + 1 < len(rotateArray) and rotateArray[i] > rotateArray[i+1]:
 9 |                 return rotateArray[i+1]
10 |         return rotateArray[0]
11 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/min_stack.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def __init__(self):
 4 |         self.ls = []
 5 | 
 6 |     def push(self, node):
 7 |         # write code here
 8 |         self.ls.append(node)
 9 |     def pop(self):
10 |         # write code here
11 |         return self.ls.pop()
12 |     def top(self):
13 |         # write code here
14 |         if len(self.ls) == 0:
15 |             return None
16 |         return self.ls[-1]
17 |     def min(self):
18 |         # write code here
19 |         return min(self.ls)
20 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/movingCount.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     """
 4 |     地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，
 5 |     但是不能进入行坐标和列坐标的数位之和大于k的格子。
 6 |     例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），
 7 |     因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
 8 |     """
 9 |     def movingCount(self, threshold, rows, cols):
10 |         # write code here
11 |         def neighbours(x, y):
12 |             result = []
13 |             if x > 0:
14 |                 result.append((x-1, y))
15 |             if x < rows - 1:
16 |                 result.append((x+1, y))
17 |             if y > 0:
18 |                 result.append((x, y-1))
19 |             if y < cols - 1:
20 |                 result.append((x, y + 1))
21 |             return result
22 | 
23 |         def isLegal(i, j):
24 |             res = 0
25 |             while i:
26 |                 res += i % 10
27 |                 i = i/10
28 |             while j:
29 |                 res += j % 10
30 |                 j = j/10
31 |             return res <= threshold
32 | 
33 |         def dfs(i, j, visited):
34 |             if isLegal(i,j) and visited[i][j] == 0:
35 |                 visited[i][j] = 1
36 |                 for (x,y) in neighbours(i,j):
37 |                     dfs(x,y, visited)
38 | 
39 |         visited = [[0]*cols for i in range(rows)]
40 |         dfs(0,0,visited)
41 |         ls = [sum(i) for i in visited]
42 |         return sum(ls)
43 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/multiply.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def multiply(self, A):
 4 |         # write code here
 5 |         B = []
 6 |         forward = [1]
 7 |         backward = [1]
 8 |         n = len(A)
 9 |         for i in range(1,n):
10 |             forward.append(forward[i-1] * A[i-1])
11 |             backward.append(backward[i-1] * A[n-i])
12 |         for i in range(n):
13 |             B.append(forward[i]*backward[n-i-1])
14 |         return B
15 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/print.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class TreeNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.left = None
 6 | #         self.right = None
 7 | class Solution:
 8 |     # 返回二维列表[[1,2],[4,5]]
 9 |     def Print(self, pRoot):
10 |         """
11 |         从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
12 |         """
13 |         # write code here
14 |         if pRoot == None:
15 |             return []
16 |         queue = [pRoot]
17 |         result = []
18 |         while len(queue) > 0:
19 |             n = len(queue)
20 |             ls = []
21 |             for i in range(n):
22 |                 node = queue.pop(0)
23 |                 ls.append(node.val)
24 |                 if node.left:
25 |                     queue.append(node.left)
26 |                 if node.right:
27 |                     queue.append(node.right)
28 |             result.append(ls)
29 |         return result
30 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/print2.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class TreeNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.left = None
 6 | #         self.right = None
 7 | class Solution:
 8 |     """
 9 |     请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，
10 |     第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
11 |     """
12 |     def Print(self, pRoot):
13 |         # write code here
14 |         if pRoot == None:
15 |             return []
16 |         result = []
17 |         queue = [pRoot]
18 |         flag = False
19 |         while len(queue) > 0:
20 |             n = len(queue)
21 |             ls = []
22 |             for i in range(n):
23 |                 node = queue.pop(0)
24 |                 ls.append(node.val)
25 |                 if node.left:
26 |                     queue.append(node.left)
27 |                 if node.right:
28 |                     queue.append(node.right)
29 |             if flag:
30 |                 result.append(ls[::-1])
31 |             else:
32 |                 result.append(ls)
33 |             flag = not flag
34 |         return result
35 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/printFromToptoBottom.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class TreeNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.left = None
 6 | #         self.right = None
 7 | class Solution:
 8 |     # 返回从上到下每个节点值列表，例：[1,2,3]
 9 |     def PrintFromTopToBottom(self, root):
10 |         # write code here
11 |         if root == None:
12 |             return []
13 |         result = []
14 |         queue = [root]
15 |         while len(queue) > 0:
16 |             node = queue.pop(0)
17 |             result.append(node.val)
18 |             if node.left != None:
19 |                 queue.append(node.left)
20 |             if node.right != None:
21 |                 queue.append(node.right)
22 |         return result
23 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/printListFromTailToHead.py:
--------------------------------------------------------------------------------
 1 | class ListNode:
 2 |     def __init__(self, x):
 3 |         self.val = x
 4 |         self.next = None
 5 | 
 6 | def printListFromTailToHead(listNode):
 7 |         ls = []
 8 |         while listNode != None:
 9 |             ls.append(listNode.val)
10 |             listNode = listNode.next
11 |         return ls[::-1]
12 | 
13 | if __name__ == '__main__':
14 |     node = ListNode(1)
15 |     node.next = ListNode(2)
16 |     printListFromTailToHead(node)
17 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/printMatrix.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     # matrix类型为二维列表，需要返回列表
 4 |     def printMatrix(self, matrix):
 5 |         # write code here
 6 |         def reverse(matrix):
 7 |             """
 8 |             逆时针旋转
 9 |             """
10 |             rev = []
11 |             if len(matrix) == 0:
12 |                 return rev
13 |             n = len(matrix[0])
14 |             for i in range(n):
15 |                 rev.append([x[n-1-i] for x in matrix])
16 |             return rev
17 | 
18 |         result = []
19 |         while len(matrix) > 0:
20 |             result.extend(matrix.pop(0))
21 |             print(result)
22 |             matrix = reverse(matrix)
23 |         return matrix
24 | 
25 | if __name__ == '__main__':
26 |     solution = Solution()
27 |     solution.printMatrix([[1]])
28 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/queue.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     """
 4 |     用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
 5 |     """
 6 |     def __init__(self):
 7 |         self.stack1 = []
 8 |         self.stack2 = []
 9 |          
10 |     def push(self, node):
11 |         # write code here
12 |         if len(self.stack1) == 0:
13 |             while len(self.stack2):
14 |                 self.stack1.append(self.stack2.pop())
15 |         self.stack1.append(node)
16 |          
17 |     def pop(self):
18 |         # return xx
19 |         if not len(self.stack2) == 0:
20 |             return self.stack2.pop()
21 |         else:
22 |             while len(self.stack1) > 1:
23 |                 self.stack2.append(self.stack1.pop())
24 |             return self.stack1.pop()
25 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/reConstructBinaryTree.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class TreeNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.left = None
 6 | #         self.right = None
 7 | class Solution:
 8 |     # 返回构造的TreeNode根节点
 9 |     def reConstructBinaryTree(self, pre, tin):
10 |         # write code here
11 |         if len(pre) == 0:
12 |             return None
13 |         val = pre[0]
14 |         root = TreeNode(val)
15 |         if len(pre) > 1:
16 |             index = tin.index(val)
17 |             left_tin = tin[:index]
18 |             left_pre = pre[1:len(left_tin)+1]
19 |             right_pre = pre[len(left_tin) + 1:]
20 |             right_tin = tin[index+1:]
21 |             root.left = self.reConstructBinaryTree(left_pre, left_tin)
22 |             root.right = self.reConstructBinaryTree(right_pre, right_tin)
23 |         return root
24 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/reOrderArray.py:
--------------------------------------------------------------------------------
1 | # -*- coding:utf-8 -*-
2 | class Solution:
3 |     def reOrderArray(self, array):
4 |         # write code here
5 |         return [x for x in array if x % 2 != 0] + [x for x in array if x % 2 == 0]
6 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/rectCover.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     def rectCover(self, number):
 4 |         # write code here
 5 |         if number < 1:
 6 |             return 0
 7 |         a = [0,1,2]
 8 |         for i in range(3, number+1):
 9 |             a.append(a[i-1] + a[i-2]) # 动态规划 第一块竖放：a[i-1]; 第一块横放：a[i-2]
10 |         return a[number]
11 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/replaceSpace.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | class Solution:
 3 |     # s 源字符串
 4 |     def replaceSpace(self, s):
 5 |         # write code here
 6 |         s = list(s)
 7 |         for i, c in enumerate(s):
 8 |             if c == ' ':
 9 |                 s[i] = '%20'
10 |         return ''.join(s)
11 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/reverseList.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class ListNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.next = None
 6 | class Solution:
 7 |     # 返回ListNode
 8 |     def ReverseList(self, head):
 9 |         # write code here
10 |         # a->b->c->None
11 |         # None<-a<-b<-c
12 |         pre = None
13 |         while head != None:
14 |             temp = head.next # 保存下一个节点
15 |             head.next = pre # 反转
16 |             pre = head # 向后移动
17 |             head = temp # 向后移动
18 |         return pre
19 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/serialize.py:
--------------------------------------------------------------------------------
 1 | # -*- coding:utf-8 -*-
 2 | # class TreeNode:
 3 | #     def __init__(self, x):
 4 | #         self.val = x
 5 | #         self.left = None
 6 | #         self.right = None
 7 | class Solution:
 8 |     """
 9 |     请实现两个函数，分别用来序列化和反序列化二叉树
10 |     """
11 |     def Serialize(self, root):
12 |         # write code here
13 |         ls = []
14 |         def process(root):
15 |             if root == None:
16 |                 ls.append("$")
17 |                 return
18 |             ls.append(str(root.val))
19 |             process(root.left)
20 |             process(root.right)
21 |         process(root)
22 |         return ','.join(ls)
23 | 
24 |     def Deserialize(self, s):
25 |         # write code here
26 |         ls = s.split(',')
27 |         def process():
28 |             val = ls.pop(0)
29 |             if val == "$":
30 |                 return None
31 |             node = TreeNode(int(val))
32 |             node.left = process()
33 |             node.right = process()
34 |             return node
35 | 
36 |         return process()
37 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/sum_solution.py:
--------------------------------------------------------------------------------
1 | # -*- coding:utf-8 -*-
2 | class Solution:
3 |     def Sum_Solution(self, n):
4 |         # write code here
5 |         return sum(range(1,n+1))
6 | 


--------------------------------------------------------------------------------
/数据结构与算法/剑指offer/python/twodarray.py:
--------------------------------------------------------------------------------
 1 | def Find(target, array):
 2 |     # write code here
 3 |     while len(array) > 0 and len(array[0]) > 0:
 4 |         print(array)
 5 |         if array[0][-1] == target:
 6 |             return True
 7 |         elif array[0][-1] > target:
 8 |             # remove column
 9 |             array = [a[:-1] for a in array]
10 |         else:
11 |             # remove row
12 |             array = array[1:]
13 | 
14 |     return False
15 | 
16 | if __name__ == '__main__':
17 |     target = 7
18 |     array = [[1,2,8,9],[2,4,9,12],[4,7,10,13],[6,8,11,15]]
19 |     print(Find(target, array))
20 | 


--------------------------------------------------------------------------------
/数据结构与算法/图.md:
--------------------------------------------------------------------------------
  1 | # 图的表示 #
  2 | 稀疏图使用邻接链表，稠密图使用邻接矩阵，无向图的邻接矩阵的转置是其本身
  3 | 
  4 | 链表的数据结构 
  5 | ```java
  6 | 	class LinkNode {
  7 | 		LinkNode next;
  8 | 		Integer val;
  9 | 		String color;	
 10 | 		LinkNode(Integer val) {
 11 | 			this.val = val;
 12 | 		}
 13 | 	}
 14 | ```
 15 | 邻接链表的优点是可以以`O(V+E)`的空间复杂度存储图的信息，但是如果想要判断两个节点之间是否存在路径则需要遍历其中的一个子链表
 16 | 而邻接矩阵则是以一个二维数组存储，如果i节点和j节点之间存在路径，则`array[i][j]`的值是1或路径的权重
 17 | 
 18 | # 图的搜索 #
 19 | ## 广度优先搜索 ##
 20 | 基本思想是，以节点颜色标识此节点是否被处理过，白色表示未被访问过，灰色表示被访问过，黑色表示此节点的所有邻接节点都被访问过。
 21 | 算法的执行过程为，首先将图中的所有节点都置为白色，将源节点置为灰色，然后将源节点推入队列中；在队列不为空的情况下，循环出队，并将当前出队的节点的所有为白色的邻接节点置为灰色（被发现），之后将出队的节点置为黑色。二叉树的层级遍历就是图的广度优先搜索。
 22 | 
 23 | ```java
 24 |      public void BFS(LinkNode[] G, LinkNode s) {
 25 |         for (LinkNode node : G) {
 26 |             node.color = "WHITE";
 27 |         }
 28 | 
 29 |         s.color = "GREY";
 30 | 
 31 |         Queue<LinkNode> queue = new LinkedList<>();
 32 |         queue.add(s);
 33 | 
 34 |         while (queue.size() > 0) {
 35 |             LinkNode u = queue.poll();
 36 |             LinkNode temp = u.next;
 37 |             while (temp != null) {
 38 |                 if (G[temp.val].color == "WHITE") {
 39 |                     queue.add(G[temp.val]);
 40 |                     temp = temp.next;
 41 |                 }
 42 |             }
 43 |             u.color = "BLACK";
 44 |         }
 45 | 
 46 |     }
 47 | ```
 48 | 以上代码假设图中的节点为连续的数字，如果是其他情况，可以使用Map表示节点与其邻接链表之间的映射。
 49 | 
 50 | ## 深度优先搜索 ##
 51 | 深度优先搜索的基本思想是以递归的方式逐层深入图的非黑最底部，将底部节点置为黑色，之后回到上一层，再次深入非黑节点。代码如下
 52 | 
 53 | ```java
 54 |     public void DFS(LinkNode[] G){
 55 |         for (LinkNode node : G) {
 56 |             node.color = "WHITE";
 57 |         }
 58 | 
 59 |         for(LinkNode u: G){
 60 |            if("WHITE".equals(u.color)){
 61 |                DFS_VISIT(G, u);
 62 |            }
 63 |         }
 64 |     }
 65 | 
 66 | 
 67 |     public void DFS_VISIT(LinkNode [] G, LinkNode u){
 68 |         u.color = "GREY";
 69 |         LinkNode temp = u.next;
 70 |         while(temp != null){
 71 |             if("WHITE".equals(temp.color)){
 72 |                 DFS_VISIT(G, G[temp.val]);
 73 |             }
 74 | 	    temp = temp.next;
 75 |         }
 76 |         u.color = "BLACK";
 77 |     }
 78 |     
 79 |     
 80 | ```
 81 | 
 82 | 同上假设图中节点为连续数字
 83 | 
 84 | ## 图的拓扑排序 ##
 85 | 
 86 | 图的拓扑排序是将图的所有节点在一条水平线上展开，图中的所有有向边都从左指向右。假设我们将图的拓扑排序存储在一个链表中，可以通在DFS算法中加入一个节点处理完成时间标识，在每一个节点完成后，将其插入链表的顶部。结果链表就是这个图的拓扑排序。
 87 | 
 88 | ## 强连通分量 ##
 89 | 对于有向图G=(V,E)来说，他的一个强联通分量是一个最大节点集合C属于V，对于C中任意一对节点u和v来说，路径v-u和路径v-u同时存在。
 90 | 求解强连通分量的方法是
 91 |     
 92 |     1. 对图进行DFS，并记录每个节点结束的时间
 93 |     2. 对图进行转置（所有的边反向）
 94 |     3. 按照第一步记录时间的递减顺序（即拓扑排序）再次进行DFS，此次得到的DFS森林即G的强连通分量
 95 | 可以简单的证明这个方法的正确性。对于强联通分量C，其转置仍然是一个强连通分量，对于G，假设有两个强联通分量C1和C2且存在一条边使得C1-C2连通，但C2-C1不连通。在进行DFS过程中，如果先访问到C1，则C2的所有节点都是C1中节点的子节点，其完成时间将早于C1中的所有节点，在进行转置后的DFS过程中，由于C1-C2不连通，所以C1将会变成一棵单独的树。而如果在DFS过程中首先访问的是C2，由于C2-C1不连通，所以C2的完成时间一定早于C1，同前述论证。
 96 | 
 97 | 
 98 | ## 单源最短路径 ##
 99 | 在介绍单源最短路径算法之前，先介绍一下松弛操作。对于每一个几点来说，我们维持一个属性v.d用来记录源节点s到节点v的最短路径的上界（即最短路径不会超过这个值）。我们称v.d为s到v的最短路径估计。对一条边`(u,v)`的松弛过程为判断`u.d + w(u,v)`（其中w(u,v)为uv两节点之间边的长度）与当前v.d的大小关系，如果更小，则更新v.d
100 | 
101 | ```java
102 |     RELAX(u,v w){
103 | 	    if(v.d > u.d + w(u,v)){
104 | 	        v.d = u.d + w(u,v)
105 | 	    }
106 | 	}
107 | ```
108 | ### Bellman-Ford算法 ###
109 | 此算法解决的是一般情况下的单源最短路径问题，一般情况是指边的权重可以为负值。我们假设图中没有值为负值的环。
110 | 此算法通过对边进行松弛操作来渐进的降低从源节点s到每个节点v的最短路径。
111 | 初始状态s.d为0，其他任意节点v.d为无穷大。理论上，对图中所有边进行V-1松弛操作一定可以得到节点源节点到任意节点的最短路径
112 | 
113 | ![somewords](/image/Bellman.png?raw=true "Title")
114 | 简单证明：考虑任意从源节点可以到达的节点v，假设P=<v0,v1,v2...vk>为从源节点s到节点v的一条最短路径。这里v0=s，vk=v。因为最短路径肯定是简单路径（不存在环），所以P最多包含V-1条边。如果我们的松弛次序为（v0,v1）(v1,v2)...v(k-1,k)，则我们只需要一次松弛循环。如果顺序从后向前，在松弛（v0,v1）前松弛其他的路径都是没有意义的，所以真正的松弛次序是，第一次松弛（v0,v1）第二次松弛（v1,v2）..以此类推，我们最多需要V-1此松弛操作。
115 | 
116 | ### 有向无环图的最短路径 ###
117 | 可以很容易的发现Bellman-Ford算法需要O(VE)的时间复杂度。但是从其证明中我们发现，如果路径的松弛操作是有序的，需要的松弛操作将会大大减少。因此，对于有向无环图，我们可以对其进行拓扑排序然后初始化源节点s.d为0，从拓扑排序的端点依次对每一个节点的每一条边进行松弛操作，通过依次遍历就可以得到从源节点到所有节点的最短路径，由于整个过程，所有的节点都只访问一次，所有的边进行一次松弛操作，所有时间复杂度是
118 | O(V+E)
119 | ### Dijkstra算法 ###
120 | Dijkstra算法要求图中所有边的权重为非负值，其本质是一个贪心算法，每次进行节点的选择都选择一个松弛后d值最小的节点作为下一个节点。实现思路是维持一组节点集合S，从源节点到S中的所有节点之间的最短路径已经被找到，运行过程中重复从V-S中选择当前d值最小的节点u加入S中，然后对从u出发的所有节点进行松弛操作。
121 | 以下为伪代码：
122 | ```java
123 |     public void DIJKSTRA(LinkNode[] G, LinkNode s, int[][] w) {
124 |         List<LinkNode> Q = new ArrayList<>();
125 |         for (LinkNode node : G) {
126 |             node.d = Integer.MAX_VALUE;
127 |             Q.add(node);
128 | 
129 |         }
130 |         
131 |         s.d = 0;
132 |         
133 |         List<LinkNode> S = new ArrayList<>();
134 |         
135 |         while (Q.size() != 0) {
136 |             LinkNode u = EXTRACT_MIN(Q);
137 |             Q = Q.subList(1,Q.size());
138 |             S.add(u);
139 | 
140 | 
141 |             LinkNode temp = u.next;
142 |             while(temp!= null){
143 |                 RELAX(u, temp, w);
144 |             }
145 |         }
146 | 
147 | 
148 |     }
149 | 
150 |     private void RELAX(LinkNode u, LinkNode v, int[][] w){
151 |         int val = u.d + w[u.val][v.val];
152 |         if(val < v.d){
153 |             v.d = val;
154 |         }
155 |     }
156 | 
157 |     private LinkNode EXTRACT_MIN(List<LinkNode> list) {
158 |         list.sort((a, b) -> {
159 |             return a.d - b.d;
160 |         });
161 |         return list.get(0);
162 |     }
163 | ```
164 | 
165 | 
166 | 
167 | 简单证明：以数学归纳法，最初，s.d为0，为从s到s的最短路径，下一个节点u为针对s进行松弛的邻接节点中d值最小的一个，由于所有的路径的权值都非负，所以不存在一条路径s-v-u的松弛使得其d值小于当前的u.d。所以，当前u.d为从s到u的最短路径。初始情况描述完毕，我们选取运行过程中刚刚进入S的节点x，并对x的所有边松弛完毕，y为V-S中当前权值最小的一个节点，对于V-S中的其他节点，y有潜力使其d值减小，而对于V-S中任意节点v，其没有潜力能够使y.d减小（因为v.d>y.d,且边的权重非负），所以此时y.d一定是源节点到y节点的最短路径值。
168 | ### Floyd Warshall算法 ###
169 | Floyd warshall算法是解决任意两点间的最短路径的一种算法，此算法的是一个经典的动态规划算法。
170 | 其基本思想基于这样一个观察，设图中所有节点V={1,2,3..n},设T={1,2..k}是其一个子集，即k<=n。对于节点i和节点j之间最短路径p，其所有中间节点都属于集合T。这里有一个关键的关系，即如果k不在路径p上，则节点i和节点j之间的最短路径属于集合T-{k}，即{1,2..k-1};如果路径p中包含k节点，则路径i-k中的节点属于T-{k}，k-j中的节点也属于T-{k}。基于这个关系，我们设D(i,j,k)为节点i到节点j的所有中间节点属于集合T的一条最短路径的权重。显然，当k为0时，路径中将不包含任何节点，则D(i,j,k)=w(i,j)(即路径i-j的权重)。当k>=1,D(i,j,k) = min{D(i,j,k-1), D(i,k,k-1)+D(k,j,k-1)}。显然问题的最优解依赖于子问题的最优解，是一个动态规划的问题，我们通过自底向上的方式求解这个问题，最终矩阵D(i,j,n)即为最终结果。代码如下
171 | ```java
172 |     public int[][] FLOAD_WARSHALL(int [][] G) {
173 |         int n = G.length;
174 |         int [][][] D = new int[n][n][n];
175 |         D[0] = G;
176 |         for (int k = 1; k < n; k++) {
177 |             for(int i = 1; i<n; i++){
178 |                 for(int j = 1; j<n;j++){
179 |                     D[k][i][j] = Math.min(D[k-1][i][j], D[k-1][i][k] + D[k-1][k][j]);
180 |                 }
181 |             }
182 |         }
183 |         return D[n];
184 |     }
185 | ```
186 | 
187 | 
188 | 
189 | 


--------------------------------------------------------------------------------
/数据结构与算法/红黑树.md:
--------------------------------------------------------------------------------
 1 | ## 红黑树 ##
 2 | 红黑树的性质
 3 | >
 4 | 1. 节点的颜色分为红色和黑色
 5 | 2. 根是黑色
 6 | 3. 所有叶节点都是黑色（叶节点是NIL节点）
 7 | 4. 每个红色节点必须有两个黑色子节点
 8 | 5. 从任一节点到其每个叶子所有的简单路径都包含相同数据的黑色节点
 9 | 
10 | 


--------------------------------------------------------------------------------
/数据结构与算法/背包问题.md:
--------------------------------------------------------------------------------
 1 | ### 问题
 2 | 
 3 | **输入**：
 4 | 
 5 |  * 背包容量W
 6 |  * n个物品：
 7 | 	* 价值$v_i$
 8 | 	* 大小$w_i$
 9 | 
10 | **输出**：
11 | 	最优解$S$，$S\subseteq \{1,2,3,...,n\}$；
12 | 	S在满足$\sum_{i\in S}{w_i} <= W$的条件下,最大化$\sum_{i\in S}{v_i}$
13 |  
14 | 
15 | ### 思路
16 | 
17 | 假设把所有物品排成一列，考虑最后一个物品$n$，价值$v_n$，大小$w_n$:
18 | 	
19 | 1. 如果$n \notin S$, 则对于其他$n-1$个物品和容量$W$，$S$也是最优解
20 | 2. 如果$n \in S$, 则对于其他$n-1$个物品和容量$W-w_n$，$S-\{n\}$是最优解
21 | 
22 | > 反证：存在$\tilde{S}$是比$S-\{n\}$更优的解，则$\tilde{S} + \{n\}$是比$S$更优的解，这与$S$是最优解矛盾
23 | 
24 | 所以在已知去掉最后一个物品的子问题解的情况下，最优解只有两种可能：
25 | 
26 | 1. 子问题（n-1个物品和容量W）的最优解
27 | 2. 子问题（n-1个物品和容量$W-w_n$）的最优解，加上最后一个物品的价值$v_n$
28 | 
29 | 
30 | 假设A[i,x]表示由（前i个物品和容量x）组成的子问题解，可以得到动态规划的递推表达式：
31 | $$A[i,x] = max\{A[i-1,x], A[i-1,x-w_i]+v_i \}$$
32 | 
33 | 
34 | ### 算法
35 | 伪代码：
36 | 
37 | ```
38 | let A = 2-D array
39 | initialize A[0,x] = 0 for x = 0,1,2,...,w
40 | for i = 1,2,3,...,n:
41 | 	for x = 0,1,2,...,w:
42 | 		A[i,x] := max{A[i-1,x], A[i-1,x-w] + v}
43 | return A[n,w]
44 | ```
45 | 


--------------------------------------------------------------------------------
/机器学习/dkl项目相关准备.md:
--------------------------------------------------------------------------------
  1 | # 项目相关准备
  2 | 
  3 | ## 1. cvr预估比赛
  4 | 
  5 | ### 1.1 数据清洗
  6 | 
  7 | 稀疏点：在别人的比赛里，看到别人处理了出现次数比较少的点。点击次数少于1000次的，进行标记。万分点的提升。
  8 | 
  9 | 错误点：对30号的数据进行错误纠正，去掉平均转化率大于1天的app的数据。
 10 | 
 11 | ### 1.2 特征工程
 12 | 
 13 | #### 1.2.1 所用到的特征
 14 | 
 15 | 1. 将提供给的信息分类：分为用户特征，app特征，广告特征，上下文特征，还有组合特征，分别对这些特征进行组合，然后求其计数，点击率，转化率，排行，标记等特征。
 16 | 
 17 | 2. ctr计算平滑有两种方法的平滑：数据层级结构的贝叶斯平滑，以及时间窗口的贝叶斯平滑：
 18 | 
 19 |    （1）时间窗口的平滑：统计每天的ctr率时，不仅与当天的ctr相关，也与昨天的ctr相关。以gamma为系数。
 20 | 
 21 |    （2）数据层级结构的平滑（只对position这个特征做了平滑）：数据层级的贝叶斯平滑可以这样理解：同一个position下面的Ad，每个Ad的点击服从一个二项分布，但是她们又是在同一个position下面的Ad，它们的点击不光是由于自身的性质，而且收到position的影响，这个position对他们的影响是一致的，服从beta分布，里面有alpha，beta两个参数需要我们求解，或者说设置。
 22 | 
 23 |    而求解这个beta分布里面的参数，我们用到的方法是最大边缘似然概率，边缘似然概率指的是观测变量的概率分布，我们可以画出这样的概率图：
 24 | 
 25 |    ![ctr_1](/Users/kellydou/Desktop/ctr_1.png)
 26 | 
 27 |    这样我们的观测变量就可以表示成积分的形式，然后将似然函数对alpha，beta求导，就可以得到alpha，beta的迭代形式。
 28 | 
 29 |    ![ctr_2](/Users/kellydou/Desktop/ctr_2.png)
 30 | 
 31 | #### 1.2.2 特征选择方法
 32 | 
 33 | ### 1.3 模型简介
 34 | 
 35 | 在广告预估中，我们用的比较多的是简单的lr模型，但是这种方法需要大量的特征工程，因为lr模型只能够得到模型的一阶特征，组合特征必须要人为的进行特征工程。为了能够得到模型的二阶特征，甚至是高阶特征，大神们就想出了其他的各种模型，例如fm，能够学到二阶特征，例如dnn，能够学到模型的高阶特征。下面这个表格就展示了各种学习模型的融合。
 36 | 
 37 | |       模型       | 组合方式                 |             输入层             |                embedding层                |                  Deep部分                  |
 38 | | :------------: | -------------------- | :-------------------------: | :--------------------------------------: | :--------------------------------------: |
 39 | |   wide&deep    | 线性层+ deep层           | sparse features：one-hot，离散化 |                  指定大小的                   | 所有field特征都one-hot后再经由一个embedding层后得到一个词向量 |
 40 | |      PNN       | Deep层                |                             | 用FM的二阶权重做输入层到embedding的权重，embedding向量的大小为field-num * dim | <u>**deep的第一层与product层相连，product层包括线性，两两内积，偏置**</u> |
 41 | |     DeepFM     | **<u>线性层+Deep层</u>** |                             | 用FM的二阶权重做输入层到embedding的权重，embedding向量的大小为field-num * dim |            deep层从embedding层学习            |
 42 | | ***FFM&Deep*** | ***线性层+Deep层***      |                             |         ***用FFM形成embedding矩阵***          | ***deep的第一层与product层相连，product层包括线性，两两内积，偏置*** |
 43 | 
 44 | 在用dnn与线性模型做融合的时候，我们需要注意的就是embediing层，在这样的输入中，输入的都是稀疏向量。在embedding层，我们将输入的稀疏向量转化为比较密集的向量或者是矩阵。例如，我们可以利用fm的转换将输入转化为filed-cnt * dim的向量，也可以利用ffm的思想将输入转化为feild-cnt * feild-cnt * dim的矩阵。
 45 | 
 46 | ### 1.3 模型训练
 47 | 
 48 | | 模型                             | 数据前期处理                                   | 模型使用                                     | 效果                                       |
 49 | | :----------------------------- | ---------------------------------------- | ---------------------------------------- | ---------------------------------------- |
 50 | | 非线性模型：使用连续特征，xgboost ，lightGBM | 将原始特征使用历史点击率进行代替，去掉原始特征                  | 1.xgb中使用类别特征必须要对类别特征进行编码，要把类别特征转化为连续特征，但是lightGBM是可以处理离散特征的，这和在xgb中使用one-hot编码的效果是一样的                             2. xgboost和lightGBM都是基于gbdt的，然后由于xgboost训练速度太慢，我们就用训练速度比较快的lightGBM做特征工程，然后将训练出来的特征。 | 单模型0.103左右                               |
 51 | | 线性模型：使用离散特征，ffm                | 将比率等连续特征使用log，然后求区间进行离散化处；还可以使用xgboost预先训练进行 | ffm中比较重要的调参就是隐变量参数，正则系数，还有学习速率；我们在这次比赛中只调节了隐变量参数，和正则项。在训练过程中发现ffm很容易过拟合，因此我们把正则项设置的很大，然后把学习速率调节的非常小。 | 单模型0.103～0.104之间                         |
 52 | | 线性模型     ftrl                  | 数据离散化处理：将所有的数字特征用xgboost做离散化处理，然后使用原始id特征和xgb叶子特征进行lr训练 | 使用了组合id特征，原始id特征，还有gbdt的叶子特征，但是模型        | 模型训练出来，差距比较大，并且预测结果概率偏低。                 |
 53 | | 非线性模型，神经网络模型：wide&deep模型       | 线性部分输入：离散特征，组合特征；deep部分输入：组合特征，连续特征，     | deep部分的embedding层有两种embedding的方法，一种是用一个长向量对所有的输入进行embedding，只有一个词向量，另一种方法是对每个field有一个词向量，针对这个想法，我们可以把fm以及ffm的参数用来做得到词向量的权重，这也是后来deep ffm模型的重要参考之一。 | 模型训练出来是0.104左右，，，可以使用fm或者ffm模型对embedding层进行简化 |
 54 | 
 55 | 面试中遇到的问题：
 56 | 
 57 | 1. lr为什么使用离散特征会好一些？
 58 | 
 59 |    1. 离散特征的增加和减少都很容易，易于模型的快速迭代；
 60 |    2. 稀疏向量内积乘法运算速度快，计算结果方便存储，容易扩展；
 61 |    3. 离散化后的特征对异常数据有很强的鲁棒性，模型会更稳定：比如一个特征是年龄>30是1，否则0。如果特征没有离散化，一个异常数据“年龄300岁”会给模型造成很大的干扰；
 62 |    4. 逻辑回归属于广义线性模型，表达能力受限；单变量离散化为N个后，每个变量有单独的权重，相当于为模型引入了非线性，能够提升模型表达能力，加大拟合；
 63 |    5. 离散化后可以进行特征交叉，由M+N个变量变为M*N个变量，进一步引入非线性，提升表达能力；
 64 |    6. 特征离散化以后，起到了简化了逻辑回归模型的作用，降低了模型过拟合的风险。李沐曾经说过：模型是使用离散特征还是连续特征，其实是一个“海量离散特征+简单模型” 同 “少量连续特征+复杂模型”的权衡。既可以离散化用线性模型，也可以用连续特征加深度学习。
 65 | 
 66 | 2. Ftrl的原理，实践表现？为什么表现不好？
 67 | 
 68 |    http://www.datakit.cn/blog/2016/05/11/ftrl.html#工程tricks
 69 | 
 70 |    ftrl是将w的梯度求解过程转化成了一个优化算法，优化目标函数中包括：该方向上的梯度的累积和做稀疏的一次项，以及一个L1，L2正则项，还包括每次迭代过程不能差距太大，评估所求W与前t次W的距离和。
 71 | 
 72 |    其中的学习速率也是自适应的，每一次的学习速率于梯度的累积平方和成反比。
 73 | 
 74 |    在ftrl的实现中，除了更新每个维度上的w，我们还有两个变量需要保存，一个是z，用来保存梯度的累积和-以及之前该维度上的w；还有一个变量n，用来保存梯度的下降累积。每次迭代时，先计算g与z的更新，然后根据z的大小来更新w。
 75 | 
 76 |    表现不好：特征只是用了原始特征和组合特征，而且没有调参，，其中的alpha，beta，L1，L2正则系数都没有调整。
 77 | 
 78 |    beta的参数不用调整，但是初始学习速率的alpha 设置为0.1。
 79 | 
 80 | 3. ffm模型怎样于deep模型进行融合？有怎样的理论基础？效果怎么样？
 81 | 
 82 |    ffm于deep模型的融合是将整个模型分成三个部分，有线性部分，ffm部分，deep部分；这三个层共享输入，输入数据是filed：feature：value这样的模式。
 83 | 
 84 |    在线性部分，直接对数据进行one-hot编码，然后设置权重；
 85 | 
 86 |    在ffm部分和deep部分共享一个embedding层，设置w为field_cnt * field_cnt *dim, 然后每一个field对应一个embedding的矩阵，矩阵大小为field_cnt * dim；
 87 | 
 88 |    ffm部分，直接输出加上，deep部分连接上全链接层。
 89 | 
 90 |    最后经三个结果进行叠加，再通过sigmoid激活函数输出。
 91 | 
 92 |    效果：只用了原始特征，线下 0.103左右，0.105～0.106，我记得lr的baseline是0.107还是0.108来着。。。
 93 | 
 94 |    调参：使用了3层神经网络，128，64层。使用relu激活函数，用了3个epoch，每次epoch对数据进行random，然后3次epoch求平均，batch size 是 1000，因为只使用了2天的数据进行训练。
 95 | 
 96 | 4. 有哪些可以改进的地方？
 97 | 
 98 |    一是特征工程上的优化
 99 | 
100 |    二是模型上的优化，deep层还有很多可以防止过拟合的方法没有使用。
101 | 
102 |    三是增加数据，使用最近7天的数据进行训练，可能数据增加到一定程度以后再增加也没有意义了。实现数据的并行处理和学习。
103 | 
104 | ### 1.4 模型融合
105 | 
106 | 将两个结果比较接近的模型进行了融合：xgb结果，ffm结果，还有wide&deep的模型结果。
107 | 
108 | ### 1.5 问题存在
109 | 
110 | 1. 特征工程中还有一些想法：
111 | 2. 训练出来的ftrl模型效果很差：
112 | 3. 不同的模型有不同的特性，对不同种类的特征得到的结果不一样，在模型融合的时候不能仅仅是模型融合的过程，还要考虑不同的模型使用不同的特征
113 |    1. 例如lr比较适合用离散的特征，这时候就不能将那些连续的数字特征直接放到模型里面，而是应该先采取离散化的方式，例如log处理，
114 |    2. xgboost处理离散特征需要one-hot。
115 |    3. ftrl训练时间太长，因为是一个数据一个数据进行训练的。但是因为每一次w的更新都是基于上一个w的迭代结果。好像google的那篇论文里面实现了
116 | 4. 没有探索使用deep模型 + ffm 模型
117 | 
118 | ## 2 kaggle 比赛项目
119 | 
120 | 3.2.1 自然语言处理相关算法
121 | 
122 | 分词算法,jieba
123 | 
124 | 主题模型相关算法
125 | 
126 | ## 3.机器学习实践技巧
127 | 
128 | 4.1 数据异常点检测
129 | 
130 | 异常点检测处理方式与聚类很类似，我们
131 | 
132 | 4.2 数据归一化的重要性
133 | 
134 | 4.2 数据过拟合处理方式
135 | 
136 | 4.3 特征工程，特征选择技巧
137 | 
138 | 4.4 MapReduce 以及 spark技巧
139 | 
140 | 


--------------------------------------------------------------------------------
/机器学习/img/approximate.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/机器学习/img/approximate.png


--------------------------------------------------------------------------------
/机器学习/img/column_block.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/机器学习/img/column_block.png


--------------------------------------------------------------------------------
/机器学习/img/exact_greedy.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/机器学习/img/exact_greedy.png


--------------------------------------------------------------------------------
/机器学习/img/goss.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/机器学习/img/goss.png


--------------------------------------------------------------------------------
/机器学习/img/greedy_bundle.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/机器学习/img/greedy_bundle.png


--------------------------------------------------------------------------------
/机器学习/img/l2_loss.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/机器学习/img/l2_loss.png


--------------------------------------------------------------------------------
/机器学习/img/leaf-wise.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/机器学习/img/leaf-wise.png


--------------------------------------------------------------------------------
/机器学习/img/level-wise.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/机器学习/img/level-wise.png


--------------------------------------------------------------------------------
/机器学习/img/merge.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/机器学习/img/merge.png


--------------------------------------------------------------------------------
/机器学习/img/momentum.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/机器学习/img/momentum.png


--------------------------------------------------------------------------------
/机器学习/img/momentum_algo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/机器学习/img/momentum_algo.png


--------------------------------------------------------------------------------
/机器学习/img/practice.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/机器学习/img/practice.png


--------------------------------------------------------------------------------
/机器学习/img/regularization.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/机器学习/img/regularization.png


--------------------------------------------------------------------------------
/机器学习/img/sparsity.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/机器学习/img/sparsity.png


--------------------------------------------------------------------------------
/机器学习/img/theory.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/机器学习/img/theory.png


--------------------------------------------------------------------------------
/机器学习/lightGBM.md:
--------------------------------------------------------------------------------
 1 | LightGBM是微软开源的一个GBDT算法的高效实现库，在XGBoost的基础上进行改良，在训练效果接近的情况下，运行速度相比XGBoost有大幅提升。
 2 | 
 3 | 在GBDT算法中，最消耗时间的步骤是寻找决策树的切分点。传统GBDT算法使用预排序（pre-sorted）算法，将特征值排序，遍历所有可能的切分点，如果有n个特征，m个样本，这样做的时间复杂度为O(mn)。
 4 | 
 5 | 除了预排序算法，XGBoost还支持直方图（histogram）算法，将数据按特征值划分，用一个个桶（bin）储存，切分点的可能选择为桶的划分点。如果有k个桶，则时间复杂度为O(kn)，k << m。
 6 | 
 7 | ### Gradient-based One Side Sampling
 8 | LightGBM在直方图算法的基础上，提出了Gradient-based One Side Sampling（GOSS），目的是减少寻找切分点时需要的样本数，从而降低算法的时间复杂度。
 9 | ![](img/goss.png)
10 | 对目标函数二阶泰勒展开后，每个样本会有梯度。GOSS算法选择一个阈值，选取所有梯度大于阈值的样本，随机采样部分梯度小于阈值的样本，组成一个子集，在计算切分增益时只考虑上述子集中的样本。[LightGBM论文]()中提供了详细的数学证明。
11 | 
12 | ### Exclusive Feature Bundling
13 | LightGBM还提出了Exclusive Feature Bundling（EFB），用来减少切分点选择时要遍历的特征数。实际应用中，高维的数据往往是稀疏的，比如有些特征几乎不会同时取非零值，可以把这样的特征可以组合成一个bundle，选择切分点时，只需要遍历各个bundle。
14 | 
15 | LightGBM证明了寻找这样的feature bundle的问题可以由图着色问题（graph color problem）退化而来。一组bundle feature相当于图着色问题中一组相同颜色的节点。此问题是NP-hard，因此用贪心算法近似求解。![](img/greedy_bundle.png)
16 | 
17 | 对于一组bundle features，LightGBM提出一种merge算法，将bundle组成一个feature，核心思想是通过加offset使每个feature的取值范围不相交。
18 | ![](img/merge.png)
19 | 
20 | ### 决策树生成方式
21 | XGBoost采用level-wise的分裂方法，生成的决策树是满二叉树，即每一层的每个节点都需要分裂，增益较小的节点也会分裂。
22 | ![](img/level-wise.png)
23 | 
24 | LightGBM采用Leaf-wise的分裂方法，考虑所有叶子节点(不同层)，选择增益最大的进行分裂。这样做很容易使决策树很深，陷入过拟合。因此LightGBM也提供了max_depth参数来控制最大层数。
25 | ![](img/leaf-wise.png)


--------------------------------------------------------------------------------
/机器学习/xgboost.md:
--------------------------------------------------------------------------------
 1 | xgboost是一种tree boosting算法，可以看作在GBDT的基础上改进了目标函数、切分点查找、缺失值处理、并行化等方面。
 2 | 
 3 | ### 原理
 4 | 首先，xgboost本质上是一个加法模型，通过Gradient Boosting每一步贪心地计算出一个模型（最小化目标函数），最后加在一起得到最终模型。
 5 | 
 6 | ![](http://latex.codecogs.com/gif.latex?%24%24%5Cbegin%7Balign%7D%5Chat%7By%7D_i%5E%7B%280%29%7D%20%26%3D%200%5C%5C%20%5Chat%7By%7D_i%5E%7B%281%29%7D%20%26%3D%20f_1%28x_i%29%20%3D%20%5Chat%7By%7D_i%5E%7B%280%29%7D%20&plus;%20f_1%28x_i%29%5C%5C%20%5Chat%7By%7D_i%5E%7B%282%29%7D%20%26%3D%20f_1%28x_i%29%20&plus;%20f_2%28x_i%29%3D%20%5Chat%7By%7D_i%5E%7B%281%29%7D%20&plus;%20f_2%28x_i%29%5C%5C%20%26%5Cdots%5C%5C%20%5Chat%7By%7D_i%5E%7B%28t%29%7D%20%26%3D%20%5Csum_%7Bk%3D1%7D%5Et%20f_k%28x_i%29%3D%20%5Chat%7By%7D_i%5E%7B%28t-1%29%7D%20&plus;%20f_t%28x_i%29%20%5Cend%7Balign%7D%24%24)
 7 | 
 8 | $\hat{y}_i^{(t)}$是第t步的预测值，从上式可以看到，是由第t步的模型预测值，加上之前所有模型预测值之和。
 9 | 
10 | 要确定第t步的模型，通过最小化目标函数得到。定义目标函数为：
11 | 
12 | ![](http://latex.codecogs.com/gif.latex?%24%24%5Ctext%7Bobj%7D%5E%7B%28t%29%7D%20%26%20%3D%20%5Csum_%7Bi%3D1%7D%5En%20l%28y_i%2C%20%5Chat%7By%7D_i%5E%7B%28t%29%7D%29%20&plus;%20%5Csum_%7Bi%3D1%7D%5Et%5COmega%28f_i%29%20%5C%5C%20%26%20%3D%20%5Csum_%7Bi%3D1%7D%5En%20l%28y_i%2C%20%5Chat%7By%7D_i%5E%7B%28t-1%29%7D%20&plus;%20f_t%28x_i%29%29%20&plus;%20%5COmega%28f_t%29%20&plus;%20constant%20%24%24)
13 | 
14 | l是损失函数，常用的是均方误差，也可以是任意二次可微的函数。与GBDT的目标函数相比，xgboost多了正则化项，T为模型的叶子数，w为每个叶子节点的权重，也就是每个叶子节点的输出值。
15 | $$\Omega(f) = \gamma T + \frac{1}{2}\lambda \sum_{j=1}^T w_j^2$$
16 | 
17 | 对目标函数做二阶泰勒展开，得到：
18 | $$\text{obj}^{(t)} = \sum_{i=1}^n [l(y_i, \hat{y}_i^{(t-1)}) + g_i f_t(x_i) + \frac{1}{2} h_i f_t^2(x_i)] + \Omega(f_t) + constant$$
19 | 其中
20 | 
21 | ![](http://latex.codecogs.com/gif.latex?%24%24%5Cbegin%7Balign%7Dg_i%20%26%3D%20%5Cpartial_%7B%5Chat%7By%7D_i%5E%7B%28t-1%29%7D%7D%20l%28y_i%2C%20%5Chat%7By%7D_i%5E%7B%28t-1%29%7D%29%5C%5C%20h_i%20%26%3D%20%5Cpartial_%7B%5Chat%7By%7D_i%5E%7B%28t-1%29%7D%7D%5E2%20l%28y_i%2C%20%5Chat%7By%7D_i%5E%7B%28t-1%29%7D%29%20%5Cend%7Balign%7D%24%24)
22 | 
23 | 去除常数项后，得到表达式：
24 | 
25 | ![](http://latex.codecogs.com/gif.latex?%24%24%5Cbegin%7Balign%7D%5Ctext%7Bobj%7D%5E%7B%28t%29%7D%20%26%5Capprox%20%5Csum_%7Bi%3D1%7D%5En%20%5Bg_i%20w_%7Bq%28x_i%29%7D%20&plus;%20%5Cfrac%7B1%7D%7B2%7D%20h_i%20w_%7Bq%28x_i%29%7D%5E2%5D%20&plus;%20%5Cgamma%20T%20&plus;%20%5Cfrac%7B1%7D%7B2%7D%5Clambda%20%5Csum_%7Bj%3D1%7D%5ET%20w_j%5E2%5C%5C%20%26%3D%20%5Csum%5ET_%7Bj%3D1%7D%20%5B%28%5Csum_%7Bi%5Cin%20I_j%7D%20g_i%29%20w_j%20&plus;%20%5Cfrac%7B1%7D%7B2%7D%20%28%5Csum_%7Bi%5Cin%20I_j%7D%20h_i%20&plus;%20%5Clambda%29%20w_j%5E2%20%5D%20&plus;%20%5Cgamma%20T%20%5Cend%7Balign%7D%24%24)
26 | 
27 | 这里$I_j$表示被分到第j个叶子节点的样本集合。进一步令$G_j = \sum_{i\in I_j} g_i$，$H_j = \sum_{i\in I_j} h_i$，代入上式，最终表达式为$$\text{obj}^{(t)} = \sum^T_{j=1} [G_jw_j + \frac{1}{2} (H_j+\lambda) w_j^2] +\gamma T$$
28 | 每个叶子节点是独立的，因此根据二次函数极点的知识，可以确定使目标函数最小的每个叶子节点权重w和目标函数的最小值为：$$\begin{split}w_j^\ast = -\frac{G_j}{H_j+\lambda}\\
29 | \text{obj}^\ast = -\frac{1}{2} \sum_{j=1}^T \frac{G_j^2}{H_j+\lambda} + \gamma T
30 | \end{split}$$
31 | 此时，目标函数最小值只跟损失函数的一阶、二阶导数和叶子数有关，与叶子节点权重无关。推导到这里，如果给定树的结构，那就可以用目标函数来衡量这个树的好坏。现在就需要用这个目标函数来确定树的结构（如何分裂）。
32 | 
33 | ### 切分算法
34 | 目的是要找到一个切分点，将样本分为左右两部分（L和R）。类似CART决策树的基尼指数，xgboost根据上文推导的目标函数，定义切分的增益:
35 | $$Gain = \frac{1}{2} \left[\frac{G_L^2}{H_L+\lambda}+\frac{G_R^2}{H_R+\lambda}-\frac{(G_L+G_R)^2}{H_L+H_R+\lambda}\right] - \gamma$$
36 | $\gamma$是常数项，如果Gain小于某个常数，就不分裂，相当于决策树中的剪枝。因此xgboost不需要再进行剪枝来正则化。
37 | 
38 | 一般情况下，与GBDT类似，遍历所有特征和所有可能的切分点（如果是连续特征，排序后取两个相邻值的中点）。这种遍历的算法只支持单个机器，不支持分布式。
39 | 
40 | ![](img/exact_greedy.png)
41 | 
42 | 如果可能的切分点太多，无法遍历的情况下，xgboost提出了一种近似算法，根据特征数值分布的比例，将样本分为不同的bucket（通常分成32-100份），每个bucket之间作为可能的切分点。按比例划分方法：按照特征值排序后，以二阶导数累加比例划分
43 | 
44 | ![](img/approximate.png)
45 | 
46 | 实际应用中，数据往往有缺失值，或是数据是稀疏的，针对这个情况，xgboost提出了sparsity-aware的切分点寻找算法。对于每个特征，根据分布找到可能的切分点后，分别计算把缺失值样本放到左子节点和右子节点，学习到最优的切分点和缺失值的分类方向。
47 | 
48 | ![](img/sparsity.png)
49 | 
50 | #### 权重缩减和列抽样
51 | xgboost还使用了两种方法来防止过拟合。
52 | 
53 | 1. Shrinkage：每完成一次迭代后，会将叶子节点的权重乘以一个系数，相当于学习速率（xgboost中的eta），这样能削弱每棵树的影响。
54 | 2. Column Subsampling：类似于随机森林，随机选择部分特征（column），即降低了过拟合，又减少了计算量。
55 | 
56 | ### 并行化
57 | xgboost支持并行，从原理上来说，加法模型本身是不能并行的，用前向分步算法每一步学习一个模型，所以并行是在单一模型的学习这个角度实现的。
58 | 
59 | 训练的时候，最消耗时间的是将数据按特征大小排序。xgboost以block的形式储存数据，每个block中的数据会按照特征排序，用一个指针由特征值指向数据序号，如下图所示。
60 | ![](img/column_block.png)
61 | 这样在训练之前预排序，之后就可以复用，不需要再排序。如果切分算法是遍历所有可能切分点，那所有训练数据都放在一个block中。如果切分用的是近似算法，可以使用多个block来储存，每个block中是训练集的一个独立子集，因此多个block可以并行（分布式）处理。另外，block中每个特征（column）都是排序过的，多个特征的处理也可以并行。
62 | 
63 | block的数量选择要考虑两方面的因素，block数量多，则每个block需要处理的数据少，相应的线程利用率低，并行的效率低；block数量少，则每个block数据量大，CPU缓存命中率低。经验上，每个block储存$2^{16}$个样本比较好，平衡了CPU缓存和并行效率。
64 | 
65 | xgboost在内存中计算和从硬盘读取block数据是并行的。由于硬盘IO的速度过慢，影响总的效率，xgboost提出两个方法加速：一是压缩block，通过解压缩来换取更少的硬盘IO；二是将数据储存到多个硬盘上（如果有多个硬盘），一个读数据的线程从不同硬盘读取数据到内存中，训练线程则从相应的内存中进行计算。
66 | 
67 | 参考文献：
68 | 
69 | 1. [Introduction to Boosted Trees](https://xgboost.readthedocs.io/en/latest/model.html)
70 | 2. [Chen T, Guestrin C. Xgboost: A scalable tree boosting system[C]//Proceedings of the 22nd acm sigkdd international conference on knowledge discovery and data mining. ACM, 2016: 785-794.](https://dl.acm.org/citation.cfm?id=2939785)
71 | 3. [知乎：机器学习算法中GBDT和XGBOOST的区别有哪些？](https://www.zhihu.com/question/41354392/answer/98658997)
72 | 


--------------------------------------------------------------------------------
/机器学习/优化方法.md:
--------------------------------------------------------------------------------
 1 | ### 梯度下降
 2 | 梯度下降（Gradient Descent）是深度学习中最常见的优化方法。每一步计算损失函数对参数的梯度，然后沿着梯度的负方向更新参数。![](http://latex.codecogs.com/gif.latex?%24%24%5CTheta%20%3D%20%5CTheta%20-%5Calpha%20%5Ccdot%20%5Ctriangledown_%5CTheta%20J%28%5CTheta%20%29%24%24)
 3 | 
 4 | 直观上就是从最陡峭的方向下山。
 5 | ![](https://images2015.cnblogs.com/blog/1042406/201610/1042406-20161017221342935-1872962415.png)
 6 | 使用梯度下降算法时，如果选用所有数据计算梯度，计算量太大，如果随机选择单个训练数据计算，则迭代次数会非常大。实际应用中，会选择一个适当的batch size（16-512）来计算梯度。
 7 | 
 8 | 当目标函数为凸函数时，梯度下降的解是全局最优解。一般情况下，不能保证是全局最优解。
 9 | ### Momentum
10 | 梯度下降只考虑了当前的梯度，Momentum算法使用指数加权平均，把之前的历史梯度和当前梯度融合，确定最终的梯度方向。这样做有平均的效果，错误的梯度方向往往是随机的，通过平均可以消除这样的梯度分量，能够更快收敛，并有一定摆脱局部最优的能力。
11 | ![](img/momentum.png)
12 | Momentum具体算法：
13 | ![](img/momentum_algo.png)
14 | 两个超参数$\alpha$和$\beta$分别表示学习率和加权平均系数。
15 | 
16 | ### Adagrad
17 | Momentum和梯度下降算法中学习率始终不变，Adagrad算法可以根据梯度调整学习率，适用于稀疏场景。如果某些取值在样本中出现的很少（例如，词向量中的低频词、推荐或广告场景下onehot后特别稀疏的特征），对应的参数被学习的次数相对很少，就需要对这些参数调大学习率。
18 | 算法如下：
19 | 
20 | 1. 首先计算出梯度g
21 | 2. 计算 $\boldsymbol{s} \leftarrow \boldsymbol{s} + \boldsymbol{g} \odot \boldsymbol{g}.$ s初始化为0
22 | 3. 调整学习率 $\boldsymbol{g}^\prime \leftarrow \frac{\eta}{\sqrt{\boldsymbol{s} + \epsilon}} \odot \boldsymbol{g},$
23 | 4. 更新 $\boldsymbol{x} \leftarrow \boldsymbol{x} - \boldsymbol{g}^\prime.$
24 | 
25 | 从公式中可以看到，基础学习率为$\eta$，如果梯度在某个方向下降很快，即某个分量很大，则变量s中相应的分量也大，导致这个方向的学习率下降很快，防止跳过最优解。
26 | 
27 | ### RMSProp
28 | RMSProp是Adagrad和momentum的结合。在Adagrad的基础上，考虑部分历史梯度，加入momentum算法中的指数加权平均。Adagrad中$s$随时间递增，导致学习率趋向于0。因此，RMSProp做了改进，只考虑一定时间窗口内的历史梯度。
29 | 
30 | 1. $\boldsymbol{s} \leftarrow \gamma \boldsymbol{s} + (1 - \gamma) \boldsymbol{g} \odot \boldsymbol{g}.$
31 | 2. $\boldsymbol{g}^\prime \leftarrow \frac{\eta}{\sqrt{\boldsymbol{s} + \epsilon}} \odot \boldsymbol{g},$
32 | 3. $\boldsymbol{x} \leftarrow \boldsymbol{x} - \boldsymbol{g}^\prime.$
33 | 
34 | Adagrad和RMSProp都是根据梯度的平方（大小）来调整每个分量上的学习率。
35 | 
36 | ### Adam
37 | Adam算法结合了momentum和RMSProp，是目前最好的优化算法之一。
38 | 
39 | 1. 与momentum类似计算 ![](https://latex.codecogs.com/gif.latex?%5Cboldsymbol%20v_%7Bt%7D%20%5Cleftarrow%20%5Cbeta_1%20%5Cboldsymbol%20v_%7Bt-1%7D%20&plus;%20%281-%5Cbeta_1%29%20%5Cboldsymbol%20g_t)
40 | 2. 与RMSProp类似计算 ![](http://latex.codecogs.com/gif.latex?%5Cboldsymbol%7Bs%7D_t%20%5Cleftarrow%20%5Cbeta_2%20%5Cboldsymbol%7Bs%7D_%7Bt-1%7D%20&plus;%20%281%20-%20%5Cbeta_2%29%20%5Cboldsymbol%7Bg%7D_t%20%5Codot%20%5Cboldsymbol%7Bg%7D_t)
41 | 3. 修正误差，使过去各时刻的权重$\beta^t$和为1. $\hat{\boldsymbol{v}}_t \leftarrow \frac{\boldsymbol{v}_t}{1 - \beta_1^t},$, $\hat{\boldsymbol{s}}_t \leftarrow \frac{\boldsymbol{s}_t}{1 - \beta_2^t}.$
42 | 4. 得到最终梯度 $\boldsymbol{g}_t^\prime \leftarrow \frac{\eta \hat{\boldsymbol{v}}_t}{\sqrt{\hat{\boldsymbol{s}}_t + \epsilon}},$
43 | 5. 更新 ![](http://latex.codecogs.com/gif.latex?%5Cboldsymbol%7Bx%7D_t%20%5Cleftarrow%20%5Cboldsymbol%7Bx%7D_%7Bt-1%7D%20-%20%5Cboldsymbol%7Bg%7D_t%5E%5Cprime)
44 | 
45 | 
46 | ### 牛顿法、拟牛顿法
47 | 牛顿法和拟牛顿法是另一类求解优化问题的算法。如果目标函数二次可微，函数f(x)取极小值的必要条件是导数$f\prime(x)=0$，对f(x)泰勒二次展开，得到![](http://latex.codecogs.com/gif.latex?f%5Cleft&space;(&space;x&space;%5Cright&space;)=f%5Cleft&space;(&space;x_k&space;%5Cright&space;)+%7Bf%7D%27%5Cleft&space;(&space;x_k&space;%5Cright&space;)%5Cleft&space;(&space;x-x_k&space;%5Cright&space;)+%5Cfrac%7B1%7D%7B2%7D%7Bf%7D%27%27%5Cleft&space;(&space;x_k&space;%5Cright&space;)%5Cleft&space;(&space;x-x_k&space;%5Cright&space;)%5E2)
48 | 
49 | 求导并令其等于0，得到:
50 | 
51 | ![](http://latex.codecogs.com/gif.latex?%7Bf%7D%27%5Cleft&space;(&space;x_k&space;%5Cright&space;)+%7Bf%7D%27%27%5Cleft&space;(&space;x_k&space;%5Cright&space;)%5Cleft&space;(&space;x-x_k&space;%5Cright&space;)=0)
52 | 
53 | 解得:
54 | 
55 | ![](http://latex.codecogs.com/gif.latex?x=x_k-%5Cfrac%7B%7Bf%7D%27%5Cleft&space;(&space;x_k&space;%5Cright&space;)%7D%7B%7Bf%7D%27%27%5Cleft&space;(&space;x_k&space;%5Cright&space;)%7D)
56 | 
57 | 扩展到高维情况，一阶导数用梯度代替，二阶导数的倒数用Hessian矩阵的逆矩阵代替。牛顿法要收敛，Hessian矩阵必须正定。牛顿法利用了二阶偏导数，其收敛速度比梯度下降类算法快，但是求Hessian逆矩阵的计算量往往非常大，因此出现[拟牛顿法](https://zh.wikipedia.org/wiki/%E6%93%AC%E7%89%9B%E9%A0%93%E6%B3%95)，近似计算Hessian逆矩阵，如DFP算法、BFGS算法等。
58 | 
59 | ### 启发式算法
60 | 遗产算法、粒子群算法等启发式算法（Heuristic Algorithm）也可以解优化问题。启发式算法往往是模拟自然界生物的行为，在可接受的计算成本内取搜索最优解，但不一定保证收敛。
61 | 
62 | 以遗传算法为例，在解空间内随机生成一组解，作为初始种群。种群之间进行交叉、变异，产生新的一组解。选择一个适应度函数来评价解的优劣，按概率进行选择。如果第i个个体的适应度函数为$f(x_i)$,则它被选择到下一个种群的概率为$\frac {f(x_i)}{\sum_{n=1}^N f(x_n)}$。如此不断迭代直到收敛。
63 | 
64 | 目标函数$f(x)=x^2$求最小值，可以令适应度函数为$\frac 1 {x^2}$。考虑两个二进制数[1000,1110], 交叉操作可以将后两位交换，生成[1010,1100]; 变异操作可以将任意一位取反，以最后一位为例，则生成[1001,1111]。
65 | 


--------------------------------------------------------------------------------
/机器学习/决策树.md:
--------------------------------------------------------------------------------
 1 | 决策树是一个基础的模型，也是许多集成算法的基学习器。决策树即可以解决分类问题，也可以解决回归问题。决策树是树状结构，每个非叶子节点表示一个特征或属性，其分叉表示在该属性上的划分，每个叶子节点表示一个分类。从根节点到叶子节点的路径对应了一个决策序列，下图是周志华“西瓜书”的决策树例子。
 2 | ![周志华“西瓜书”的决策树例子](https://pic3.zhimg.com/80/v2-39d109b46ea4f34d5efbf67edc11d57d_hd.jpg)
 3 | 
 4 | 决策树的生成：不断递归找到最优划分属性和划分点，直到：
 5 | 
 6 | 1. 当前节点的样本全属于同一类别
 7 | 2. 当前节点的样本所有属性值都相同
 8 | 3. 当前节点样本集为空
 9 | 
10 | 生成决策树的核心是找到最优划分属性及其划分点，有多种方法。其中ID3、C4.5算法生成的是多叉树（如果有离散特征），CART算法为二叉树。
11 | 
12 | ### 信息增益
13 | 衡量一个集合中样本纯度的一种指标是信息熵，假设集合D中有K个类：
14 | $$Ent(D)= -\sum_{k=1}^K p_klog_2p_k$$
15 | 
16 | 熵越大，数据越混乱，纯度越小。
17 | 决策树希望划分之后能减小熵，也就是划分前后之差越大越好，因此用信息增益来表示。假设样本集合D，属性a有V个可能取值，$D^v$表示属性a取值为v的样本子集，则有信息增益：
18 | $$Gain(D,a)=Ent(D) - \sum_{v=1}^V \frac {|D^v|}{|D|}Ent(D^v)$$
19 | 
20 | 对所有属性，遍历计算每一个的信息增益，挑选最大的作为最优划分属性。这是ID3算法的选择方法。
21 | 
22 | ### 信息增益比
23 | 考虑到信息增益会偏向取值较多的属性，因此C4.5算法引入信息增益比：
24 | $$Gain_ratio(D,a) = \frac {Gain(D,a)}{IV(a)}$$
25 | $$IV(a) = -\sum_{v=1}^{V}\frac {|D^v|}{|D|} log_2 \frac {|D^v|}{|D|}$$
26 | 
27 | ### 基尼指数
28 | 基尼指数表示集合的不确定性，CART决策树在分类时使用基尼指数最小的属性作为最优划分属性。
29 | $$Gini(D)=\sum_{k=1}^K p_k(1-p_k) = 1 - \sum_{k=1}^K p_k^2$$
30 | 考虑属性a的V种取值,则有：
31 | $$Gini(D,a) = \sum_{v=1}^V \frac {|D^v|}{|D|}Gini(D^v)$$
32 | 
33 | ### 连续值
34 | 以上只考虑了属性是离散的，实际数据往往有连续的属性值。对于连续值，可以选择一个切分点，小于切分点的为一类，大于切分点的为另一类。切分点的可能选择为任意两个相邻属性值的平均值$\frac {a_i + a_{i+1}}2$。遍历所有可能的切分点，同样用信息增益（比）来决定最优切分点。
35 | 
36 | ### 缺失值
37 | 实际数据集中，有的样本在某些属性上的数据会缺失。先给每个样本分配一个权重$w_i$,令$r_v=\frac {\sum_{\tilde{D}^v} w_i} {\sum_{D}wi}$ ，即某属性无缺失且取值为v的样本权重和/所有样本权重和
38 | 
39 | 在选择划分属性时，只要考虑该属性不缺失的样本子集。
40 | 若某个样本在划分属性上数据缺失，将样本同时划入所有子节点，改变权重为$r_vw_i$。从概率论的角度来说，将一个样本以不同概率划入不同节点。
41 | 
42 | ### 最小二乘回归树
43 | 决策树可以处理回归问题，即输出一个值而不是分类，核心思想是最小二乘法。对于每个切分变量j和切分点s,集合D可以被切分成两个子集R1,R2，相应的样本平均值为c1,c2。遍历所有属性j，每个属性可以求解切分点s,用下式选择最优切分(j,s)：
44 | $$min[\sum_{x_i\in R_1}(y_i-c_1)^2 + \sum_{x_i\in R_2}(y_i-c_2)^2]$$
45 | 每个节点的输出值就是该节点中所有样本的平均值。
46 | 
47 | 
48 | 
49 | ### 剪枝
50 | 决策树的生成是不断递归的直到不能继续分裂，意味着对训练数据拟合的好而泛化能力弱，因此通过剪枝的方法来简化决策树，相当于正则化，增强模型的泛化能力。
51 | 
52 | 剪枝时考虑决策树的整体代价函数。设叶子节点个树为$|T|$，每个叶子节点t有属于k类的$N_{tk}$个样本，则代价函数为：
53 | $$C(T) = \sum_{t=1}^{|T|}N_tH_t(T) + \alpha|T|$$
54 | $$H_t(T) = -\sum_{k}\frac{N_{tk}}{N_t}log\frac{N_{tk}}{N_t}$$
55 | 
56 | 代价函数结合了训练数据的误差和决策树的复杂度，常数$\alpha$控制两者的trade off。
57 | 剪枝即最小化代价函数，由底向上，考虑去掉每个叶子节点能否降低代价函数值，直到代价函数不能再减小。
58 | 
59 | ### 多变量决策树
60 | 上述决策树模型都只考虑切分单个属性，这样的结果是决策边界都是平行于坐标轴的。如果要有斜的决策边界，就要考虑多变量决策树，即候选切分属性要加入属性的线性组合。
61 | 


--------------------------------------------------------------------------------
/机器学习/机器学习基本知识总结.md:
--------------------------------------------------------------------------------
  1 | # 机器学习基本知识总结：深度和广度
  2 | 
  3 | ## 1. 机器学习基本理论
  4 | 
  5 | ### 1.1 vc维
  6 | 
  7 | 标签：机器学习的本质，霍夫定不等式，成长函数，break-point，vc-维
  8 | 
  9 | vc维的引入，是为了证明机器学习是能够学到东西的。我们认为，机器学习的目标是从现有的数据当中学习出符合现有数据的规律g，而这个g与实际的数据规律f之间肯定是有差距的。
 10 | 
 11 | 这样我们可以引申出两个概念：Ein，Eout，这两个概念是用来衡量一个假设函数的，Ein指的是假设函数在训练数据上的误差，Eout指的是假设函数在整个数据分布上的误差。我们学到一个假设函数以后，有两个目标：一是让Ein尽量小，而是要让Ein与Eout尽量一致，不能相差太大。
 12 | 
 13 | 那么我们如何保证这种差距是比较小的呢？这里我们可以假设有一个罐子，每个罐子里面有黄色，绿色的珠子，黄色的珠子表示g得到的结果与f不一致，绿色的表示一致，那么我们可以认为每个罐子代表一个假设g。因为罐子中的珠子太多，我们不能全部拿出来，因此我们只能抽样查看绿色珠子的比例。那么又有一个问题，就是如何衡量抽样带来的误差，即我抽样出来的黄，绿珠子的比例与这个假设罐子中的真实比例差距有多大？关于这个，有霍夫定不等式，能够保证，抽样比例和实际比例之间的误差是有一个上界的。这就保证我对一个罐子进行抽样的时候，得到关于这个假设罐子的Ein与Eout的差距比较大的可能性是比较小的。但是，我们在假设空间寻找假设函数的时候，是对无穷个罐子进行搜索，这样，我们保证没有一个罐子会抽样到Ein与Eout相差比较大的情况的概率，就会被放大。这个放大的倍数就是罐子的个数，也就是假设空间中假设的个数。
 14 | 
 15 | 但是其实这又是一个比较宽松的上界，在这个上界的系数是描述假设空间中假设的个数，但是其实我们想象一下线性分类（以下距离都是以线性分类为例），将分割平面稍微转动一下，就会是另外的假设，这这些假设是非常相似的，是有很大交集的，那么为了让这个上限更紧确些。我们需要重新考虑如何衡量假设空间的复杂度。这时候我们对假设空间中的函数做一下分类，即将数据点分割成同样结果的作为一类，用假设空间中函数的类别来衡量其复杂度。
 16 | 
 17 | 按照数据点的多少，假设的类别肯定是变化的。而且数据点在空间排列的不同，数据点所属的类别不同，假设的类别肯定也是不同的。我们考虑在给定数据个数的情况下，在不同的数据分布的情况下，假设空间最多能有多少类。这是一个关于数据个数的函数。例如在数据点为3的时候, 下图显示了两种不同的数据分布，左图的分布情况下，八种情况都可以线性可分，这时假设空间中假设有8类，右图中，第三行的情况是线性不可分的，因此在当前的数据分布情况下，假设空间中只有6类假设。因此，在数据个数为3的情况下，假设空间的类别数为8。在这里，我们将这种描述假设空间类别的函数称为 成长函数（按照数据点的个数进行成长的）。
 18 | 
 19 | ![vc_1](../image/vc_1.png)
 20 | 
 21 | 按照成长函数的定义，我们自然想到成长函数的上限是2^n,但是指数增长是非常快的，我们是否能够找到一个更加紧确的上限呢？这里我们提出了叫做“shater”的概念，指的是在数据量一定的情况下，存在一种数据分布情况，分割平面能够将数据空间中的所有点标记的所有情况都分割成功（即上图这种情况）。随着数据量的增加，肯定存在一个数据量的情况（我们称这时候的数据点的个数为break-point），假设空间不能够shater所有的数据点，这时候，我们的假设空间的类别个数就不再是指数增加了，说不定就变成多项式了呢。。（先小小的幻想一下，后面证明的确是多项式）
 22 | 
 23 | 上段中提到了break-point的概念，这里举几个例子，具体说明一下什么是break-point。例如在假设空间是正向射线的情况下，在数据点为2的情况下，假设空间有三种类别：起始点分别位于比两个数据点都小，两个数据点中间，比两个数据点都大。这时候假设空间的类别为3，不等于2^2，因此break-point为2。
 24 | 
 25 | ![vc_2](../image/vc_2.png)
 26 | 
 27 | 知道了成长函数不总是指数增长的，接下来我们想要证明出来一个比较紧确的多项式的上界。我们可以将成长函数的上限表示成B(N,k),其中N是数据点的个数，k是break-point。B(N,k)的概念就是在一定数据量的情况下，将数据点的标记情况进行排列组合，排列组合的结果不能shater到k个点（也就是不能将k个点中的所有情况都拍哦咧组合出来）。由此我们可以想象到，B(N,k)是一个动态规划的情况，有以下递推公式：
 28 | 
 29 | ![vc_3](../image/vc_3.png)
 30 | 
 31 | 现在，我们证明了成长函数的上界的上界是一个多项式的表达式，因此，我们接下里的问题就是是否可以利用成长函数的上界来将Ein和Eout的差别很大的概率限制到一个更加紧确的上界。这里我就不加证明了，肯定是可以的。详细可以看林老师的机器学习基石的第六节。
 32 | 
 33 | 接下来，我们看面试中常问到的vc维。vc维的定义就是假设空间的类别个数等于2^n的最大数据量，就是break-point减1.
 34 | 
 35 | ### 1.2 概率论基础
 36 | 
 37 | 概率分布在机器学习中占有非常重要的作用。尤其是在贝叶斯相关的理论中，参数，训练数据，预测变量等都是在一定的概率分布下形成的，我们预测的目标也主要是在对概率分布建模。而现实生活中的概率分布是非常复杂的，而我们只能利用简单的概率分布对其进行估计，近似。最常用的，最基本的一些概率分布模型就是指数族的概率分布了，包括很多基本的概率分布。
 38 | 
 39 | #### 1.2.1 常见的概率分布
 40 | 
 41 | 标签：beta分布，二项分布，泊松分布，正态分布，狄利克雷分布，极限关系，共轭关系，一致性
 42 | 
 43 | 伯努利分布：一次抛硬币实验中（硬币未必均匀），投掷结果的概率分布；
 44 | 
 45 | 二项分布：伯努利试验重复多次，投掷结果就服从二项分布；多次抛硬币实验中，投掷结果的概率分布。
 46 | 
 47 | 泊松分布：泊松分布描述的是单位时间内某件小概率事件发生次数的分布。判断一件事情是否服从于泊松分布的条件：某件事情发生属于小概率事件，某件事情的发生是独立的，某件事情发生的概率是稳定的。泊松分布的表达可以由二项分布推导出来，当二项分布中n趋向于无穷，p趋向于0，而np是常数。因此，泊松分布可以理解为单位时间内无穷多次的伯努利实验，这些伯努利实验的和是稳定的，为lambda。
 48 | 
 49 | 指数分布：主要描述相互独立的随机事件之间的时间间隔的概率；指数分布的形式可以由泊松分布推导出来。
 50 | 
 51 | gamma分布：gamma分布是独立同分布的指数分布的积分。gamma分布可以理解从头开始，到第n次事件发生的时间的分布。
 52 | 
 53 | beta分布：一定范围内的n个随机变量进行排序后，第k个变量的取值就是一个beta分布，其中alpha = k , beta = n - k + 1。其中gamma函数起到了将变量从整数空间延拓到实数空间的作用。
 54 | 
 55 | 狄利克雷分布：一定范围内的n个随机变量进行排序后，第k1个变量，第k2个变量的联合分布就是一个狄利克雷分布。
 56 | 
 57 | 高斯分布：在n趋近于无穷的时候，随机变量的均值收敛于正态分布。
 58 | 
 59 | 卡方分布：n个服从正态分布的随机变量的平方和的分布。
 60 | 
 61 | t分布：x服从标准正态分布，y服从卡方分布。
 62 | 
 63 | F分布：x服从自由度为n的卡方分布，y服从自由夫为m的卡方分布。
 64 | 
 65 | #### 1.2.2 常用的统计学检验方法
 66 | 
 67 | t检验：适用于方差齐性的两组小样本之间的比较。
 68 | 
 69 | f检验：
 70 | 
 71 | 卡方检验：理论频数和实际频数的吻合程度
 72 | 
 73 | p值：
 74 | 
 75 | 自由度：
 76 | 
 77 | ### 1.3模型选择
 78 | 
 79 | 标签：F1，AUC，ROC，k折交叉验证，AIC，BIC，L1，L2，bootstrapping
 80 | 
 81 | #### 1.3.1 性能度量
 82 | 
 83 | 回归任务中常用的性能度量是最小平方差
 84 | 
 85 | 分类任务中，由于我们一般通过混淆矩阵来定义不同的度量方式：
 86 | 
 87 | |      |      |      |
 88 | | ---- | ---- | ---- |
 89 | |      |      |      |
 90 | |      |      |      |
 91 | 
 92 | #### 1.3.2 模型选择方法
 93 | 
 94 | #### 1.3.3 过拟合的处理方法
 95 | 
 96 | ## 4. 贝叶斯推断学习中的推断方法
 97 | 
 98 | 3.1 参数化贝叶斯
 99 | 
100 | 最大后验分布
101 | 
102 | 最大边缘概率分布
103 | 
104 | 3.2 非参数贝叶斯
105 | 
106 | 两者的不同在于先验的不同
107 | 
108 | 
109 | 
110 | 
111 | 
112 | 
113 | 
114 | 


--------------------------------------------------------------------------------
/机器学习/特征选择.md:
--------------------------------------------------------------------------------
  1 | ## 特征选择
  2 | 从已有的特征中选择出有意义的特征，提升模型表现、减少计算量。
  3 | 
  4 | 特征选择的主要方法：
  5 | 
  6 | * 方差选择
  7 | * 相关系数
  8 | * 卡方检验
  9 | * 互信息
 10 | * 递归特征消除：Recursive Feature Elimination（RFE）
 11 | * 基于L1正则化
 12 | * 基于树模型
 13 | 
 14 | ### 方差选择
 15 | 对每个特征计算方差，设定阈值（或特征个数）并筛选。特征的方差小，说明样本在这个特征上没什么差异，这个特征没有区分能力，因此可以通过方差来选择特征。
 16 | 
 17 | ### 相关系数
 18 | 皮尔逊相关系数 ![](https://wikimedia.org/api/rest_v1/media/math/render/svg/8b0d0608b5f85d24a9c572f8d1b5769289664dfb) 
 19 | 
 20 | 衡量两个变量的相关程度，取值为[-1,1]，绝对值越大表示两者越相关。变量与自身的相关系数为1。
 21 | 
 22 | 可以计算所有特征与目标值的相关系数，设定阈值并筛选出与目标值较为相关的特征。
 23 | 
 24 | ### 卡方检验
 25 | 卡方检验用来验证两个变量是否相关，原假设两者不相关。
 26 | 卡方检验统计量的计算公式： $$\chi^2 = \sum \frac{(A-T)^2}{T}$$ A表示实际值，T表示理论值，对所有可能求和。
 27 | 
 28 | 两个变量A、B可以做出四格表
 29 | ![](img/practice.png)计算出属于A的概率为0.609
 30 | ![](img/theory.png)
 31 | 最终计算卡方统计量 $\chi^2 = \frac{(19-26.2)^2}{26.2} +  \frac{(34-26.8)^2}{26.8} + \frac{(24-16.8)^2}{16.8} + \frac{(10-17.2)^2}{17.2} = 10.00$
 32 | 
 33 | 卡方统计量的值越大，说明理论和实际的差别越大，拒绝原假设，说明两个变量越相关。
 34 | 
 35 | 特征选择时，选择与目标值卡方统计量较大的特征。卡方检验在基于词袋模型的文本分类时，特征选择效果较好。
 36 | 
 37 | ### 互信息
 38 | 互信息的定义 
 39 | 
 40 | ![](https://wikimedia.org/api/rest_v1/media/math/render/svg/6a75f80322072168ff9ecb8cde63cca5aa9218e1)
 41 | 
 42 | 也可以表示为
 43 | 
 44 | ![](https://wikimedia.org/api/rest_v1/media/math/render/svg/c13e97646e808df00481954f411dfcf1da9a4b60)
 45 | 
 46 | 直观的解释：原来对X的不确定性为熵H(x)，知道Y之后对X的不确定性为条件熵H(X|Y)，不确定性的减少量$H(x)-H(X|Y)$就是X、Y之间的互信息。
 47 | 
 48 | 互信息表示了两个变量的关联程度，越大表示越相关，因此可以计算特征与目标量之间的互信息，据此筛选特征。
 49 | 
 50 | ### 递归特征消除
 51 | Recursive Feature Elimination（RFE），直接使用最终的模型，递归训练模型，每次根据模型中的特征重要性，不断删除最不重要的特征。这里的模型需要训练完后能提供特征的权重。
 52 | 
 53 | sklearn中实现了这个算法，配合可以提供feature_importance的模型很方便。
 54 | 
 55 | ```
 56 | >>> from sklearn.datasets import make_friedman1
 57 | >>> from sklearn.feature_selection import RFE
 58 | >>> from sklearn.svm import SVR
 59 | >>> X, y = make_friedman1(n_samples=50, n_features=10, random_state=0) #一共10个特征
 60 | >>> estimator = SVR(kernel="linear") #用SVM模型
 61 | >>> selector = RFE(estimator, 5, step=1) #选择5个特征，每次递归删除一个
 62 | >>> selector = selector.fit(X, y)
 63 | >>> selector.support_ 
 64 | array([ True,  True,  True,  True,  True,
 65 |         False, False, False, False, False], dtype=bool)
 66 | >>> selector.ranking_
 67 | array([1, 1, 1, 1, 1, 6, 4, 3, 2, 5])
 68 | ```
 69 | 
 70 | ### 基于L1正则化
 71 | 带L1正则化的线性模型容易获得稀疏解，[目标函数与L1取值范围的交点往往在坐标轴上](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/%E8%BF%87%E6%8B%9F%E5%90%88.md)，不为零的系数所对应的特征即是最重要的特征。
 72 | 
 73 | 使用线性模型（线性回归、逻辑回归、线性支持向量机），配合L1正则化，拟合训练数据，非零系数对应的即为重要特征。通过控制正则化系数C，可以控制选择的特征多少。
 74 | 
 75 | ```
 76 | >>> from sklearn.svm import LinearSVC
 77 | >>> from sklearn.datasets import load_iris
 78 | >>> from sklearn.feature_selection import SelectFromModel
 79 | >>> iris = load_iris()
 80 | >>> X, y = iris.data, iris.target
 81 | >>> X.shape
 82 | (150, 4)
 83 | >>> lsvc = LinearSVC(C=0.01, penalty="l1", dual=False).fit(X, y) 
 84 | >>> model = SelectFromModel(lsvc, prefit=True) # 用线性支持向量机和L1正则化选取特征
 85 | >>> X_new = model.transform(X)
 86 | >>> X_new.shape
 87 | (150, 3)
 88 | ```
 89 | 
 90 | ### 基于树模型
 91 | 决策树构建时，每一个节点分裂的过程就是寻找增益最大的特征。单颗树容易过拟合，结合随机森林或GBDT这样的集成学习模型，计算特征在所有决策树模型上的平均增益，能够很好的反映一个特征的有效性。
 92 | 
 93 | ```
 94 | >>> from sklearn.ensemble import ExtraTreesClassifier
 95 | >>> from sklearn.datasets import load_iris
 96 | >>> from sklearn.feature_selection import SelectFromModel
 97 | >>> iris = load_iris()
 98 | >>> X, y = iris.data, iris.target
 99 | >>> X.shape
100 | (150, 4)
101 | >>> clf = ExtraTreesClassifier()
102 | >>> clf = clf.fit(X, y)
103 | >>> clf.feature_importances_  
104 | array([ 0.04...,  0.05...,  0.4...,  0.4...])
105 | >>> model = SelectFromModel(clf, prefit=True)
106 | >>> X_new = model.transform(X)
107 | >>> X_new.shape               
108 | (150, 2)
109 | ```
110 | 


--------------------------------------------------------------------------------
/机器学习/过拟合.md:
--------------------------------------------------------------------------------
 1 | ### 过拟合
 2 | 模型在训练数据上表现好，而在测试数据上表现不好的现象称为过拟合。从方差和偏差的角度，过拟合时偏差小但是方差大。
 3 | 
 4 | ### L0、L1、L2正则化
 5 | 
 6 | ![](img/regularization.png)
 7 | 正则化目的在于防止过拟合，以上图为例，二次函数能较好的拟合现有数据点，三次函数也可以拟合现有的数据点，也就是说它们都能使训练误差很小。但是对于新的数据点，三次函数的测试集误差就会很大，因此三次函数模型在这里就是过拟合。
 8 | 
 9 | 一个数据集可以有许多模型能使其训练误差很小，模型越复杂，越有可能出现过拟合。一般来说，n次多项式模型的参数可以表示成$[w_0, w_1, w_2, ..., w_n]$，如果只有$w_0, w_1, w_2$不为0，则n次多项式模型退化成二次函数。
10 | 
11 | * L0正则化：限制$w_i$不为0的个数
12 | * L1正则化（Lasso）：限制$\sum_{i=0}^{n}|w_i| \le C$
13 | * L2正则化（Ridge）：限制$\sum_{i=0}^{n}|w_i|^2 \le C$
14 | 
15 | ![](https://img-blog.csdn.net/20140504123020546?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvem91eHkwOQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
16 | 
17 | L0正则化可以使参数稀疏化，控制模型的复杂度，但是这样求解参数向量W是NP-hard的问题，因此实际不使用L0正则化。L1和L2正则化如上图所示，参数取值范围被限制（二维情况下L1对应正方形，L2对应圆形），找到与损失函数的等高线首次相交的点，就是最优解。损失函数加上正则化项后作为目标函数，绝对值函数和平方函数都是凸函数，因此可以用最优化方法来求解参数向量W。下式也称为权值衰减（weight-decay）
18 | ![](img/l2_loss.png)
19 | 
20 | 如果是L1正则化，相交的点往往会趋向于顶点（斜边上点的法向量不指向损失函数圆心），从而导致许多w的取值为0，形成稀疏解。所以L1正则化也可以用于特征选择。
21 | 
22 | 如果是L2正则化，则损失函数处处可微，优化求解稳定且快速，最终的参数大多数为非零，且相对较小。实际使用效果L2正则化优于L1正则化。
23 | 
24 | 
25 | ### Dropout
26 | ![](https://raw.githubusercontent.com/stdcoutzyx/Blogs/master/blogs/imgs/n7-1.png)
27 | 
28 | 在神经网络的训练阶段，随机丢弃某些神经元，每个batch训练时对应的神经网络都不同。Dropout的好处：
29 | 
30 | * 减少计算量
31 | * 使特征随机组合，防止过拟合
32 | 
33 | ### Early Stopping
34 | ![](http://izhaoyi.top/materials/img/bias_variance/curve.png)
35 | 随着训练次数的增加，模型的偏差减小，而方差增大，在某个临界点后就出现了过拟合。Early Stopping是在测试集误差逐渐增大后，提前停止训练，从而防止过拟合。
36 | 
37 | ### Data Augmentation
38 | 从数据的角度，过拟合可能由数据量太少而造成。如果能获得更多的训练数据，有助于防止过拟合。在无法获得更多数据的情况下，可以在现有数据的基础上随机生成更多的数据，即数据增强。
39 | 
40 | 常用的数据增强方法有：平移、旋转、翻转等。
41 | 
42 | 在类别不平衡的情况下，可以利用数据增强重复采样，使最终的训练数据类别平衡。


--------------------------------------------------------------------------------
/机器学习/逻辑回归.md:
--------------------------------------------------------------------------------
 1 | ## 逻辑回归模型
 2 | 逻辑回归是一种分类模型，根据输入$x\in R^n$，来判断输出Y的类别（Y=1，正类；Y=0，负类），参数为权值$w\in R^n$和偏置$b\in R$。
 3 | 
 4 | 逻辑回归把输出作为随机变量Y对于输入X的条件概率，取值范围限定在[0,1]，一般情况下，若大于0.5则Y=1，否则Y=0。从广义的线性模型角度考虑，$w\cdot x +b$ 是线性回归的输出，但它的取值范围是全体实数，
 5 | 逻辑回归为了把输出的范围限定在[0,1]，引入logistic函数：
 6 | $$ g(x) = \frac {1}{1+e^{-x}} $$
 7 | logistic函数单调且可微，x趋向正无穷时，g(x)趋向1；x趋向负无穷时，g(x)趋向0；x=0时，g(x)=0.5。
 8 | 
 9 | 
10 | 
11 | Y对于X的条件概率分布如下：
12 | 
13 | $$P(Y=1|X) = \frac {1}{1+e^{-(w\cdot x +b)}}$$
14 | $$P(Y=0|X) = \frac {e^{-(w\cdot x +b)}}{1+e^{-(w\cdot x +b)}}$$
15 | 
16 | logistic函数又称为对数几率函数。几率（odds）定义为：事件发生概率和不发生概率之间的比值，即$odds = \frac p {1-p}$。据此，可以计算得到：
17 | $$ln\frac {P(Y=1|X)}{1 - P(Y=0|X)} = w\cdot x +b$$
18 | 
19 | 换句话说，逻辑回归就是将线性回归的输出$w\cdot x +b$来拟合对数几率函数（logistic函数），核心就是将线性回归输出的取值范围从全体实数映射到概率取值[0,1]之间。
20 | 
21 | ## 最大似然估计参数
22 | 逻辑回归模型学习时，给定数据集$(x_1,y_1),(x_2,y_2), ... ,(x_n,y_n)$，用最大似然法来估计参数。
23 | 
24 | 单个样本的概率 $p_i = P(Y=1|X)^{y_i}P(Y=0|X)^{1-y_i}$，所以似然函数为：
25 | $$\prod_{i=1}^n P(Y=1|X)^{y_i}P(Y=0|X)^{1-y_i}$$
26 | 设logistic函数为g(x), 对数似然函数为：
27 | $$\sum_{i=1}^n [y_i log(g(x)) + (1-y_i)log(1-g(x))]$$ 
28 | 
29 | 要最大化对数似然函数，即最小化：
30 | $$- \frac 1n \sum_{i=1}^n [y_i log(g(x)) + (1-y_i)log(1-g(x))]$$
31 | 
32 | 上式即交叉熵（Cross-Entropy）损失函数，通过梯度下降等方法可以解这个最优化问题，得到逻辑回归的参数w,b。
33 | 
34 | ## 多分类
35 | 多分类时，可以构建k-1个逻辑回归模型；如果每个类互斥，logistic回归扩展成softmax回归。设有k个分类，第i个类的概率为：
36 | $$P(y=i|x, \theta) = \frac{e^{\theta_i^T x}}{\sum_j^K{e^{\theta_j^T x}}}$$
37 | 把logistic函数替换成softmax函数，将概率归一化，损失函数为交叉熵：
38 | $$J(\theta) = -\frac{1}{N} \sum_i^N \sum_j^K {y_i \log{p_i}}$$
39 | 可用梯度下降等方法求解。
40 | 
41 | ## 冗余特征
42 | 在模型训练时，一般会进行特征选择，去除冗余特征和高度相关特征。一是能降低维度，减小计算量。二是冗余特征没有增加数据的信息，但其效果也会叠加在模型中，使效果变差。
43 | 
44 | 对于逻辑回归，考虑对数几率$$log\frac{p}{1-p} = w\cdot x$$
45 | 如果所有特征重复一遍，则$w\cdot x$的值变为原来的两倍，即对数几率变为原来的两倍，显然会影响最终的分类结果。
46 | 
47 | ## 优缺点
48 | * 速度快
49 | * 可解释性强，每个特征对应一个权重
50 | * 无法处理正负样本不平衡的问题（全部预测为正，损失函数依然很小）
51 | * 准确率相对不高
52 | * 不引入其他方法时，只能处理二分类问题
53 | 


--------------------------------------------------------------------------------
/机器学习/集成学习.md:
--------------------------------------------------------------------------------
  1 | 集成学习是将多个模型组合在一起形成一个更强大的模型。往往单一的模型存在缺陷，只在某些方面表现的好，集成学习能够把这些有偏好的模型组合在一起，通过集体的决定将缺陷纠正。通俗的说，就是“三个臭皮匠顶个诸葛亮”
  2 | 
  3 | ### Bagging
  4 | Bagging全称是Bootstrap Aggregation，bootstrap的意思是对样本集D有放回地抽取N个样本。Bagging的流程如下：
  5 | 
  6 | 1. bootstrap获取样本子集$\tilde{D}$，并据此训练一个模型
  7 | 2. 重复n次，得到n个模型
  8 | 3. 将n个模型线性组合成最终模型
  9 | 
 10 | Bagging的每个模型是同类模型，训练数据是重采样获得的，因此每个模型肯定不相同但是两两之间存在相关性。从bias和variance的角度考虑，每个模型的期望和方差近似相等。显然$E[\frac{\sum X_i}{n}]=E[X_i]$，所以bias不变。
 11 | 
 12 | 方差$Var(\frac 1n \sum X_i) = \frac 1{n^2}\sum Var(X_i) + Cov(X_1,X_2,...,X_i)$，所有模型的方差近似相等，并且协方差肯定大于0，所以最终模型的方差会比$\frac {Var(X_i)}n$大一些，但小于$Var(X_i)$（所有模型完全相同的情况）。
 13 | 
 14 | 综上，Bagging能降低模型的variance而不能降低bias。因此，在选择Bagging的基学习器时，通常选用强学习器（高variance低bias），比如CART决策树，将容易过拟合的学习器“平均”成泛化能力强的学习器。显然，Bagging是可以并行的算法（同时训练n个模型）
 15 | 
 16 | ### 随机森林
 17 | 随机森林是Bagging和[决策树](https://github.com/LEAGUE-OF-BME/InterviewFAQ/blob/master/ML%26DL/%E5%86%B3%E7%AD%96%E6%A0%91.md)的组合。令D为样本集，随机森林算法如下：
 18 | 
 19 | ```
 20 | for t = 1,2,...,T:
 21 | 	对样本集D重采样得到子数据集
 22 | 	根据子数据集拟合一个决策树模型
 23 | G = 线性组合所有T个决策树模型
 24 | return G 
 25 | ```
 26 | 这里的决策树模型一般选用CART决策树，并且不需要剪枝，希望得到低bias高variance的决策树用于bagging。
 27 | 
 28 | 随机森林在CART决策树分裂时有一点改进：普通决策树是遍历所有M个特征，随机森林是从所有M个特征中随机选择m个（m << M），从这m个中选择最优分裂点。
 29 | 
 30 | #### OOB（out of bag）
 31 | 所有bagging类的算法，包括随机森林，都可以使用OOB样本来做测试集验证误差。OOB指的是那些每一次重采样都没有被选中的样本，一个样本是OOB的概率为$P=(1-\frac 1N)^N$，当重采样次数趋向于∞时，概率为$\frac 1e$。大约有不到三分之一的样本是OOB样本，不参与训练，可以直接作为验证集。
 32 | 
 33 | ### Boosting
 34 | Boosting中文是提升方法，是另一种常见的集成学习方法。Boosting的核心思想是：迭代训练一系列学习器，每个学习器的样本分布与之前的学习器有关，最后将所有学习器线性组合作为最终输出。
 35 | 
 36 | Boosting每一个学习器的训练都用了相同的样本，所以每个学习器之间是强相关的，相关系数可以近似为1，因此方差近似不会改变$Var(\frac 1n \sum X_i) = Var(X_i)$。并且Boosting的思想是每一步训练一个新的学习器，来最小化整体损失函数，因此整体模型的bias是在逐渐减小的。所以，Boosting的基学习器应该选择弱学习器（高bias低variance）。
 37 | 
 38 | ### AdaBoost
 39 | 二分类问题训练集：$T=\lbrace(x_1,y_1),(x_2,y_2),...,(x_n,y_n) \rbrace, y \in \lbrace+1,-1 \rbrace$
 40 | 
 41 | 初始化每个样本的权重为$w_i=\frac 1n$
 42 | 
 43 | for m = 1,2,...,M:
 44 | 
 45 | 1. 根据所有样本及其权重，训练得到分类器$G_m(x)$
 46 | 2. 计算$G_m(x)$在训练集上的误差，其中$I(x)$为0-1误差$$e_m = \sum_{i=1}^n w_iI(G_m(x_i) \neq y_i)$$
 47 | 3. 根据误差，计算$G_m(x)$的系数，即一个模型在最终模型的权重由它在训练集上的误差决定$$\alpha_m = \frac 12 ln\frac{1-e_m}{e_m}$$
 48 | 4. 更新样本权重，错误样本增大权重，正确样本减小权重$$w_i = \begin{cases} \frac{w_i}{Z_m}exp(-\alpha_m), & \text G_m(x)=y_i \\ \frac{w_i}{Z_m}exp(\alpha_m), & \text G_m(x)\neq y_i \end{cases}$$ 其中$Z_m$是归一化因子 $$Z_m = \sum_{i=1}^n exp(-\alpha_my_iG_m(x_i)）$$
 49 | 
 50 | 将所有M步得到的分类器线性组合成最终分类器$$f(x)=\sum_{m=1}^M \alpha_mG_m(x)$$
 51 | 
 52 | #### 模型解释
 53 | AdaBoost模型可以看作加法（additive model）模型，用前向分步算法和指数损失函数进行学习。
 54 | 
 55 | 加法模型是指一系列学习器线性组合成的模型，前向分步算法是一种学习加法模型的贪心算法，不从整体优化模型，而是根据损失函数每一步学习一个基学习器及其参数。
 56 | 
 57 | AdaBoost算法的最终分类器是$f(x)=\sum_{m=1}^M \alpha_mG_m(x)$，令其损失函数为$$L(y,f(x)) = exp(-yf(x))$$
 58 | 
 59 | 假设m-1步已经得到$f_{m-1}(x)$，第m步希望得到
 60 | 
 61 | 
 62 | ![](http://latex.codecogs.com/gif.latex?%24%24%20%28%5Calpha_m%2C%20G_m%28x%29%29%20%3D%20%5Cmathop%7B%5Carg%5Cmin%7D_%7B%5C%20%5Calpha%2CG%7D%20%5Csum_%7Bi%3D1%7D%5En%20exp%28-y_i%28f_%7Bm-1%7D%28x_i%29&plus;%5Calpha%20G%28x_i%29%29%29%20%24%24)
 63 | 
 64 | 令$w_{mi} = exp(-y_if_{m-1}(x))$，**这就是第m步时每个样本的权重**。$w_{mi}$与$\alpha ,G$不相关，所以上式可以写成：
 65 | 
 66 | 
 67 | ![](http://latex.codecogs.com/gif.latex?%24%24%20%28%5Calpha_m%2C%20G_m%28x%29%29%20%3D%20%5Cmathop%7B%5Carg%5Cmin%7D_%7B%5C%20%5Calpha%2CG%7D%20%5Csum_%7Bi%3D1%7D%5En%20w_%7Bmi%7Dexp%28-y_i%5Calpha%20G%28x_i%29%29%20%24%24)
 68 | 
 69 | 对于上式，首先求解
 70 | 
 71 | 
 72 | ![](http://latex.codecogs.com/gif.latex?%24%24%20G_m%28x%29%20%3D%20%5Cmathop%7B%5Carg%5Cmin%7D_%7B%5C%20G%7D%5Csum_%7Bi%3D1%7D%5En%20w_%7Bmi%7DI%28y_i%5Cneq%20G%28x_i%29%29%20%24%24)
 73 | 
 74 | 考虑预测的正确与否，展开后得到：
 75 | 
 76 | 
 77 | ![](http://latex.codecogs.com/gif.latex?%24%24%20%5Cbegin%7Balign%7D%20%5Csum_%7Bi%3D1%7D%5En%20w_%7Bmi%7Dexp%28-y_i%5Calpha%20G%28x_i%29%29%20%26%3D%20%5Csum_%7By_i%3DG_m%28x_i%29%7Dw_%7Bmi%7De%5E%7B-%5Calpha%7D%20&plus;%20%5Csum_%7By_i%5Cneq%20G_m%28x_i%29%7Dw_%7Bmi%7De%5E%7B%5Calpha%7D%20%5C%5C%20%26%3D%20%28e%5E%7B%5Calpha%7D&plus;e%5E%7B-%5Calpha%7D%29%5Csum_%7Bi%3D1%7D%5En%20w_%7Bmi%7DI%28y_i%5Cneq%20G%28x_i%29%29%20&plus;%20e%5E%7B-%5Calpha%7D%5Csum_%7Bi%3D1%7D%5Enw_%7Bmi%7D%20%5Cend%7Balign%7D%20%24%24)
 78 | 
 79 | 对$\alpha$求导并使导数为0，可以解得：
 80 | $$\alpha_m = \frac12 ln\frac {1-e_m}{e_m}$$
 81 | 
 82 | **与AdaBoost算法中基分类器的系数一致**
 83 | 
 84 | 当错误率$e_m < 0.5$时，系数$\alpha_m > 0$，并且错误率越小，系数越大。表明单个模型越好，在总模型中权重越大，如果比纯随机（错误率0.5）要好，那这个模型在总模型中有正向的作用。
 85 | 
 86 | ### GBDT
 87 | 
 88 | GBDT全称Gradient Boosting Decision Tree，也是一种Boosting算法，并且被认为是效果最好的统计学习算法之一。GBDT基学习器用的是决策树，采用加法模型和前向分步算法。GBDT可以选用不同的损失函数来解决不同的决策问题，比如用平方损失函数解决回归问题，用指数损失函数解决分类问题。从这个角度，如果AdaBoost算法选用决策树作为基分类器，那AdaBoost算法可以看作GBDT的一个特例。
 89 | 
 90 | GBDT最终加法模型可以表示为：$$f_M(x) = \sum_{m=1}^M T(x;\theta_m)$$
 91 | $T(x;\theta_m)$是表示第m个决策树， $\theta_m$表示决策树的参数，M是决策树的数量。
 92 | 
 93 | 如果使用平方损失函数：
 94 | 
 95 | 
 96 | ![](http://latex.codecogs.com/gif.latex?%24%24%20%5Cbegin%7Balign%7D%20L%28y%2C%20f_m%28x%29%29%20%26%3D%20%28y-f_m%28x%29%29%5E2%20%5C%5C%20%26%3D%20%28y%20-%20f_%7Bm-1%7D%28x%29%20-%20T%28x%3B%5Ctheta_m%29%29%5E2%20%5C%5C%26%3D%20%28r%20-%20T%28x%3B%5Ctheta_m%29%29%5E2%20%5Cend%7Balign%7D%20%24%24)
 97 | 
 98 | 令$r=y-f_{m-1}(x)$，称为当前模型拟合数据的残差，从损失函数的形式可以看到，这时候拟合第m棵决策树时，不要拟合训练数据的y，而要拟合残差r。换句话说，第m棵决策树的训练数据是$(x_i, y_i-f_{m-1}(x_i))$，这样自然而然每一步根据之前模型的残差可以训练一个决策树模型。
 99 | 
100 | 损失函数是平方损失时定义残差很方便，如果推广到一般损失函数，就需要引入梯度提升（gradient boosting）算法来计算。梯度提升算法相当于在函数空间内做梯度下降（gradient descent），用损失函数的负梯度在当前模型的值作为残差的近似值，第m步第i个样本的残差可以表示为：
101 | 
102 | 
103 | ![](http://latex.codecogs.com/gif.latex?%24%24r_%7Bmi%7D%20%3D%20-%5B%5Cfrac%20%7B%5Cpartial%20L%28y%2Cf%28x_i%29%7D%7B%5Cpartial%20f%28x_i%29%7D%5D_%7Bf%28x%29%3Df_%7Bm-1%7D%28x%29%7D%24%24)
104 | 
105 | 例如，损失函数用对数似然损失函数：
106 | $$L(y,f(x)) = log(1+exp(-yf(x)))$$
107 | 此时计算残差：
108 | 
109 | 
110 | ![](http://latex.codecogs.com/gif.latex?%24%24%20%5Cbegin%7Balign%7D%20r_%7Bmi%7D%20%26%3D%20-%5B%5Cfrac%20%7B%5Cpartial%20log%281&plus;exp%28-y_if%28x_i%29%29%29%7D%7B%5Cpartial%20f%28x_i%29%7D%5D_%7Bf%28x%29%3Df_%7Bm-1%7D%28x%29%7D%20%5C%5C%20%26%3D%20%5Cfrac%20y%20%7B1&plus;exp%28y_if_%7Bm-1%7D%28x_i%29%29%7D%20%5Cend%7Balign%7D%20%24%24)
111 | 
112 | 据此拟合第m棵决策树。
113 | 
114 | #### GBDT分类
115 | 
116 | 二分类：
117 | 
118 | * 使用指数损失函数，此时GBDT退化为AdaBoost算法
119 | * 使用类似于逻辑回归的对数似然损失函数
120 | 
121 | 使用对数似然损失函数，令GBDT的输出 $F(x) = log\frac {p(x)}{1-p(x)} $，p(x)为正样本的概率。
122 | 损失函数：$$L(y, p(x)) = -ylogp(x) - (1-y)log(1-p(x))$$
123 | 将p(x)用F(x)代入，得到：
124 | $$L(y,f(x)) = log(1+exp(-yf(x)))$$
125 | 然后按照GBDT回归算法拟合决策树，迭代计算。
126 | 
127 | 多分类：
128 | 
129 | GBDT采用一对多的策略，假设k个类，则训练k个分类器。使用交叉熵损失函数：
130 | $$L(y, f(x)) = -  \sum\limits_{k=1}^{K}y_klog\;p_k(x)$$
131 | 
132 | 其中概率用softmax表示：$\frac{e^{f_k(x)}}{\sum_j^K{e^{e^{f_j(x)}}}}$
133 | 
134 | 对f(x)求导计算负梯度：
135 | $$r_{til} = -\bigg[\frac{\partial L(y_i, f(x_i)))}{\partial f(x_i)}\bigg]_{f_k(x) = f_{l, t-1}\;\; (x)} = y_{il} - p_{l, t-1}(x_i)$$
136 | 
137 | 实质上每个样本的误差就是真实概率与上一轮计算得到的概率之差。
138 | 
139 | 按照GBDT回归算法拟合决策树，每次迭代，分别训练k个模型的一棵树。
140 | 


--------------------------------------------------------------------------------
/机器学习/非监督性算法.md:
--------------------------------------------------------------------------------
 1 | # 非监督性算法
 2 | 
 3 | ## 1. 聚类
 4 | 
 5 | ### 1.1常见的聚类算法
 6 | 
 7 | 1.K-means：
 8 | 
 9 | 2.层次聚类：
10 | 
11 | 3.密度聚类：
12 | 
13 | 考虑到
14 | 
15 | DBSCAN框架：
16 | 
17 | SNN，DBSCAN是个框架，可以采取不同的距离衡量函数，相对密度，SNN就是一种选择
18 | 
19 | 混合高斯模型：高斯检验
20 | 
21 | Mean-shift：
22 | 
23 | 谱聚类：
24 | 
25 | 狄利克雷过程：
26 | 
27 | #### 3.1.2 聚类算法中比较常用的数据结构：
28 | 
29 | KD-TREE
30 | 
31 | #### 3.1.3 类别数目的确定：
32 | 
33 | 据说有不需要确定最终聚类个数的方法
34 | 
35 | 例如AP聚类方法，或者说狄利克雷过程方法，但是个人理解，这些方法都是将k的选择转移到别的参数上面。终归到底都没有解决聚类个数的问题。
36 | 
37 | 其实有其他的参数
38 | 
39 | ### 3.2 降维
40 | 
41 | PCA
42 | 
43 | 概率PCA的解释是给定z一个先验高斯分布，然后观察变量x服从亦z的线性变换为均值的高斯分布。在概率PCA中我们的目的是求出z的这个线性变化是什么，包括权重和偏置项，然后权重可以表示成。
44 | 
45 | 通过将观测变量的边缘概率表达出来，我们能够得到观测变量的似然函数。然后最大化似然函数，我们能够得到转化矩阵表示为：
46 | 
47 | ![ppca_1](/Users/kellydou/Desktop/ppca_1.png)
48 | 
49 | 与PCA方法得到的解是一致的。其中UM是数据协方差矩阵的特征向量，中间项是特征值。虽然我们已经能够得到PPCA上午一个最优解，但是这样求特征值的解是非常耗时的。
50 | 
51 | 核PCA：利用核技术
52 | 
53 | 因子分析与PPCA不一样的地方在于其观测变量的方差不是齐性的
54 | 
55 | 独立成分分析：潜在变量是非高斯分布的
56 | 
57 | LLE，LE（流性方法）
58 | 
59 | ### 3.3 密度估计
60 | 
61 | ### 3.4 频繁模式挖掘


--------------------------------------------------------------------------------
/计算机网络/HTTP.md:
--------------------------------------------------------------------------------
  1 | HTTP
  2 | 
  3 | ### 1.HTTP 与HTTPS的区别
  4 | 
  5 | **HTTPS=HTTP+SSL**，其主要作用是
  6 | 
  7 | - 建立信息安全通道，来保证数据传输的安全；
  8 | 
  9 |   - 确认网站的真实性。 
 10 | 
 11 |   **HTTPS和HTTP的区别主要如下：**
 12 | 
 13 | 　　1、https协议需要到ca申请证书，一般免费证书较少，因而需要一定费用。
 14 | 
 15 | 　　2、http是超文本传输协议，信息是明文传输，https则是具有安全性的ssl加密传输协议。
 16 | 
 17 | 　　3、http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。
 18 | 
 19 | 　　4、http的连接很简单，是无状态的；HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，比http协议安全。
 20 | 
 21 | ### 2.HTTP 1.0 、1.1 、2.0
 22 | 
 23 | | HTTP 1.1较HTTP 1.0 | HTTP 2.0较HTTP 1.1 |
 24 | | ----------------- | ----------------- |
 25 | | 长连接               | 多路复用              |
 26 | | 请求与响应可以重叠         | 二进制分帧             |
 27 | | 带宽优化              | 首部压缩              |
 28 | | 更灵活的缓存机制          | 服务端推送             |
 29 | | 新增错误提示类型          |                   |
 30 | 
 31 | **多路复用**：允许同时通过单一的 HTTP/2 连接发起多重的请求-响应消息；
 32 | 
 33 | **二进制分帧**：通过增加一个二进制分帧层改进传输性能，实现低延迟和高吞吐量。HTTP/2将传输的信息分割成更小的消息和帧。
 34 | 
 35 | **首部压缩**：HTTP/2 则使用了专门为首部压缩而设计的HPACK算法。
 36 | 
 37 | **服务端推送**: 是一种在客户端请求之前发送消息的机制，在HTTP/2中，服务端可以对客户端的一个请求发送多个响应。
 38 | 
 39 | ### 3.HTTP方法
 40 | 
 41 | **GET**     请求获取Request-URI所标识的资源
 42 | 
 43 | **POST**    在Request-URI所标识的资源后附加新的数据
 44 | 
 45 | **HEAD**    请求获取由Request-URI所标识的资源的响应消息报头
 46 | 
 47 | **PUT**     请求服务器存储一个资源，并用Request-URI作为其标识
 48 | 
 49 | **DELETE**  请求服务器删除Request-URI所标识的资源
 50 | 
 51 | **TRACE**   请求服务器回送收到的请求信息，主要用于测试或诊断
 52 | 
 53 | **CONNECT** 保留将来使用
 54 | 
 55 | **OPTIONS** 请求查询服务器的性能，或者查询与资源相关的选项和需求
 56 | 
 57 | **GET方法**：在浏览器的地址栏中输入网址的方式访问网页时，浏览器采用GET方法向服务器获取资源，**POST方法**要求被请求服务器接受附在请求后面的数据，常用于提交表单。**GET是用于获取数据的，POST一般用于将数据发给服务器之用**。
 58 | 
 59 | ### 4.HTTP状态码
 60 | 
 61 | | 分类   | 分类描述                    |
 62 | | ---- | ----------------------- |
 63 | | 1**  | 信息，服务器收到请求，需要请求者继续执行操作  |
 64 | | 2**  | 成功，操作被成功接收并处理           |
 65 | | 3**  | 重定向，需要进一步的操作以完成请求       |
 66 | | 4**  | 客户端错误，请求包含语法错误或无法完成请求   |
 67 | | 5**  | 服务器错误，服务器在处理请求的过程中发生了错误 |
 68 | 
 69 | HTTP状态码列表:
 70 | 
 71 | | 状态码  | 状态码英文名                          | 中文描述                                     |
 72 | | ---- | ------------------------------- | ---------------------------------------- |
 73 | | 100  | Continue                        | 继续。客户端应继续其请求                             |
 74 | | 101  | Switching Protocols             | 切换协议。服务器根据客户端的请求切换协议。只能切换到更高级的协议，例如，切换到HTTP的新版本协议 |
 75 | |      |                                 |                                          |
 76 | | 200  | OK                              | 请求成功。一般用于GET与POST请求                      |
 77 | | 201  | Created                         | 已创建。成功请求并创建了新的资源                         |
 78 | | 202  | Accepted                        | 已接受。已经接受请求，但未处理完成                        |
 79 | | 203  | Non-Authoritative Information   | 非授权信息。请求成功。但返回的meta信息不在原始的服务器，而是一个副本     |
 80 | | 204  | No Content                      | 无内容。服务器成功处理，但未返回内容。在未更新网页的情况下，可确保浏览器继续显示当前文档 |
 81 | | 205  | Reset Content                   | 重置内容。服务器处理成功，用户终端（例如：浏览器）应重置文档视图。可通过此返回码清除浏览器的表单域 |
 82 | | 206  | Partial Content                 | 部分内容。服务器成功处理了部分GET请求                     |
 83 | |      |                                 |                                          |
 84 | | 300  | Multiple Choices                | 多种选择。请求的资源可包括多个位置，相应可返回一个资源特征与地址的列表用于用户终端（例如：浏览器）选择 |
 85 | | 301  | Moved Permanently               | 永久移动。请求的资源已被永久的移动到新URI，返回信息会包括新的URI，浏览器会自动定向到新URI。今后任何新的请求都应使用新的URI代替 |
 86 | | 302  | Found                           | 临时移动。与301类似。但资源只是临时被移动。客户端应继续使用原有URI     |
 87 | | 303  | See Other                       | 查看其它地址。与301类似。使用GET和POST请求查看             |
 88 | | 304  | Not Modified                    | 未修改。所请求的资源未修改，服务器返回此状态码时，不会返回任何资源。客户端通常会缓存访问过的资源，通过提供一个头信息指出客户端希望只返回在指定日期之后修改的资源 |
 89 | | 305  | Use Proxy                       | 使用代理。所请求的资源必须通过代理访问                      |
 90 | | 306  | Unused                          | 已经被废弃的HTTP状态码                            |
 91 | | 307  | Temporary Redirect              | 临时重定向。与302类似。使用GET请求重定向                  |
 92 | |      |                                 |                                          |
 93 | | 400  | Bad Request                     | 客户端请求的语法错误，服务器无法理解                       |
 94 | | 401  | Unauthorized                    | 请求要求用户的身份认证                              |
 95 | | 402  | Payment Required                | 保留，将来使用                                  |
 96 | | 403  | Forbidden                       | 服务器理解请求客户端的请求，但是拒绝执行此请求                  |
 97 | | 404  | Not Found                       | 服务器无法根据客户端的请求找到资源（网页）。通过此代码，网站设计人员可设置"您所请求的资源无法找到"的个性页面 |
 98 | | 405  | Method Not Allowed              | 客户端请求中的方法被禁止                             |
 99 | | 406  | Not Acceptable                  | 服务器无法根据客户端请求的内容特性完成请求                    |
100 | | 407  | Proxy Authentication Required   | 请求要求代理的身份认证，与401类似，但请求者应当使用代理进行授权        |
101 | | 408  | Request Time-out                | 服务器等待客户端发送的请求时间过长，超时                     |
102 | | 409  | Conflict                        | 服务器完成客户端的PUT请求是可能返回此代码，服务器处理请求时发生了冲突     |
103 | | 410  | Gone                            | 客户端请求的资源已经不存在。410不同于404，如果资源以前有现在被永久删除了可使用410代码，网站设计人员可通过301代码指定资源的新位置 |
104 | | 411  | Length Required                 | 服务器无法处理客户端发送的不带Content-Length的请求信息       |
105 | | 412  | Precondition Failed             | 客户端请求信息的先决条件错误                           |
106 | | 413  | Request Entity Too Large        | 由于请求的实体过大，服务器无法处理，因此拒绝请求。为防止客户端的连续请求，服务器可能会关闭连接。如果只是服务器暂时无法处理，则会包含一个Retry-After的响应信息 |
107 | | 414  | Request-URI Too Large           | 请求的URI过长（URI通常为网址），服务器无法处理               |
108 | | 415  | Unsupported Media Type          | 服务器无法处理请求附带的媒体格式                         |
109 | | 416  | Requested range not satisfiable | 客户端请求的范围无效                               |
110 | | 417  | Expectation Failed              | 服务器无法满足Expect的请求头信息                      |
111 | |      |                                 |                                          |
112 | | 500  | Internal Server Error           | 服务器内部错误，无法完成请求                           |
113 | | 501  | Not Implemented                 | 服务器不支持请求的功能，无法完成请求                       |
114 | | 502  | Bad Gateway                     | 充当网关或代理的服务器，从远端服务器接收到了一个无效的请求            |
115 | | 503  | Service Unavailable             | 由于超载或系统维护，服务器暂时的无法处理客户端的请求。延时的长度可包含在服务器的Retry-After头信息中 |
116 | | 504  | Gateway Time-out                | 充当网关或代理的服务器，未及时从远端服务器获取请求                |
117 | | 505  | HTTP Version not supported      | 服务器不支持请求的HTTP协议的版本，无法完成处理                |
118 | 
119 | ### 5.网络攻击（CSRF\XSS）
120 | 
121 | [](https://segmentfault.com/a/1190000009514661)


--------------------------------------------------------------------------------
/计算机网络/OSI7层模型.md:
--------------------------------------------------------------------------------
 1 | # OSI七层模型（TCP4层）
 2 | 
 3 | ### 1.各层的协议和功能
 4 | 
 5 | ![img](http://images2015.cnblogs.com/blog/1099668/201702/1099668-20170212153338135-125492424.jpg)
 6 | 
 7 | ### 2.ARP协议作用过程
 8 | 
 9 | 假设主机A和B在同一个网段，主机A要向主机B发送信息。
10 | 
11 | (1)       主机A首先查看自己的ARP表，确定其中是否包含有主机B对应的ARP表项。如果找到了对应的MAC地址，则主机A直接利用ARP表中的MAC地址，对IP数据包进行帧封装，并将数据包发送给主机B。
12 | 
13 | (2)        如果主机A在ARP表中找不到对应的MAC地址，则将缓存该数据报文，然后以广播方式发送一个ARP请求报文。ARP请求报文中的发送端IP地址和发送端MAC地址为主机A的IP地址和MAC地址，目标IP地址和目标MAC地址为主机B的IP地址和全0的MAC地址。由于ARP请求报文以广播方式发送，该网段上的所有主机都可以接收到该请求，但只有被请求的主机（即主机B）会对该请求进行处理。
14 | 
15 | (3)        主机B比较自己的IP地址和ARP请求报文中的目标IP地址，当两者相同时进行如下处理：将ARP请求报文中的发送端（即主机A）的IP地址和MAC地址存入自己的ARP表中。之后以单播方式发送ARP响应报文给主机A，其中包含了自己的MAC地址。
16 | 
17 | (4)        主机A收到ARP响应报文后，将主机B的MAC地址加入到自己的ARP表中以用于后续报文的转发，同时将IP数据包进行封装后发送出去。
18 | 
19 | 当主机A和主机B不在同一网段时，主机A就会先向网关发出ARP请求，ARP请求报文中的目标IP地址为网关的IP地址。当主机A从收到的响应报文中获得网关的MAC地址后，将报文封装并发给网关。如果网关没有主机B的ARP表项，网关会广播ARP请求，目标IP地址为主机B的IP地址，当网关从收到的响应报文中获得主机B的MAC地址后，就可以将报文发给主机B；如果网关已经有主机B的ARP表项，网关直接把报文发给主机B。
20 | 
21 | ### 3.URL到返回页面全过程
22 | 
23 | 1.      我们输入一个域名：[www.baidu.com](http://www.baidu.com/)  
24 | 
25 | 
26 | 2.      浏览器查找浏览器缓存，如果有域名的IP地址则返回，如果没有继续查找；
27 | 
28 | 
29 | 3.      系统查找系统缓存，如果有域名的IP地址则返回，如果没有继续查找；
30 | 
31 | 
32 | 4.      路由器查找路由器缓存，如果有域名的IP地址则返回，如果没有继续查找；
33 | 
34 | 
35 | 5.      本地域名服务器采用迭代查询，它先向一个根域名服务器查询；
36 | 
37 | 
38 | 6.      根域名服务器告诉本地域名服务器，下一次应查询的顶级域名服务器dns.com的IP地址；
39 | 
40 | 
41 | 7.      本地域名服务器向顶级域名服务器dns.com进行查询；
42 | 
43 | 
44 | 8.      顶级域名服务器dns.com告诉本地域名服务器，下一次应查询的权限域名服务器dns.baidu.com的IP地址；
45 | 
46 | 
47 | 9.      本地域名服务器向权限域名服务器dns.baidu.com进行查询；
48 | 
49 | 10.  权限域名服务器dns.baidu.com告诉本地域名服务器，所查询的主机www.baidu.com的IP地址；
50 | 
51 | 
52 | 11.  本地域名服务器最后把查询结果告诉主机；
53 | 
54 | 
55 | 12.  主机浏览器获取到Web服务器的IP地址后，与服务器建立TCP连接；
56 | 
57 | 
58 | 13.  浏览器所在的客户机向服务器发出连接请求报文；
59 | 
60 | 
61 | 14.  服务器接收报文后，同意建立连接，向客户机发出确认报文；
62 | 
63 | 
64 | 15.  客户机接收到确认报文后，再次向服务器发出报文，确认已接收到确认报文；
65 | 
66 | 
67 | 16.  此处客户机与服务器之间的TCP连接建立完成，开始通信；
68 | 
69 | 17.  浏览器发出取文件命令：GET；
70 | 
71 | 18.  服务器给出响应，将指定文件发送给浏览器；
72 | 
73 | 19.  浏览器释放TCP连接；
74 | 
75 | 
76 | 20.  浏览器所在主机向服务器发出连接释放报文，然后停止发送数据；
77 | 
78 | 
79 | 21.  服务器接收到释放报文后发出确认报文，然后将服务器上未传送完的数据发送完；
80 | 
81 | 22.  服务器数据传输完毕后，向客户机发送连接释放报文；
82 | 
83 | 23.  客户机接收到报文后，发出确认，然后等待一段时间后，释放TCP连接；
84 | 
85 | 24.  浏览器显示页面中所有文本。
86 | 
87 | 


--------------------------------------------------------------------------------
/计算机网络/网络编程.md:
--------------------------------------------------------------------------------
 1 | # IO模型 #
 2 | ## 阻塞式I/O ##
 3 | 这里把recvfrom函数视为系统调用，一般而言，调用过程都会在应用进程空间切换到内核空间，一段时间后再切换回来。进程调用recvfrom，其系统调用指导数据报到达企鹅杯复制到应用进程的缓冲区中或者发生错误才返回。进程从调用recvfrom开始刀塔返回的整段时间内是被阻塞的。recvfrom成功返回后，应用进程开始处理数据报。模型如下图
 4 | ![](/image/阻塞式IO模型.png)
 5 | ## 非阻塞式I/O模型 ##
 6 | 进程可以把一个套接字设置成非阻塞，这是在告诉内核，如果所请求的I/O操作非得把本进程的状态更改成睡眠（就绪？）才能完成时，不要本进程投入睡眠，而是返回一个错误。模型如下图
 7 | ![](/image/非阻塞式IO模型.png)
 8 | 上图中，前三次调用recvfrom是没有数据可以返回，因此内核立即返回一个EWOULDBLOCK错误。第四次调用recvfrom时已经有一个数据报准备好，他被复制应用进程缓冲区，于是revcfrom成功返回。应用进程继续处理数据。
 9 | 当一个应用进程像这样对一个非阻塞描述符循环调用recvfrom时，我们称之为轮询（polling）。应用进程持续轮询内黑，以检查某个操作是否就绪。这么做往往耗费大量的CPU时间。
10 | 
11 | ## IO复用模型 ##
12 | 有了IO复用，我们可以调用select或poll，阻塞在这两个系统调用的某一个之上，而不是阻塞在真正的IO系统调用上。
13 | ![](/image/IO复用模型.png)
14 | 我们阻塞与select调用，等待数据报套接字变为可读。当select返回套接字可读这一条件时，我们调用recvfrom吧所读取的数据复制到应用进程缓冲区。
15 | IO复用需要执行两个系统调用，一个用来处理真正的IO调用，另一个用来监测其状态。看似这并没有什么优势。不过在下文我们将会看到，使用select的优势在于我们可以等待多个描述符就绪。
16 | ## 信号驱动式IO模型 ##
17 | IO调用时也可以使用信号，让内黑在描述符就绪是发送SIGIO信号通知我们。我们称这种模型为信号驱动式IO，如下图
18 | ![](/image/信号驱动IO模型.png)
19 | 执行过程为，首先开启套接字的信号驱动式IO功能，并通过sigaction系统调用安装信号处理函数。该系统调用将立即返回，我们的进程继续执行。也就是说在这一部分没有阻塞。当数据报准备好读取时，内核就为该进程产生一个SIGIO信号，我们随后既可以在信号处理函数中调用recvfrom读取数据报，将数据从内核复制到用户缓冲区。数据从内核中复制到缓冲区的过程是被阻塞的。
20 | ## 异步IO模型 ##
21 | 简单讲其工作机制是：告知内核启动某个操作，并让内核在整个操作（包括内核到用户缓冲区的复制）完成后通知我们。可以发现其与信号驱动式的区别是，前者在IO操作何时完成通知我们，后者通知我们何时可以启动一个IO操作。细节如下图
22 | ![](/image/异步IO模型.png)
23 | 
24 | 这里我们对同步和异步下一个定义
25 | - 同步IO 导致请求进程阻塞，知道IO操作完成
26 | - 异步IO 不导致请求进程阻塞
27 | 
28 | 可以发现前除了最后一种异步IO模型，其他四种都会导致进程阻塞，所以他们都是同步IO操作
29 | 
30 | 
31 | ## IO复用之select，poll，epoll ##
32 | 
33 | #### select ####
34 | 对于给定的描述符进行轮询，当有描述符就绪时返回，返回值是就绪描述符的数目，select返回后，用户程序需要遍历确定给定的描述符中哪一个已经就绪，从而执行后面的操作。select模型每次调用都会讲描述符的内容（一个数组）从用户空间拷贝到内核空间，当数量较大时，效率会很低。 此外，select会轮询遍历所有的关注的描述符，描述符数量较大时效率也会很低。
35 | 
36 | #### poll  ####
37 |  内部实现与select基本相同，只是传入参数的方式不同，而且会把就绪的描述符放置在一个参数中返回，用户程序可以遍历这个数组以得到就绪的描述符
38 |  
39 | #### epoll  ####
40 |  将用户关心的文件描述符的时间存放在内核中的一个事件表中，用户空间和内核空间只需要复制一次。当某个描述符就绪时，内核会采用类似callback的回调机制（软件中断）迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知


--------------------------------------------------------------------------------
/计算机网络/计算机网络FAQ.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LEAGUE-OF-BME/InterviewFAQ/0db6aed3bd3d101542d2fd8e7c61658eb816ab43/计算机网络/计算机网络FAQ.md


--------------------------------------------------------------------------------