BlogJava-xiaomage234-随笔分类-algorithm

白话经典算法（转）

小马歌 — Fri, 23 Jun 2017 03:17:00 GMT

from:http://blog.csdn.net/MoreWindows/article/category/859207

【白话经典算法系列之十七】数组中只出现一次的数

数组A中，除了某一个数字x之外，其他数字都出现了三次，而x出现了一次。请给出最快的方法找到x。这个题目非常有意思，在本人博客中有《位操作基础篇之位操作全面总结》这篇文章介绍了使用位操作的异或来解决——数组中其他数字出现二次，而x出现一次，找出x。有《【白话经典算法系列之十二】数组中只出现1次的两个数字(百度面试题)》这边文章介绍了分组异或的方法来解决——数组中其他数字出现二次，而x和y出现一次，找出x和y。而这个题目则是其他数字出现3次，x出现一次。...

2013-10-21 11:49 阅读(32100) 评论(34)

【白话经典算法系列之十六】“基数排序”之数组中缺失的数字

首先看看题目要求：给定一个无序的整数数组，怎么找到第一个大于0，并且不在此数组的整数。比如[1,2,0]返回3，[3,4,-1,1]返回2，[1, 5, 3, 4, 2]返回6，[100, 3, 2, 1, 6,8, 5]返回4。要求使用O(1)空间和O(n)时间。这道题目初看没有太好的思路，但是借鉴下《白话经典算法系列之十一道有趣的GOOGLE面试题》这篇文章，我们不发现使用“基数排序”正好可以用来解决这道题目...

2013-10-15 10:17 阅读(13580) 评论(11)

【白话经典算法系列之十五】“一步千里”之数组找数

【白话经典算法系列之十五】“一步千里”之数组找数有这样一个数组A，大小为n，相邻元素差的绝对值都是1。如：A={4,5,6,5,6,7,8,9,10,9}。现在，给定A和目标整数t，请找到t在A中的位置。除了依次遍历，还有更好的方法么？...

2013-09-02 12:57 阅读(25918) 评论(39)

【白话经典算法系列之十三】随机生成和为S的N个正整数——投影法

【白话经典算法系列之十三】随机生成和为S的N个正整数——投影法随机生成和为S的N个正整数有很多种解法。下面讲解一种比较高效且比较有趣味性的解法——投影法。以生成和为20的4个数为例，可以先生成随机生成0到20之间的三个数字再排序，假设得到了4，7，18。然后在X-Y数轴上画出这三个数，如下图：然后将这些数值投影到Y轴上，可得下图：由图很容易看出AB，BC，CD，DE这四段的长度...

2013-01-04 13:46 阅读(15710) 评论(46)

【白话经典算法系列之十二】数组中只出现1次的两个数字(百度面试题)

微博http://weibo.com/MoreWindows已开通，欢迎关注。本系列文章地址：http://blog.csdn.net/MoreWindows/article/category/859207首先来看题目要求：在一个数组中除两个数字只出现1次外，其它数字都出现了2次，要求尽快找出这两个数字。考虑下这个题目的简化版——数组中除一个数字只出现1次外，其它数字都成对出现，要求尽快...

2012-11-27 09:17 阅读(35498) 评论(51)

【白话经典算法系列之十一】一道有趣的GOOGLE面试题 --【解法2】

微博http://weibo.com/MoreWindows已开通，欢迎关注。本系列文章地址：http://blog.csdn.net/MoreWindows/article/category/859207 上一篇《白话经典算法系列之十一道有趣的GOOGLE面试题》中对一道有趣的GOOGLE面试题进行了详细的讲解，使用了类似于基数排序的做法在O(N)的时间复杂度和O(1)的空间复杂度完成了题目的要...

2012-11-23 07:57 阅读(24806) 评论(52)

白话经典算法系列之十一道有趣的GOOGLE面试题

