算法与数据结构大纲（设计与实现）

数据结构与算法目录：1.线性表;2.堆栈和队列;3.串;4.数组;5.递归算法;6.树和二叉树（遍历）;7.图; 8.排序;9.查找

  在Java编程语言中，最基本的结构就是两种，一种是数组，一种是模拟指针(引用)(链表),所有的数据结构都可以用这两个基本结构构造。
  java中的算法：循环和递归等。java中的数据结构：数组和链表。

 重点：二分查找，归并排序，快速排序。

> 核心算法：算法框架新特性。软件= 数据 + 一些数学的运算(算法).

理想中的算法工程师：提出假设->收集数据->训练模型->解释结果。

实际中的算法工程师：提出假设->收集数据->预处理->预处理->训练模型->调试->调试->重新收集数据->预处理->收集更多数据->调试->调试->调试->…->放弃。

-- 18届清华硕士狂拿18家互联网公司sp offer总结- http://blog.csdn.net/Ch97CKd/article/details/78557120
算法有ACM算法，AI的算法，算法水平。高级数据结构或算法？推荐算法相关的工作
一道约瑟夫环裸题，一道贪心，最后一道有点意思，是个图论里最大独立集的变体。
LCA的变种题，然后是一道BST转有序双向链表。零碎链表重组

以数理逻辑和数学问答题。直接无限背包 筛质数跟爬楼梯。

--   分治策略才是最基础的，动态规划、贪婪选择可以说是建立在其基础上的（算法导论中就按照分治策略、动态规划、贪婪选择的顺序来讲的）。
 1、分治策略（Divide and Conquer） 将原问题分解为若干个规模较小但类似于原问题的子问题（Divide），递归的求解这些子问题（Conquer），然后再合并这些子问题的解来建立原问题的解。因为在求解大问题时，需要递归的求小问题，因此一般用递归的思想实现，即自顶向下。
 2、动态规划（Dynamic Programming） 动态规划其实和分治策略是类似的，也是将一个原问题分解为若干个规模较小的子问题，递归的求解这些子问题，然后合并子问题的解得到原问题的解。区别在于这些子问题会有重叠，一个子问题在求解后，可能会再次求解，于是我们想到将这些子问题的解存储起来，当下次再次求解这个子问题时，直接拿过来就是。其实就是说，动态规划所解决的问题是分之策略所解决问题的一个子集，只是这个子集更适合用动态规划来解决从而得到更小的运行时间。即用动态规划能解决的问题分治策略肯定能解决，只是运行时间长了。因此，分治策略一般用来解决子问题相互对立的问题，称为标准分治，而动态规划用来解决子问题重叠的问题。 动态规划一般由两种方法来实现，一种为自顶向下的备忘录方式，用递归实现，一种为自底向上的方式，用迭代实现。
 3、贪心选择（Greedy Algorithm） 贪心算法在每一步都做出局部最优的选择，寄希望这样的选择能导致全局最优解。对，只是寄希望，因此贪心算法并不保证得到最优解，但是它对很多问题确实可以得到最优解，而且运行时间更短。那什么时候可以用贪心算法呢？当该问题具有贪心选择性质的时候，我们就可以用贪心算法来解决该问题。 贪心选择性质：我们可以通过做出局部最优（贪心）来构造全局最优。只要我们能够证明该问题具有贪心选择性质，就可以用贪心算法对其求解。比如对于0-1背包问题，我们用贪心算法可能得不到最优解（当然，也可能会得到最优解），但对于部分背包问题，则可以得到最优解，贪心算法可以作为0-1背包问题的一个近似算法。
 4、总结 分治策略一般用于解决子问题相互独立的情况，一般用递归实现；而动态规划则用户解决子问题有重叠的情况，既可以用递归实现，也可以用迭代实现，贪心选择则用户解决具有贪心选择性质的一类问题，既可以用递归实现，也可以用迭代实现，因为很多递归贪心算法都是尾递归，很容易改成迭代贪心算法。