微博http://weibo.com/MoreWindows已开通，欢迎关注。最近在微博上看到一道有趣的GOOGLE面试题，见下图：文字版：一个大小为n的数组，里面的数都属于范围[0, n-1]，有不确定的重复元素，找到至少一个重复元素，要求O(1)空间和O(n)时间。这个题目要求用O(n)的时间复杂度，这意味着只能遍历数组一次。同时还要寻找重复元素，很容易想到建立哈希表来完成，遍历数组...

2012-11-21 09:03 阅读(47907) 评论(87)

白话经典算法系列之九从归并排序到数列的逆序数对（微软笔试题）

首先来看看原题微软2010年笔试题在一个排列中，如果一对数的前后位置与大小顺序相反，即前面的数大于后面的数，那么它们就称为一个逆序数对。一个排列中逆序的总数就称为这个排列的逆序数。如{2，4，3，1}中，2和1，4和3，4和1，3和1是逆序数对，因此整个数组的逆序数对个数为4，现在给定一数组，要求统计出该数组的逆序数对个数。计算数列的逆序数对个数最简单的方便就最从前向后依次统计每个数字与它后面...

2012-10-15 09:15 阅读(30367) 评论(36)

白话经典算法系列之八 MoreWindows白话经典算法之七大排序总结篇

在我的博客对冒泡排序，直接插入排序，直接选择排序，希尔排序，归并排序，快速排序和堆排序这七种常用的排序方法进行了详细的讲解，并做成了电子书以供大家下载。下载地址为：http://download.csdn.net/detail/morewindows/4443208。有网友提议到这本《MoreWindows白话经典算法之七大排序》电子书讲解细致用来平时学习是非常好的，但是页数有22页...

2012-09-10 10:08 阅读(42997) 评论(26)

白话经典算法系列之七堆与堆排序

堆排序与快速排序，归并排序一样都是时间复杂度为O(N*logN)的几种常见排序方法。学习堆排序前，先讲解下什么是数据结构中的二叉堆。二叉堆的定义二叉堆是完全二叉树或者是近似完全二叉树。二叉堆满足二个特性：1．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。2．每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父...

2011-08-22 20:04 阅读(338481) 评论(188)

白话经典算法系列之六快速排序快速搞定

快速排序由于排序效率在同为O(N*logN)的几种排序方法中效率较高，因此经常被采用，再加上快速排序思想----分治法也确实实用，因此很多软件公司的笔试面试，包括像腾讯，微软等知名IT公司都喜欢考这个，还有大大小的程序方面的考试如软考，考研中也常常出现快速排序的身影。总的说来，要直接默写出快速排序还是有一定难度的，因为本人就自己的理解对快速排序作了下白话解释，希望对大家理解有帮助，达到快速排序，快...

2011-08-13 17:19 阅读(418202) 评论(284)

白话经典算法系列之五归并排序的实现

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。//将有序数组a[]和b[]合并到c[]中 void MemeryArra...

2011-08-11 11:01 阅读(275147) 评论(154)

白话经典算法系列之四直接选择排序及交换二个数据的正确实现

直接选择排序和直接插入排序类似，都将数据分为有序区和无序区，所不同的是直接播放排序是将无序区的第一个元素直接插入到有序区以形成一个更大的有序区，而直接选择排序是从无序区选一个最小的元素直接放到有序区的最后。设数组为a[0…n-1]。 1. 初始时，数组全为无...

2011-08-09 11:15 阅读(29055) 评论(38)

白话经典算法系列之三希尔排序的实现

希尔排序的实质就是分组插入排序，该方法又称缩小增量排序，因DL．Shell于1959年提出而得名。该方法的基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增...

2011-08-08 11:41 阅读(148913) 评论(82)

白话经典算法系列之二直接插入排序的三种实现

直接插入排序(Insertion Sort)的基本思想是：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中的适当位置，直到全部记录插入完成为止。设数组为a[0…n-1]。 1. 初始时，a[0]自成1个有序区，无序区为a[1..n-1]。...