-- 数据结构的实现-http://blog.longjiazuo.com/archives/category/code_language/java/shujujiegou
白话算法- http://blog.csdn.net/dd864140130/article/category/2689525
Algorithm - http://blog.csdn.net/u012515223/article/category/1932003
数学之美(数据结构和算法)- http://blog.csdn.net/a345017062/article/category/6227297
代码面试最常用的10大算法- http://blog.csdn.net/bboyfeiyu/article/details/23459985
数据结构和算法- http://blog.csdn.net/NUPTboyZHB/article/category/1295767
Algorithm- http://blog.csdn.net/sunboy_2050/article/category/694821
java算法- http://blog.csdn.net/lican19911221
Data Structure- http://blog.csdn.net/abcjennifer/article/category/684348
数据结构与算法- http://blog.csdn.net/xiangzhihong8/article/category/6170753
【数据结构与算法】- http://blog.csdn.net/mmc_maodun/article/category/1624373
【剑指offer】把数组排成最小的数- http://blog.csdn.net/mmc_maodun/article/category/2095669
算法设计与分析- http://blog.csdn.net/wangyaninglm/article/category/1696235
数据结构和算法- http://blog.csdn.net/RowandJJ/article/category/1460275
数据结构和算法- http://blog.csdn.net/RowandJJ/article/category/2393201

-- Arrays.sort(a);冒泡算法。

> 数据结构表和图的区别:
 表的存储结构是线型的; 树的存储结构是树型的; 图的存储结构是图型的;
 数据结构从大类上这三种，具体的，队列 栈 java的各种list 接口和类等也都是表的一种.

java中的数据结构和算法：循环和递归，数组和链表。

> 各种算法的原理？？  

  static、final、transient等关键字的作用，foreach循环的原理等,volatile关键字的底层实现原理?
  List、Map、Set，问的是各种实现类的底层实现原理，实现类的优缺点?
  ArrayList、LinkedList、Hashtable、HashMap、ConcurrentHashMap、HashSet的实现原理?
  ConcurrentHashMap的锁分段技术;读是否要加锁，为什么;迭代器是强一致性的迭代器还是弱一致性的迭代器?
  synchronized和ReentrantLock的区别、synchronized锁普通方法和锁静态方法、死锁的原理及排查方法等?

学习概率的时候，大家一定都学过马尔科夫模型吧。HMM一开始是在信息论中应用的，后来才被应用到自然语言处理还有其他图像识别等各个方面。下面举两个例子说明他的应用，一个是输入法的整句解码，一个是语音识别。

学习算法关键是我们要有一个正确的学习方法再结合着实战项目就可以快速的提升自己的技战水平。

学习大纲

  算法与数据结构的设计与实现 【数据结构、 抽象数据类型、算法（时间与空间复杂度）】- 性能与内存（内存和持久化）

数列 集合 字符串匹配 线性规划 散列（哈希） 分治 贪心 动态规划 图  马尔可夫模型 最大熵模型

  存储结构-基于动态数组的数据结构和基于链表的数据结构。存储节点的数据元素和节点之间的逻辑关系。

--数据结构有：数组、栈、链表、队列、树、堆、图、散列表等；

--算法的设计范型：分治、动态、贪心、线性、图论、简化等；

--算法的实现方式：递归、迭代、平行、序列、过程、确定、不确定等；

数据结构与算法目录：1.线性表;2.堆栈和队列;3.串;4.数组;5.递归算法;6.树和二叉树（遍历）;7.图; 8.排序;9.查找

> 1.线性表

  在任意位置进行插入和删除、由N个相同类型数据元素。顺序存储结构使用的是数组实现，而链式存储结构使用的是链表实现。

1.线性表的顺序（存储）表示； 

   线性表的顺序存储结构之顺序表类的实现（Java） -- http://blog.csdn.net/angelhacker/article/details/6596069（接口） ， http://blog.csdn.net/angelhacker/article/details/6596080 （接口的实现） 
    顺序表实现解约瑟夫环_Java -- http://blog.csdn.net/angelhacker/article/details/6646301

2.线性表的链式（存储）表示（单链表、循环单链表、双向链表）；

  链式存储：实现数据元素之间的次序关系依靠指针。

    链式存储结构的线性表将采用一组任意的存储单元存放线性表中的数据元素。由于不需要按顺序存储，链表在插入、删除数据元素时比顺序存储要快，但是在查找一个节点时则要比顺序存储要慢。
  使用链式存储可以克服顺序线性表需要预先知道数据大小的缺点，链表结构可以充分利用内存空间，实现灵活的内存动态管理。但是链式存储失去了数组随机存取的特点，同时增加了节点的指针域，空间开销较大。

    线性表的Java实现--链式存储（单向链表）-- http://hoxis.iteye.com/blog/2044524
    线性表链式存储 代码获取地址：https://github.com/liuhao123/JavaMore.git (哈夫曼树的java实现/希尔排序的Java实现/普通树的父节点表示法实现)

    线性表的顺序存储结构（java版）http://hjj20040849.iteye.com/blog/1816838
    线性表的链式存储结构（java版）http://hjj20040849.iteye.com/blog/1816941