2011-08-06 19:27 阅读(118661) 评论(81)

白话经典算法系列之一冒泡排序的三种实现

冒泡排序是非常容易理解和实现，，以从小到大排序举例：设数组长度为N。 1．比较相邻的前后二个数据，如果前面数据大于后面的数据，就将二个数据交换。 2．这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。 3．N=N-1，如果N...

2011-08-06 19:20 阅读(166505) 评论(94)

小马歌 2017-06-23 11:17 发表评论

深度学习培训班路线

小马歌 — Wed, 17 May 2017 03:28:00 GMT

from:http://blog.csdn.net/hemeinvyiqiluoben/article/details/62439861

课程安排第一天上午	一、机器学习基础	1.线性代数 (1).矩阵运算 (2).向量运算 (3).SVD (4).PCA 2.概率信息论 (1).概率分布 (2).期望、方差、协方差 (3). 贝叶斯 (4).结构概率模型 3.数值优化
课程安排第一天上午	二、深度学习基础	1.深度学习介绍 (1).发展历史 (2).主要应用 2.感知器 3.人工神经网络 4.前馈神经网络 5.BP算法 6.Hessian矩阵
第一天下午	三、深度学习进阶---卷积神经网络	1.CNN卷积神经网络 (1).卷积层（一维卷积、二维卷积） (2).池化层（均值池化、最大池化） (3). 全连接层 (4).激活函数层 (5).Softmax层 2.CNN卷积神经网络改进 (1).R-CNN （SPPNET） (2).Fast-R-CNN (3).Faster-R-CNN （YOLO、SSD） 3.深度学习的模型训练技巧 4.梯度下降的优化方法详解
第二天上午	四、深度学习软件	1.深度学习相关软件的安装配置与使用介绍 (1).Caffe (2).Tensorflow (3).Torch (4).MXNet
第二天下午	五、 CNN应用案例	(1).CNN与手写数字集分类 (2).YOLO实现目标检测 (3).PixelNet原理与实现 (4).利用卷积神经网络做图像风格结合
第三天上午	六、深度学习——循环神经网络	1.RNN循环神经网络 (1).梯度计算 (2).BPTT 2.RNN循环神经网络改进 (1).LSTM (2).GRU (3).Bi-RNN (4).Attention based RNN 3.RNN实际应用 (1).Seq2Seq的原理与实现
第三天下午	七、强化学习	1.强化学习的理论知识 2.经典模型DQN讲解 3.AlphaGo原理讲解 4.RL实际应用 (1).实现一个AlphaGo
第四天上午	八、对抗性生成网络	1.GAN的理论知识 2.GAN经典模型 (1).GAN，CGAN，LAPGAN，DCGAN， 3.GAN经典模型 (1). INFOGAN，WGAN，S2-GAN 4.GAN实际应用 (1).DCGAN提高模糊图片分辨率 5.GAN实际应用 (1).InfoGAN做特定的样本生成
第四天下午	九、迁移学习	1.迁移学习的理论概述 2.迁移学习的常见方法 (1).基于特征的迁移 (2).基于实例的迁移 (3).基于数据的迁移 (4).深度迁移学习 (5).强化迁移学习 (6).迁移学习的研究案例 (7).迁移学习的应用 (8).2017年AAAI最佳论文讲解：利用物理定理的知识迁移到视频理解

小马歌 2017-05-17 11:28 发表评论

TimSort in Java 7

小马歌 — Thu, 26 Feb 2015 10:46:00 GMT

from：http://www.lifebackup.cn/timsort-java7.html

2012年09月25日 21:57:48

1. 为什么写这篇文章

这篇文章的根源是在产品中发现了一个诡异的bug：只能在产品环境下重现，在我的本地开发环境无法重现，而双方的代码没有任何区别。最后用remote debug的方法找到异常所在：

Exception in thread "main" java.lang.IllegalArgumentException: Comparison
method violates its general contract!

Google了这个错误，是由于Java 7内置的新排序算法导致的。这才猛然想起产品的编译环境最近升级到了Java 7。

2. 结论

在Java 6中Arrays.sort()和Collections.sort()使用的是MergeSort，而在Java 7中，内部实现换成了TimSort，其对对象间比较的实现要求更加严格：

Comparator的实现必须保证以下几点（出自这儿）：

a). sgn(compare(x, y)) == -sgn(compare(y, x))
b). (compare(x, y)>0) && (compare(y, z)>0) 意味着 compare(x, z)>0
c). compare(x, y)==0 意味着对于任意的z：sgn(compare(x, z))==sgn(compare(y, z)) 均成立

而我们的代码中，某个compare()实现片段是这样的：

public int compare(ComparatorTest o1, ComparatorTest o2) {
return o1.getValue() > o2.getValue() ? 1 : -1;
}

这就违背了a)原则：假设X的value为1，Y的value也为1；那么compare(X, Y) ≠ –compare(Y, X)
PS: TimSort不仅内置在各种JDK 7的版本，也存在于Android SDK中（尽管其并没有使用JDK 7）。

3. 解决方案

3.1) 更改内部实现：例如对于上个例子，就需要更改为

public int compare(ComparatorTest o1, ComparatorTest o2) {
return o1.getValue() == o2.getValue() ? 0 :
(o1.getValue() > o2.getValue() ? 1 : -1);
}

3.2) Java 7预留了一个接口以便于用户继续使用Java 6的排序算法：在启动参数中（例如eclipse.ini）添加-Djava.util.Arrays.useLegacyMergeSort=true

3.3) 将这个IllegalArgumentException手动捕获住（不推荐）

4. TimSort在Java 7中的实现

那么为什么Java 7会将TimSort作为排序的默认实现，甚至在某种程度上牺牲它的兼容性（在stackoverflow上有大量的问题是关于这个新异常的）呢？接下来我们不妨来看一看它的实现。

首先建议大家先读一下这篇文章以简要理解TimSort的思想。

4.1) 如果传入的Comparator为空，则使用ComparableTimSort的sort实现。

4.2) 传入的待排序数组若小于MIN_MERGE（Java实现中为32，Python实现中为64），则

a) 从数组开始处找到一组连接升序或严格降序（找到后翻转）的数
b) Binary Sort：使用二分查找的方法将后续的数插入之前的已排序数组

4.3) 开始真正的TimSort过程：

4.3.1) 选取minRun大小，之后待排序数组将被分成以minRun大小为区块的一块块子数组

a) 如果数组大小为2的N次幂，则返回16（MIN_MERGE / 2）
b) 其他情况下，逐位向右位移（即除以2），直到找到介于16和32间的一个数

4.3.2) 类似于4.2.a找到初始的一组升序数列
4.3.3) 若这组区块大小小于minRun，则将后续的数补足（采用binary sort插入这个数组）
4.3.4) 为后续merge各区块作准备：记录当前已排序的各区块的大小
4.3.5) 对当前的各区块进行merge，merge会满足以下原则（假设X，Y，Z为相邻的三个区块）：

a) 只对相邻的区块merge
b) 若当前区块数仅为2，If X<=Y，将X和Y merge
b) 若当前区块数>=3，If X<=Y+Z，将X和Y merge，直到同时满足X>Y+Z和Y>Z

4.3.6) 重复4.3.2 ~ 4.3.5，直到将待排序数组排序完
4.3.7) Final Merge：如果此时还有区块未merge，则合并它们

5. Demo

这一节用一个具体的例子来演示整个算法的演进过程：

*注意*：为了演示方便，我将TimSort中的minRun直接设置为2，否则我不能用很小的数组演示。。。同时把MIN_MERGE也改成2（默认为32），这样避免直接进入binary sort。