3.静态链表

  申请节点的内存空间的方式是静态的。

Java数据结构-线性表之静态链表 http://blog.csdn.net/yannanying/article/details/46956355

    -- 线性表 及Java实现 顺序表、链表、栈、队列-- http://www.cnblogs.com/yaowen/p/4272310.html

 

> 2.堆栈和队列

1.堆栈（顺序和链式表示）；

  堆栈是一种特殊类型的线性表，后进先出表（栈顶，栈底）

    Java栈的实现（顺序栈、链式栈）及栈的应用 http://blog.csdn.net/jiutianhe/article/details/18605999
    顺序堆栈的实现及测试 http://blog.sina.com.cn/s/blog_6d4bfb040100mawh.html
    java实现顺序栈 http://www.cnblogs.com/lixiaolun/p/4644134.html
    数据结构：列举所有出栈顺序（java实现） http://blog.sina.com.cn/s/blog_69b6a7c60100v7wl.html

2.堆栈（括号匹配、表达式计算）；

3.队列（顺序队列、顺序循环队列；链式队列）；

  队列是一种特殊类型的线性表，先进先出表。

    【数据结构】之队列的java实现（一） http://blog.csdn.net/wuwenxiang91322/article/details/12259099
    【数据结构】之队列的java实现（二） http://blog.csdn.net/wuwenxiang91322/article/details/12303111
     java 队列实现 http://blog.csdn.net/sky_zhangfan/article/details/3959847
     Java实现队列_队列内部使用链式存储结构 http://my.oschina.net/xinxingegeya/blog/314716

4.优先级队列（顺序优先级队列）

    优先级队列是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。PriorityQueue是从JDK1.5开始提供的新的数据结构接口。如果不提供Comparator的话，优先队列中元素默认按自然顺序排列，也就是数字默认是小的在队列头，字符串则按字典序排列。
    java数据结构－利用Heap（堆）实现PriorityQueue（优先队列）-- http://wushan0801-139-com.iteye.com/blog/1450072
    Java优先级队列实现-- http://blog.csdn.net/a19881029/article/details/22667139
    索引优先队列的实现 --http://blog.csdn.net/mba16c35/article/details/42489775
   （数据结构与算法分析 七）------优先队列中的二叉堆的实现（ Java语言描述）-- http://blog.csdn.net/a352193394/article/details/7210435

> 3.串

  N个字符组成的有限序列。

1. 串的存储：顺序存储和链式存储；

2. 串的模式匹配算法（Brute-Force算法、KMP算法）

  字符串模式匹配算法:正则表达式也是必须掌握的一种概念和编程技术。
  字符串匹配算法总结 (分析及Java实现)-- http://blog.csdn.net/chndata/article/details/43792363
  字符串模式匹配-- http://www.cnblogs.com/jingmoxukong/p/4343770.html

 

> 4.数组

  相同的数据类型的数据元素占用一块地址连续的内存单元的有限序列。

1. 动态数组和静态数组；

  ArrayList作为Java动态数组的用法；int score[]=new int[3]; 

2. 特殊矩阵的压缩存储；

  数据结构：矩阵的压缩存储（特殊矩阵）http://blog.csdn.net/s634772208/article/details/45578863

3. 稀疏矩阵的压缩存储（稀疏矩阵的三元组顺序表，稀疏矩阵的三元组链表）

  稀疏矩阵压缩存储 http://blog.csdn.net/taohuaxinmu123/article/details/20696301
  三元组表压缩存储稀疏矩阵实现稀疏矩阵的快速转置(Java语言描述)-- http://www.cnblogs.com/wxisme/p/4363790.html
  压缩感知进阶——有关稀疏矩阵-- http://blog.csdn.net/abcjennifer/article/details/7748833

 

> 5.递归算法

  一个算法直接或间接的调用本身。

1. 递归算法与非递归算法的转换

   斐波纳契数列（Fibonacci Sequence）用递归和非递归方法求n的阶乘