初始数组为[7,5,1,2,6,8,10,12,4,3,9,11,13,15,16,14]
=> 寻找连续的降序或升序序列 (4.3.2)
[1,5,7] [2,6,8,10,12,4,3,9,11,13,15,16,14]
=> 入栈 (4.3.4)
当前的栈区块为[3]
=> 进入merge循环 (4.3.5)
do not merge因为栈大小仅为1
=> 寻找连续的降序或升序序列 (4.3.2)
[1,5,7] [2,6,8,10,12] [4,3,9,11,13,15,16,14]
=> 入栈 (4.3.4)
当前的栈区块为[3, 5]
=> 进入merge循环 (4.3.5)
merge因为runLen[0]<=runLen[1]
1) gallopRight：寻找run1的第一个元素应当插入run0中哪个位置（”2”应当插入”1”之后），然后就可以忽略之前run0的元素（都比run1的第一个元素小）
2) gallopLeft：寻找run0的最后一个元素应当插入run1中哪个位置（”7”应当插入”8”之前），然后就可以忽略之后run1的元素（都比run0的最后一个元素大）
这样需要排序的元素就仅剩下[5,7] [2,6]，然后进行mergeLow
完成之后的结果：
[1,2,5,6,7,8,10,12] [4,3,9,11,13,15,16,14]
=> 入栈 (4.3.4)
当前的栈区块为[8]
退出当前merge循环因为栈中的区块仅为1
=> 寻找连续的降序或升序序列 (4.3.2)
[1,2,5,6,7,8,10,12] [3,4] [9,11,13,15,16,14]
=> 入栈 (4.3.4)
当前的栈区块大小为[8,2]
=> 进入merge循环 (4.3.5)
do not merge因为runLen[0]>runLen[1]
=> 寻找连续的降序或升序序列 (4.3.2)
[1,2,5,6,7,8,10,12] [3,4] [9,11,13,15,16] [14]
=> 入栈 (4.3.4)
当前的栈区块为[8,2,5]
=>
do not merege run1与run2因为不满足runLen[0]<=runLen[1]+runLen[2]
merge run2与run3因为runLen[1]<=runLen[2]
1) gallopRight：发现run1和run2就已经排好序
完成之后的结果：
[1,2,5,6,7,8,10,12] [3,4,9,11,13,15,16] [14]
=> 入栈 (4.3.4)
当前入栈的区块大小为[8,7]
退出merge循环因为runLen[0]>runLen[1]
=> 寻找连续的降序或升序序列 (4.3.2)
最后只剩下[14]这个元素：[1,2,5,6,7,8,10,12] [3,4,9,11,13,15,16] [14]
=> 入栈 (4.3.4)
当前入栈的区块大小为[8,7,1]
=> 进入merge循环 (4.3.5)
merge因为runLen[0]<=runLen[1]+runLen[2]
因为runLen[0]>runLen[2]，所以将run1和run2先合并。（否则将run0和run1先合并）
1) gallopRight & 2) gallopLeft
这样需要排序的元素剩下[13,15] [14]，然后进行mergeHigh
完成之后的结果：
[1,2,5,6,7,8,10,12] [3,4,9,11,13,14,15,16] 当前入栈的区块为[8,8]
=>
继续merge因为runLen[0]<=runLen[1]
1) gallopRight & 2) gallopLeft
需要排序的元素剩下[5,6,7,8,10,12] [3,4,9,11]，然后进行mergeHigh
完成之后的结果：
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16] 当前入栈的区块大小为[16]
=>
不需要final merge因为当前栈大小为1
=>
结束

6. 如何重现文章开始提到的Exception

这一节将剥离复杂的业务逻辑，用一个最简单的例子（不修改TimSort.java内置的各种参数）重现文章开始提到的Exception。因为尽管google出来的结果中非常多的人提到了这个Exception及解决方案，但并没有人给出一个可以重现的例子和测试数据。另一方面，我也想从其他角度来加深对这个问题的理解。

构造测试数据的过程是个反人类的过程:( 大家不要学我。。

以下是能重现这个问题的代码：

public class ReproJava7Exception {
    public static void main(String[] args) {
        int[] sample = new int[]
              {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,0,-2,0,0,0,0};
        List list = new ArrayList();
        for (int i : sample)
            list.add(i);
        // use the native TimSort in JDK 7
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // miss the o1 = o2 case on purpose
                return o1 > o2 ? 1 : -1;
            }
        });
    }
}

7. Sample Code

这篇文章的所有代码可以到github：https://github.com/Huang-Wei/understanding-timsort-java7下载。

8. References

http://en.wikipedia.org/wiki/Timsort
http://www.geneffects.com/briarskin/theory/binary/index.html
http://docs.oracle.com/javase/6/docs/api/java/util/Comparator.html#compare%28T,%20T%29
http://www.oracle.com/technetwork/java/javase/compatibility-417013.html#source

分类：01呓语 | 标签： java、java7、timsort |

9条评论

hute说道：
三月 2, 20134:09 下午
太好了,找了一天.感谢.
hute说道：
三月 2, 20134:10 下午
重现bug的方法确实很逆天,作者花了很大力气吧.
superpippo说道：
三月 4, 201310:56 上午
@hute 所以说这个过程是很反人类的。。。
cjnetwork说道：
三月 13, 201311:41 下午
你好，我测试了一下你提供的测试代码，发现还是不能复现这个异常情况，能否帮忙一下呢。
以下是我的jdk：
java version “1.7.0-ea”
Java(TM) SE Runtime Environment (build 1.7.0-ea-b45)
Java HotSpot(TM) Client VM (build 14.0-b10, mixed mode, sharing)
superpippo说道：
三月 17, 20139:30 下午
@cjnetwork 我在jdk 1.7.0_17上用ReproJava7Exception.java能重现这个问题
我猜测你不能重现有两种可能：
1) 你的这个jdk版本有点诡异(1.7.0-ea)，尝试升到最1.7的正式版本
2) 确认你在编译时候使用的是JDK7，而不是JDK6 – 因为有可能在Eclipse或别的IDE中并没有设置正确。你可以写一段switch string的小例子看看有没有编译错误
ghsau说道：
十二月 21, 201411:06 上午
compare实现只需要这样:
return o1.getValue() – o2.getValue();
不需要自己判断.
superpippo说道：
一月 14, 201510:24 下午
@ghsau 是的

小马歌 2015-02-26 18:46 发表评论

[译]理解timsort, 第一部分：适应性归并排序(Adaptive Mergesort)

小马歌 — Thu, 26 Feb 2015 10:30:00 GMT

摘要: Python2.3中开始使用的timsort应该说算是声名在外了，不管是在稳定性还是在速度上都十分的惊人。前一段刚刚看了《Python CookBook》中的一些章节，对timsort产生了一些兴趣。于是在网上看到了这边文章，讲的相当清楚明了，于是产生了翻译的念头，也于是有了这篇文章。这应该算是我翻译的第一篇技术文章，真正做一次才明白能看懂和能翻译出来还是有蛮大的差距的。翻译质量不可谓不差，诸位如... 阅读全文

小马歌 2015-02-26 18:30 发表评论

OpenJDK 源代码阅读之 TimSort

小马歌 — Thu, 26 Feb 2015 07:59:00 GMT

摘要: 概要这个类在 Oracle 的官方文档里是查不到的，但是确实在 OpenJDK 的源代码里出现了，Arrays 中的 sort 函数用到了这个用于排序的类。它将归并排序(merge sort) 与插入排序(insertion sort) 结合，并进行了一些优化。对于已经部分排序的数组，时间复杂度远低于 O(n log(n))，最好可达&n... 阅读全文

小马歌 2015-02-26 15:59 发表评论