递归
   public int factorial(int m)
     {
               if (m < 0)
                     return 0;
               else if ( m == 1)
                     reteurn 1;
                else if (m > 1)
                    return m * factorial(m-1);
     }
非递归
   public int factorial(int m){
               if (m < 0)
                     return 0;
               else if ( m == 1)
                     reteurn 1;
                else if (m > 1){ 
  int sum = 1
  for (int i = 2; i <= m; i++)
        sum = sum * i;
   return sum;
}
}

2. 一般递归算法与回溯法

  回溯法求解N皇后问题（Java实现）http://haolloyin.blog.51cto.com/1177454/353105/
  java写的回溯法求迷宫问题 http://www.cnblogs.com/rollenholt/archive/2011/08/23/2151202.html 

 

> 6.树和二叉树（遍历） -- 什么是二叉查找树、什么是平衡树，AVL树和红黑树的区别？

  树结构表示了数据元素之间的层次关系。

java数据结构与算法系列文章目录(持续更新)- https://github.com/shinezejian/javaStructures
【数据结构】之二叉树的java实现- http://blog.csdn.net/wuwenxiang91322/article/details/12231657
java数据结构与算法之树基本概念及二叉树（BinaryTree）的设计与实现- http://blog.csdn.net/javazejian/article/details/53727333

1. 二叉树的存储；

    java实现树（链式存储）http://blog.csdn.net/jdhanhua/article/details/6606815

2. 二叉树的遍历（前序、中序、后序遍历）；

  **【数据结构】之二叉树的java实现-- http://blog.csdn.net/wuwenxiang91322/article/details/12231657
  二叉树的顺序存储及其Java实现-- http://blog.csdn.net/bruce_6/article/details/38111321
  二叉树的表示和实现-- http://www.cnblogs.com/archimedes/p/binary-tree.html
  java版 二叉树 所有递归和非递归遍历算法: http://blog.csdn.net/cuikai314/article/details/7945607
  Java实现二叉树的多种遍历-- http://blog.csdn.net/anialy/article/details/8145114

 

3. 线索二叉树（中序线索二叉树）；

  Java实现特殊二叉树之线索二叉树-- http://blog.csdn.net/jiangnan2014/article/details/38656803

 

4. 哈夫曼树（哈夫曼编码）-最优二叉树；

  最小带权路径长度的二叉树。

  【code】java创建哈夫曼树和实现哈夫曼编码-- http://justsee.iteye.com/blog/1106693
  哈夫曼树（最优二叉树）及其Java实现-- http://blog.csdn.net/bruce_6/article/details/38656413
  哈夫曼树的java实现-- http://blog.csdn.net/jdhanhua/article/details/6621026

  线性表链式存储 代码获取地址：https://github.com/liuhao123/JavaMore.git (哈夫曼树的java实现/希尔排序的Java实现/普通树的父节点表示法实现)

 

5. 树与二叉树的转换

 

> 7.图

  图由节点集合及结点间的关系集合组成的一种数据结构，是非线性的，数据元素之间的关系是多对多的。

图的表示方法: 
DG（有向图）或者DN（有向网）：邻接矩阵、邻接表（逆邻接表--为求入度）、十字链表 
UDG（无向图）或者UDN（无向网）：邻接矩阵、邻接表、邻接多重表 

1. 图的存储（图的邻接矩阵存储和图的邻接表的存储）

  图的理解：存储结构与邻接矩阵的Java实现-- https://segmentfault.com/a/1190000002685782
  邻接表存储图Java实现-- http://blog.csdn.net/liangxiamoyi/article/details/52154842

 

2. 图的遍历

  图的理解：深度优先和广度优先遍历及其 Java 实现-- https://segmentfault.com/a/1190000002685939
  java图的遍历方式(深度遍历、广度遍历)-- http://blog.csdn.net/wang171838/article/details/16802417

3. 最小生成树

  普利姆算法、克鲁斯卡尔算法

    Prim算法(三)之 Java详解- http://www.cnblogs.com/skywang12345/p/3711510.html  http://blog.csdn.net/timmy_zzh/article/details/53316814
最小生成树的Prim算法和Kruskal算法java代码实现- http://blog.csdn.net/witsmakemen/article/details/8889256  http://blog.csdn.net/jianfpeng241241/article/details/50452680
    在图形应用中，常常需要求从图中某个结点至其余各结点的最短路径，如对于一个物流配送系统计算从配送中心到各订货点的最短路径。
Dijkstra's Algorithm 基本思想：
若给定带权有向图G=(V,E)和源顶点v0，构筑一个源集合S，将v0加入其中。
① 对差集V\S中 个顶点vi，逐一计算从v0 至它的距离 D(v0 , vi ),若该两顶点之间没有边，则其距离为无穷大。求出其中距离最短      的顶点w，将其加入到集合 S 中。
② 重新计算 v0 至差集 V\S 中各顶点的距离 D（v0, vi ）= Min(D(v0, vi ), D(v0, w ) + C(w, vi )).其中C（w, vi ）是顶点w 与 vi 之      间边上的费用。
③ 重复 步骤①②。直至所有的顶点都加到集合S 中为止。

 

4. 最短路径

  迪克斯特拉算法

 

> 8.排序

  关键字分主关键字和次关键字。排序分内部排序和外部排序。

排序算法：内部和外部排序

1. 插入排序（直接插入排序与希尔排序）

    直接插入原理：从初始有序的子集合开始，不断的把新的数据元素插入到已排序有序的子集合的合适位置上，（子集合的数据元素个数从只有一个数据元素开始逐次增大，）使子集合中的数据元素的个数不断增多，当子集合等于集合时，插入排序算法结束。
    希尔排序原理：把待排序的数据元素分为若干个小组，对同一小组内的数据元素直接用直接插入排序；小组的个数逐次缩小，当完成了所有数据元素都在一个组内的排序后的排序过程结束。希尔排序又称为缩小量排序。

  经典（Java版）排序算法的分析及实现之一直接插入排序-- http://www.linuxidc.com/Linux/2014-12/110429.htm 
  直接插入排序的三种实现  http://www.oschina.net/code/snippet_131893_15742
  程序员必知的8大排序(一)-------直接插入排序，希尔排序（java实现）-- http://blog.csdn.net/pzhtpf/article/details/7559896

  该方法实质上是一种分组插入方法。
  Java实现希尔排序 http://www.cnblogs.com/hxsyl/p/3309615.html
  数据结构——希尔排序原理及Java实现  http://blog.chinaunix.net/uid-20384806-id-1954177.html

  线性表链式存储 代码获取地址：https://github.com/liuhao123/JavaMore.git (哈夫曼树的java实现/希尔排序的Java实现/普通树的父节点表示法实现)

2. 选择排序（直接选择排序和堆排序）

    直接选择排序原理：从待排序的数据元素集合中选取关键字最小的数据元素并将它与原始数据元素集合的第一个数据元素交换位置；然后从不包括第一个位置的数据元素集合中选取关键字最小的数据元素集合并将它与原始数据集合中的第二个数据元素交换位置；如此重复，直到数据元素集合中只剩下一个元素为止。
    堆排序原理：在直接选择排序中，待排序的数据元素集合构成一个线性结构，要从有N个数据元素的线性表中选择出一个最小的数据元素需要比较N-1次。如果把待排序的数据元素集合构成一个完全二叉树结构，则每次选择出最大（或最小）的数据元素只需比较完全二叉树的数值为高度的次数，即nlong2n，所以排序算法的时间复杂度就是O（nlong2n）.

  java实现选择排序-- http://blog.csdn.net/wangkuifeng0118/article/details/7289594
  java实现排序算法之选择排序（直接选择排序、堆排序）-- http://zengzhaoshuai.iteye.com/blog/1171921

  堆排序(Heapsort)之Java实现-- http://blog.csdn.net/kimylrong/article/details/17150475

 

3. 交换排序（冒泡排序和快速排序）

    冒泡排序的原理:设数组a中存放了N个数据元素，循环进行N-1次如下排序过程：第一次时，依次比较相邻两个数据元素a[i].key和a[i+1].key（i=0,1,2,...,n-2）,若为逆序，即a[i].key>a[i+1].key，则交换两个数据元素，否则不交换，这样，当作完n-1次比较后数值最大的数据元素将放置在a[n-1]中。第二次时，数据元素个数减去1，即数据元素的个数为n-1，操作方法与第一次类似，这样N个数据元素中数值次大的数据元素被放置在a[n-2]中。当第n-1次排序结束时，n个数据元素集合中次小的数据元素被放置在a[1]中，而a[0]中放置了最小的数据元素。 
    快速排序是一种二叉树结构的交换排序算法。
    快速排序原理：设数组a中存放了N个数据元素，Low为数组的低端下标，High为数组的高端下标，从数组a中任取一个元素（通常取a[low]）作为标准，调整数组a中各个元素的位置，使排在标准元素前面元素的关键字均小于标准元素的关键字，排在标准元素后面元素的关键字均大于等于标准元素的关键字;再将左右两边的数组各分成两个子数组，再用相同的方法递归快速排序。

 

Java实现冒泡排序算法  http://blog.163.com/yurong_1987@126/blog/static/475178632008615054342/
快速排序算法Java实现 http://www.cnblogs.com/vanezkw/archive/2012/06/21/2557685.html

 

4. 归并排序

    归并排序主要是二路归并排序。二路归并排序的思想：设数组a中存放了N个数据元素，初始时把他们看成N个长度为1的有序子数组，然后从第一个子数组开始，把相邻的子数组两两合并，得到n/2的整数上界个长度为2的新的有序子数组（当N为奇数时最后一个新的有序子数组的长度为1）；对这些新的有序子数组再两两归并；如此重复，直到得到一个长度为N的有序数组。多于二路归并排序方法和二路归并方法类同。

 

  归并排序建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
  归并排序算法介绍 http://blog.csdn.net/kimylrong/article/details/17127441

5. 基数排序

    基数排序也称桶排序，是一种当关键字为整数类型时非常高效的排序方法。
    基数排序的思想：设排序的数据元素关键字是M位D进制整数（不足M位的关键字在高位补0）设置D个桶，令其编号分别为0，1，2，...,D-1。首先，按关键字最低位的数值依次把各数据元素放到相应的桶中；然后按照桶号从小到大和进入桶中数据元素的先后顺序收集分配在各桶中的数据元素；这样，就形成了数据元素集合的一个新的排列，称这样一次排序过程为一次基数排序。再对一次基数排序得到的数据元素序列按关键字次低位的数值依次把各数据元素放到相应的桶中，然后再按照桶号从小到大和进入桶中的数据元素的先后次数分配在各桶中的数据元素。这样重复进行，当完成了第M次基数排序后，就得到排序好的数据元素序列。

 

   Java排序算法（十一）：基数排序 http://blog.csdn.net/apei830/article/details/6596104 

 

> 9.查找

    主关键字和次关键字。

1. 静态查找表（顺序表、有序顺序表、索引顺序表）-二分查找。

  静态查找表与动态查找表-- http://blog.csdn.net/zhangkongzhongyun/article/details/21958581

 

2. 动态查找表（二叉排序树、B_树）

  Java 创建动态类和查看方法列表信息 http://blog.csdn.net/alex_zhuang/article/details/7071834
  查找算法总结之二（动态查找表）http://blog.csdn.net/jerryburning/article/details/46636479

 

3. 哈希表（构造与冲突解决）

  Java中哈希表(Hashtable)是如何实现的 http://www.cnblogs.com/goodwin/p/4102702.html
  用java实现的哈希表（散列表） http://blog.csdn.net/kavensu/article/details/8053873

 

> 10.文件

1. 文件的存储介质

 

如软盘、光盘、DVD、硬盘、闪存、U盘、CF卡、SD卡、MMC卡、SM卡、记忆棒(Memory Stick)、XD卡等MMC卡、SM卡、记忆棒(Memory Stick)、XD卡等

 

2. 顺序文件

 

3. 索引文件

 

4. ISAM文件

5. VSAM文件

6. 散列文件

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

拓展：

隐马尔可夫模型 (Hidden Markov Model，HMM) 最初由 L. E. Baum 和其它一些学者发表在一系列的统计学论文中，随后在语言识别，自然语言处理以及生物信息等领域体现了很大的价值。

 

> 排列组合

java 高效率的排列组合算法（java实现）- http://blog.csdn.net/songylwq/article/details/12706183
高效率的排列组合算法（java实现）- http://blog.csdn.net/wmj2003/article/details/3678941
排列与组合的Java递归实现 (参考)- http://www.cnblogs.com/longhs/archive/2013/06/14/3135433.html
Java实现排列组合算法- http://blog.csdn.net/yhyr_ycy/article/details/52523243