《剑指offer》内容总结

（1）剑指Offer——Trie树(字典树)

Trie树

    Trie树，即字典树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。

    Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。

    Trie树也有它的缺点，Trie树的内存消耗非常大。当然，或许用左儿子右兄弟的方法建树的话，可能会好点。可见，优化的点存在于建树过程中。

 和二叉查找树不同，在trie树中，每个结点上并非存储一个元素。trie树把要查找的关键词看作一个字符序列，并根据构成关键词字符的先后顺序构造用于检索的树结构。在trie树上进行检索类似于查阅英语词典。

3个基本性质

   1.根节点不包含字符，每条边代表一个字符。

   2.从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串。

   3.每个节点的所有子节点包含的字符都不相同。

字典树的构建

  题目：给你100000个长度不超过10的单词。对于每一个单词，我们要判断他出没出现过，如果出现了，求第一次出现在第几个位置。

  分析：这题当然可以用hash来解决，但是本文重点介绍的是trie树，因为在某些方面它的用途更大。比如说对于某一个单词，我们要询问它的前缀是否出现过。这样hash就不好搞了，而用trie还是很简单。

  假设我要查询的单词是abcd，那么在他前面的单词中，以b，c，d，f之类开头的我显然不必考虑。而只要找以a开头的中是否存在abcd就可以了。同样的，在以a开头中的单词中，我们只要考虑以b作为第二个字母的，一次次缩小范围和提高针对性，这样一个树的模型就渐渐清晰了。

  好比假设有b，abc，abd，bcd，abcd，efg，hii 这6个单词，我们构建的树就是如下图这样的（图片来自百度百科）：

 

    如上图所示，对于每一个节点，从根遍历到他的过程就是一个单词，如果这个节点被标记为红色，就表示这个单词存在，否则不存在。

    那么，对于一个单词，我只要顺着他从根走到对应的节点，再看这个节点是否被标记为红色就可以知道它是否出现过了。把这个节点标记为红色，就相当于插入了这个单词。

    这样一来我们查询和插入可以一起完成（重点体会这个查询和插入是如何一起完成的，稍后，下文具体解释）。

  我们可以看到，trie树每一层的节点数是26^i（26个英文字母）级别的。所以为了节省空间，我们用动态链表，或者用数组来模拟。空间的花费，不会超过单词数×单词长度。

  已知n个由小写字母构成的平均长度为10的单词,判断其中是否存在某个串为另一个串的前缀子串。下面对比3种方法：

  最容易想到的：1.即从字符串集中从头往后搜，看每个字符串是否为字符串集中某个字符串的前缀，复杂度为O(n^2)。

  2.使用hash：我们用hash存下所有字符串的所有前缀子串，建立存有子串hash的复杂度为O(n*len)，而查询的复杂度为O(n)* O(1)= O(n)。

  3.使用trie：因为当查询如字符串abc是否为某个字符串的前缀时，显然以b,c,d....等不是以a开头的字符串就不用查找了。所以建立trie的复杂度为O(n*len)，而建立+查询在trie中是可以同时执行的，建立的过程也就可以称为查询的过程，hash就不能实现这个功能。所以总的复杂度为O(n*len)，实际查询的复杂度也只是O(len)。（说白了，就是Trie树的平均高度h为len，所以Trie树的查询复杂度为O（h）=O（len）。好比一棵二叉平衡树的高度为logN，则其查询，插入的平均时间复杂度亦为O（logN））。

查询

    Trie树是简单但实用的数据结构，通常用于实现字典查询。我们做即时响应用户输入的AJAX搜索框时，就是Trie树。本质上，Trie是一棵存储多个字符串的树。相邻节点间的边代表一个字符，这样树的每条分支代表一则子串，而树的叶节点则代表完整的字符串。和普通树不同的地方是，相同的字符串前缀共享同一条分支。下面，再举一个例子。给出一组单词，inn, int, at, age, adv, ant, 我们可以得到下面的Trie：

 

    可以看出：

    每条边对应一个字母。

    每个节点对应一项前缀。叶节点对应最长前缀，即单词本身。

  单词inn与单词int有共同的前缀“in”, 因此他们共享左边的一条分支，root->i->in。同理，ate, age, adv, 和ant共享前缀"a"，所以他们共享从根节点到节点"a"的边。

  查询操纵非常简单。比如要查找int，顺着路径i -> in -> int就找到了。

  搭建Trie的基本算法也很简单，无非是逐一把每个单词的每个字母插入Trie。插入前先看前缀是否存在。如果存在，就共享，否则创建对应的节点和边。比如要插入单词add，就有下面几步：

  考察前缀"a"，发现边a已经存在。于是顺着边a走到节点a。

  考察剩下的字符串"dd"的前缀"d"，发现从节点a出发，已经有边d存在。于是顺着边d走到节点ad

  考察最后一个字符"d"，这下从节点ad出发没有边d了，于是创建节点ad的子节点add，并把边ad->add标记为d。

查找分析

  在trie树中查找一个关键字的时间和树中包含的结点数无关，而取决于组成关键字的字符数。而二叉查找树的查找时间和树中的结点数有关O(log₂n)。

    如果要查找的关键字可以分解成字符序列且不是很长，利用trie树查找速度优于二叉查找树。例如：若关键字长度最大是5，则利用trie树，利用5次比较可以从26^5＝11881376个可能的关键字中检索出指定的关键字。而利用二叉查找树至少要进行次比较。

应用

1. 字符串检索，词频统计，搜索引擎的热门查询

  事先将已知的一些字符串（字典）的有关信息保存到trie树里，查找另外一些未知字符串是否出现过或者出现频率。

   举例：

    1、有一个1G大小的一个文件，里面每一行是一个词，词的大小不超过16字节，内存限制大小是1M。返回频数最高的100个词。

    2、给出N 个单词组成的熟词表，以及一篇全用小写英文书写的文章，请你按最早出现的顺序写出所有不在熟词表中的生词。

    3、给出一个词典，其中的单词为不良单词。单词均为小写字母。再给出一段文本，文本的每一行也由小写字母构成。判断文本中是否含有任何不良单词。例如，若rob是不良单词，那么文本problem含有不良单词。

    4、1000万字符串，其中有些是重复的，需要把重复的全部去掉，保留没有重复的字符串。请怎么设计和实现？

    5、一个文本文件，大约有一万行，每行一个词，要求统计出其中最频繁出现的前10个词，请给出思想，给出时间复杂度分析。

    6、寻找热门查询：搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。假设目前有一千万个记录，这些查询串的重复读比较高，虽然总数是1千万，但是如果去除重复和，不超过3百万个。一个查询串的重复度越高，说明查询它的用户越多，也就越热门。请你统计最热门的10个查询串，要求使用的内存不能超过1G(京东笔试题简答题与此类似)。

    (1) 请描述你解决这个问题的思路；

    (2) 请给出主要的处理流程，算法，以及算法的复杂度。

2. 字符串最长公共前缀

    Trie树利用多个字符串的公共前缀来节省存储空间，反之，当我们把大量字符串存储到一棵trie树上时，我们可以快速得到某些字符串的公共前缀。举例：

    1) 给出N 个小写英文字母串，以及Q 个询问，即询问某两个串的最长公共前缀的长度是多少.  解决方案：

  首先对所有的串建立其对应的字母树。此时发现，对于两个串的最长公共前缀的长度即它们所在结点的公共祖先个数，于是，问题就转化为了离线（Offline）的最近公共祖先（Least Common Ancestor，简称LCA）问题。

    而最近公共祖先问题同样是一个经典问题，可以用下面几种方法：

      1. 利用并查集（Disjoint Set），可以采用经典的Tarjan 算法；

      2. 求出字母树的欧拉序列（Euler Sequence ）后，就可以转为经典的最小值查询（Range Minimum Query，简称RMQ）问题了；

3.  排序

      Trie树是一棵多叉树，只要先序遍历整棵树，输出相应的字符串便是按字典序排序的结果。

      举例：给你N 个互不相同的仅由一个单词构成的英文名，让你将它们按字典序从小到大排序输出。

4. 作为其他数据结构和算法的辅助结构

   如后缀树，AC自动机等。

举例

   下面以字典树的构建与单词查找为例。

 

TrieTreeNode.java

 

 

package cn.edu.ujn.trieTree;

public class TrieTreeNode {
    int nCount; //记录该字符出现次数
    char ch; //记录该字符
    TrieTreeNode[] child;   // 记录子节点
    final int MAX_SIZE = 26;
    public TrieTreeNode() {
        nCount=1;
        child = new TrieTreeNode[MAX_SIZE];
    }
}

 

TrieTree.java

 

package cn.edu.ujn.trieTree;

public class TrieTree {
    //字典树的插入和构建
    public void createTrie(TrieTreeNode node,String str){
        if (str == null || str.length() == 0) {
            return;
        }
        char[] letters = str.toCharArray();
        for (int i = 0; i < letters.length; i++) {
            int pos = letters[i] - 'a';   // 用相对于a字母的值作为下标索引，也隐式地记录了该字母的值
            if (node.child[pos] == null) {
                node.child[pos] = new TrieTreeNode();
            }else {
                node.child[pos].nCount++;
            }
            node.ch = letters[i];
            node = node.child[pos];
        }
    }

    //字典树的查找
    public int findCount(TrieTreeNode node,String str){
        if (str == null || str.length() == 0) {
            return -1;
        }
        char[] letters = str.toCharArray();
        for (int i = 0; i < letters.length; i++) {
            int pos = letters[i] - 'a';
            if (node.child[pos] == null) {
                return 0;
            }else {
                node = node.child[pos];
            }
        }
        return node.nCount;
    }

}

 

Test.java

 

package cn.edu.ujn.trieTree;

public class Test {
public static void main(String[] args) {
/**
 * Problem Description 老师交给他很多单词(只有小写字母组成,不会有重复的单词出现),现在老师要他统计
 * 出以某个字符串为前缀的单词数量(单词本身也是自己的前缀).
 */
String[] strs = { "banana", "band", "bee", "absolute", "acm" };
String[] prefix = { "ba", "b", "band", "abc" };
TrieTree tree = new TrieTree();
TrieTreeNode root = new TrieTreeNode();

for (String s : strs) {
tree.createTrie(root, s);
}
// tree.printAllWords();
for (String pre : prefix) {
int num = tree.findCount(root, pre);
System.out.println(pre + " " + num);
}
}
}

 

小结

  看过上面的代码，是否发现这个代码有什么问题呢？尽管这个实现方式查找的效率很高，时间复杂度是O(m)，m是要查找的单词中包含的字母的个数。但是确浪费大量存放空指针的存储空间。因为不可能每个节点的子节点都包含26个字母的。所以对于这个问题，字典树存在的意义是解决快速搜索的问题，所以采取以空间换时间的作法也毋庸置疑。

    Trie树占用内存较大，例如：处理最大长度为20、全部为小写字母的一组字符串，则可能需要 2620 个节点来保存数据。而这样的树实际上稀疏的十分厉害，可以采用左儿子右兄弟的方式来改善，也可以采用需要多少子节点则添加多少子节点来解决（不要类似网上的示例，每个节点初始化时就申请一个长度为26的数组）。

Wiki上提到了采用三数组Trie(Tripple-Array Trie)和二数组Trie(Double-Array Trie)来解决该问题，此外还有压缩等方式来缓解该问题。

示例优化

TrieTreeNode.java

 

 

package cn.edu.ujn.trieTreeMap;

import java.util.HashMap;
import java.util.Map;

public class TrieNode {
    int nCount; //记录该字符出现次数
    Map<Character, TrieNode> childdren;   // 记录子节点
    public TrieNode() {
        nCount = 1;
        childdren = new HashMap<Character, TrieNode>();
    }
}

 

TrieTree.java

 

 

package cn.edu.ujn.trieTreeMap;

// 利用Map动态创建节点
public class TrieTree {

    // 字典树的插入和构建
    public void insert(TrieNode node, String word) {
        for (int i = 0; i < word.length(); i++) {
            Character c = new Character(word.charAt(i));
            if (!node.childdren.containsKey(c)) {
                node.childdren.put(c, new TrieNode());
            }else{
                node.childdren.get(c).nCount++;
            }
            node = node.childdren.get(c);
        }
    }

    // 字典树的查找
    public int search(TrieNode node, String word) {
        for (int i = 0; i < word.length(); i++) {
            Character c = new Character(word.charAt(i));
            if (!node.childdren.containsKey(c)) {
                return 0;
            }
            node = node.childdren.get(c);
        }
        return node.nCount;
    }

}

 

Test.java

 

package cn.edu.ujn.trieTreeMap;

public class Test {
public static void main(String[] args) {
/**
 * Problem Description 老师交给他很多单词(只有小写字母组成,不会有重复的单词出现),现在老师要他统计
 * 出以某个字符串为前缀的单词数量(单词本身也是自己的前缀).
 */
String[] strs = { "banana", "band", "bee", "absolute", "acm" };
String[] prefix = { "ba", "b", "band", "abc" };
TrieTree tree = new TrieTree();
TrieNode node = new TrieNode();
for (String s : strs) {
tree.insert(node, s);
}
// tree.printAllWords();
for (String pre : prefix) {
int num = tree.search(node, pre);
System.out.println(pre + " " + num);
}
}
}

 

计算结果如下：

 

  经过以上方法的改进，可避免冗余节点的存在。将字典树的优势进一步放大。当然，也可以使用左儿子右兄弟的形式创建字典树。此方法后续介绍~

文件读入

 

package cn.edu.ujn.trieTreeMap;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public class Test {
public static void main(String[] args) {
/**
 * Problem Description 老师交给他很多单词(只有小写字母组成,不会有重复的单词出现),现在老师要他统计
 * 出以某个字符串为前缀的单词数量(单词本身也是自己的前缀).
 */
String[] strs = { "banana", "band", "bee", "absolute", "acm" };
String[] prefix = { "网易", "软件", "band", "abc" };
TrieTree tree = new TrieTree();
TrieNode node = new TrieNode();
        BufferedReader br = null;
        try {
            File file= new File("C://Users//SHQ//Desktop//Offer.txt");
            //读取语料库words.txt
            br = new BufferedReader(new InputStreamReader(new FileInputStream(file.getAbsolutePath()),"GBK"));
            String word="";
            while ((word = br.readLine()) != null) {
                tree.insert(node, word);
            }
        }catch (Exception e) {
// TODO: handle exception
            e.printStackTrace();
}
/*for (String s : strs) {
tree.insert(node, s);
}*/
// tree.printAllWords();
for (String pre : prefix) {
int num = tree.search(node, pre);
System.out.println(pre + " " + num);
}
}
}

 

计算结果如下:

 

    Offer.txt文本内容如下:

 

    可知计算结果正确。而且出现了中文字符，对于数字的操作同理。而利用第一种方法就无法实现固定分配内存。只能使用动态分配机制。

 

 

 

（2）剑指Offer——分治算法

基本概念

    在计算机科学中，分治法是一种很重要的算法。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算法(快速排序，归并排序)，傅立叶变换(快速傅立叶变换)……

    任何一个可以用计算机求解的问题所需的计算时间都与其规模有关。问题的规模越小，越容易直接求解，解题所需的计算时间也越少。例如，对于n个元素的排序问题，当n=1时，不需任何计算。n=2时，只要作一次比较即可排好序。n=3时只要作3次比较即可，…。而当n较大时，问题就不那么容易处理了。要想直接解决一个规模较大的问题，有时是相当困难的。

基本思想及策略

    分治法的设计思想是：将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。

    分治策略是：对于一个规模为n的问题，若该问题可以容易地解决（比如说规模n较小）则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立且与原问题形式相同，递归地解这些子问题，然后将各子问题的解合并得到原问题的解。这种算法设计策略叫做分治法。

    如果原问题可分割成k个子问题，1<k≤n，且这些子问题都可解并可利用这些子问题的解求出原问题的解，那么这种分治法就是可行的。由分治法产生的子问题往往是原问题的较小模式，这就为使用递归技术提供了方便。在这种情况下，反复应用分治手段，可以使子问题与原问题类型一致而其规模却不断缩小，最终使子问题缩小到很容易直接求出其解。这自然导致递归过程的产生。分治与递归像一对孪生兄弟，经常同时应用在算法设计之中，并由此产生许多高效算法。

分治法适用的情况

    分治法所能解决的问题一般具有以下几个特征：

    1) 该问题的规模缩小到一定的程度就可以容易地解决；

    2) 该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质；

    3) 利用该问题分解出的子问题的解可以合并为该问题的解；

    4) 该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题；

    第一条特征是绝大多数问题都可以满足的，因为问题的计算复杂性一般是随着问题规模的增加而增加；

    第二条特征是应用分治法的前提，它也是大多数问题可以满足的，此特征反映了递归思想的应用；

    第三条特征是关键，能否利用分治法完全取决于问题是否具有第三条特征，如果具备了第一条和第二条特征，而不具备第三条特征，则可以考虑用贪心法或动态规划法。

    第四条特征涉及到分治法的效率，如果各子问题是不独立的则分治法要做许多不必要的工作，重复地解公共的子问题，此时虽然可用分治法，但一般用动态规划法较好。

分治法的基本步骤

    分治法在每一层递归上都有三个步骤：

    step1 分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题；

    step2 解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题

    step3 合并：将各个子问题的解合并为原问题的解。

    它的一般的算法设计模式如下：

    Divide-and-Conquer(P)

    1. if |P|≤n0

    2. then return(ADHOC(P))

    3. 将P分解为较小的子问题 P1 ,P2 ,…,Pk

    4. for i←1 to k

    5. do yi ← Divide-and-Conquer(Pi) △ 递归解决Pi

    6. T ← MERGE(y1,y2,…,yk) △ 合并子问题

    7. return(T)

  其中|P|表示问题P的规模；n0为一阈值，表示当问题P的规模不超过n0时，问题已容易直接解出，不必再继续分解。ADHOC(P)是该分治法中的基本子算法，用于直接解小规模的问题P。因此，当P的规模不超过n0时直接用算法ADHOC(P)求解。算法MERGE(y1,y2,…,yk)是该分治法中的合并子算法，用于将P的子问题P1 ,P2 ,…,Pk的相应的解y1,y2,…,yk合并为P的解。

分治法的复杂性分析

   一个分治法将规模为n的问题分成k个规模为n／m的子问题去解。设分解阀值n0=1，且adhoc解规模为1的问题耗费1个单位时间。再设将原问题分解为k个子问题以及用merge将k个子问题的解合并为原问题的解需用f(n)个单位时间。用T(n)表示该分治法解规模为|P|=n的问题所需的计算时间，则有：

     T（n）= k T(n/m)+f(n)

     通过迭代法求得方程的解：

   递归方程及其解只给出n等于m的方幂时T(n)的值，但是如果认为T(n)足够平滑，那么由n等于m的方幂时T(n)的值可以估计T(n)的增长速度。通常假定T(n)是单调上升的，从而当mi≤n<mi+1时，T(mi)≤T(n)<T(mi+1)。

可使用分治法求解的一些经典问题

（1）二分搜索

（2）大整数乘法

（3）Strassen矩阵乘法

（4）棋盘覆盖

（5）合并排序

（6）快速排序

（7）线性时间选择

（8）最接近点对问题

（9）循环赛日程表

（10）汉诺塔

依据分治法设计程序时的思维过程 

    实际上就是类似于数学归纳法，找到解决本问题的求解方程公式，然后根据方程公式设计递归程序。

    1、一定是先找到最小问题规模时的求解方法

    2、然后考虑随着问题规模增大时的求解方法

    3、找到求解的递归函数式后（各种规模或因子），设计递归程序即可。

 

 

（3）剑指Offer——简述堆和栈的区别

堆(Heap)

     Java堆是被所有线程共享的一块内存区域，在虚拟机启动时创建；

     Java虚拟机规范描述:所有的对象实例及数组都要在堆上分配；

     Java堆可以处于物理上不连续的内存空间，只要逻辑上连续即可;

     (线程共享)堆内存中的对象对所有线程可见。堆内存中的对象可以被所有线程访问;

     (异常提示)如果是堆内存没有可用的空间存储生成的对象，JVM会抛出java.lang.OutOfMemoryError；

     (内存分配)动态分配内存

栈(Stack)

    存放基本类型的数据和对象的引用，即存放变量;

       如果存放的是基本类型数据（非静态变量），则直接将变量名和值存入stack中的内存中；

    如果是引用类型，则将变量名存入栈，然后指向它new出的对象（存放在堆中）;

     (线程私有)栈内存归属于单个线程，每个线程都会有一个栈内存，其存储的变量只能在其所属线程中可见，即栈内存可以理解成线程的私有内存;

     (内存分配)栈的内存要远远小于堆内存，如果你使用递归的话，那么你的栈很快就会充满。如果递归没有及时跳出，很可能发生StackOverFlowError问题;

     (异常提示)如果栈内存没有可用的空间存储方法调用和局部变量，JVM会抛出java.lang.StackOverFlowError；

     (内存分配)内存分配固定；

     存取速度比堆要快，仅次于寄存器，栈数据可以共享；

附 栈数据共享

   栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：

     int a = 3;

     int b = 3；

   编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理int b = 3；在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。

   这时，如果再令a=4；那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。

   要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。

   String是一个特殊的包装类数据。可以用：

   String str = new String("abc");

   String str = "abc";

  两种的形式来创建，第一种是用new()来新建对象的，它会在存放于堆中。每调用一次就会创建一个新的对象。

而第二种是先在栈中创建一个对String类的对象引用变量str，然后查找栈中有没有存放"abc"，如果没有，则将"abc"存放进栈，并令str指向”abc”，如果已经有”abc”则直接令str指向“abc”。

   比较类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==，下面用例子说明上面的理论。

   String str1 = "abc";

   String str2 = "abc";

   System.out.println(str1==str2); //true

   可以看出str1和str2是指向同一个对象的。

   String str1 =new String ("abc");

   String str2 =new String ("abc");

   System.out.println(str1==str2); // false

   用new的方式是生成不同的对象。每一次生成一个。

   因此用第一种方式创建多个”abc”字符串,在内存中其实只存在一个对象而已. 这种写法有利于节省内存空间. 同时它可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。

   另一方面, 要注意: 我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为，创建了String类的对象str。担心陷阱！对象可能并没有被创建！而可能只是指向一个先前已经创建的 对象。只有通过new()方法才能保证每次都创建一个新的对象。

   由于String类的immutable性质，当String变量需要经常变换其值时，应该考虑使用StringBuffer(线程安全，效率低)类，以提高程序效率。

 

 

 

 

 

（4）数据结构进阶(四)二叉排序树(二叉查找树)

    注:构造一棵二叉排序树的目的，其实并不是为了排序(中序遍历)，而是为了提高查找、插入、删除关键字的速度。

定义

    二叉排序树又叫二叉查找树，英文名称是：Binary Sort Tree.BST的定义就不详细说了，我用一句话概括：左 < 中 < 右。 根据这个原理，我们可以推断：BST的中序遍历必定是严格递增的。

    二叉查找树是满足以下条件的二叉树：

    1.左子树上的所有节点值均小于根节点值；

    2.右子树上的所有节点值均不小于根节点值；

    3.左右子树也满足上述两个条件。

    二叉查找树是基于二叉树的，其结点数据结构定义为如下：

 

public class TreeNode {
  public Integer data;

  /*该节点的父节点*/
  public TreeNode parent;

  /*该节点的左子节点*/
  public TreeNode left;

  /*该节点的右子节点*/
  public TreeNode right;

  public TreeNode(Integer data) {
    this.data = data;
  }

  @Override
  public String toString() {
    return "TreeNode [data=" + data + "]";
  }
}

 

    现在明白了什么是二叉查找树，那么二叉查找树的基本操作又是如何来实现的呢？

查找

    在二叉查找树中查找x的过程如下：

    1、若二叉树是空树，则查找失败。

    2、若x等于根结点的数据，则查找成功，否则。

    3、若x小于根结点的数据，则递归查找其左子树，否则。

    4、递归查找其右子树。

   根据上述的步骤，写出其查找操作的代码：

 

/**
 * @param data
 * @return TreeNode
 */
public TreeNode findTreeNode(Integer data){
  if(null == root){
    return null;
  }
  TreeNode current = root;
  while(current != null){
    if(current.data > data){
      current = current.left;
    }else if(current.data < data){
      current = current.right;
    }else {
      return current;
    }

  }
  return null;
}

 

插入

    二叉查找树的插入过程如下：

    1.若当前的二叉查找树为空，则插入的元素为根节点；

    2.若插入的元素值小于根节点值，则将元素插入到左子树中；

    3.若插入的元素值不小于根节点值，则将元素插入到右子树中。

 

/**
 * 往树中加节点
 * @param data
 * @return Boolean 插入成功返回true
 */
public Boolean addTreeNode(Integer data) {

  if (null == root) {
    root = new TreeNode(data);
    System.out.println("数据成功插入到平衡二叉树中");
    return true;
  }

  TreeNode treeNode = new TreeNode(data);// 即将被插入的数据
  TreeNode currentNode = root;
  TreeNode parentNode;

  while (true) {
    parentNode = currentNode;// 保存父节点
    // 插入的数据比父节点小
    if (currentNode.data > data) {
      currentNode = currentNode.left;
      // 当前父节点的左子节点为空
      if (null == currentNode) {
        parentNode.left = treeNode;
        treeNode.parent = parentNode;
        System.out.println("数据成功插入到二叉查找树中");
        size++;
        return true;
      }
      // 插入的数据比父节点大
    } else if (currentNode.data < data) {
      currentNode = currentNode.right;
      // 当前父节点的右子节点为空
      if (null == currentNode) {
        parentNode.right = treeNode;
        treeNode.parent = parentNode;
        System.out.println("数据成功插入到二叉查找树中");
        size++;
        return true;
      }
    } else {
      System.out.println("输入数据与节点的数据相同");
      return false;
    }
  }

 

删除

   二叉查找树的删除，分三种情况进行处理：

   1.p为叶子节点，直接删除该节点，再修改其父节点的指针（注意分是根节点和不是根节点），如图a。

   2.p为单支节点（即只有左子树或右子树）。让p的子树与p的父亲节点相连，删除p即可；（注意分是根节点和不是根节点）；如图b。

   3.p的左子树和右子树均不空。找到p的后继y，因为y一定没有左子树，所以可以删除y，并让y的父亲节点成为y的右子树的父亲节点，并用y的值代替p的值；或者方法二是找到p的前驱x，x一定没有右子树，所以可以删除x，并让x的父亲节点成为y的左子树的父亲节点。如图c。

 

 

 

 

 

（5）Java多线程讲解

前言

    接到菜鸟网络的电话面试，面试官让自己谈一下自己对多线程的理解，现将其内容整理如下。

线程生命周期

    Java线程具有五种基本状态

    新建状态（New）：当线程对象创建后，即进入了新建状态，如：Thread t = new MyThread();

    就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

    运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

    阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：

    1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

    2.同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；

    3.其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

    死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

注 同步阻塞的正解

JAVA多线程实现的三种方式

    JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用Callable、FutureTask实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。

1.继承Thread类实现多线程

    继承Thread类的方法尽管列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extends Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：

 

public class MyThread extends Thread {
public void run() {
System.out.println("MyThread.run()");
}
}

 

    在合适的地方启动线程如下：

 

MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();

 

2.实现Runnable接口方式实现多线程

    如果自己的类已经extends另一个类，就无法直接extends Thread，此时，必须实现一个Runnable接口，如下：

 

public class MyThread extends OtherClass implements Runnable {
public void run() {
System.out.println("MyThread.run()");
}
}

 

    为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：

 

MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();

 

    事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：

 

public void run() {
if (target != null) {
target.run();
}
}

 

3.使用Callable和Future创建线程

    Callable接口提供了一个call()方法可以作为线程执行体，但call()方法比run()方法功能更为强大：call()方法可以有返回值；call()方法可以声明抛出异常。代码如下:

 

//实现Callable接口实现线程类
public class callableThread implements Callable<Integer>{
//实现call()方法作为线程执行体
public Integer call(){
int i = 0;
for(; i < 100; i++){
System.out.println(Thread.currentThread().getName() + “ 的循环变量i的值:” + i);
}
//call()方法可以有返回值
return i;
}
public static void main(String [] args){
//创建Callable对象
callableThread ct= new callableThread();
//使用FutureTask来包装Callable对象
FutureTask<Integer> task = new FutureTask<Integer>(ct);
for(int i = 0; i < 100; i++){
System.out.println(Thread.currentThread().getName() + “ 的循环变量i的值:” + i);
if(i ==20){
//实质还是以Callable对象来创建并启动线程
new Thread(task,有返回值的线程).start;
}
}
try{
//获取线程返回值
System.out.println(“子线程的返回值:” + task.get());
}
catch(Exception ex){
ex.printStackTrace();
}
}
}

 

多线程通信(摘录自课本)

    经典场景：用2个线程，这2个线程分别代表存款和取款。——现在系统要求存款者和取款者不断重复的存款和取款的动作，而且每当存款者将钱存入账户后，取款者立即取出这笔钱。不允许2次连续存款、2次连续取款。

传统的线程通信

    实现上述场景需要用到Object类提供的wait、notify和notifyAll三个方法，这3个方法并不属于Thread类。但这3个方法必须由同步监视器调用，可分为2种情况：

    A、对于使用synchronized修饰的同步方法，因为该类的默认实例this就是同步监视器，所以可以在同步中直接调用这3个方法。

    B、对于使用synchronized修改的同步代码块，同步监视器是synchronized后可括号中的对象，所以必须使用括号中的对象调用这3个方法

    传统方法概述：

    一、wait方法：导致当前线程进入等待，直到其他线程调用该同步监视器的notify方法或notifyAll方法来唤醒该线程。

    wait方法有3中形式：无参数的wait方法，会一直等待，直到其他线程通知；带毫秒参数的wait和微妙参数的wait，这2种形式都是等待时间到达后苏醒。调用wait方法的当前线程会释放对该对象同步监视器的锁定。

    二、notify：唤醒在此同步监视器上等待的单个线程。如果所有线程都在此同步监视器上等待，则会随机选择唤醒其中一个线程。只有当前线程放弃对该同步监视器的锁定后（用wait方法），才可以执行被唤醒的线程。

    三、notifyAll：唤醒在此同步监视器上等待的所有线程。只有当前线程放弃对该同步监视器的锁定后，才能执行唤醒的线程。

使用条件变量Condition控制协调

    如果程序不使用synchronized关键字来保证同步，而是直接使用Lock对象来保证同步，则系统中不存在隐式的同步监视器对象，也不能使用wait、notify、notifyAll方法来协调进程的运行。

    当使用Lock对象同步，Java提供一个Condition类来保持协调，使用Condition可以让那些已经得到Lock对象却无法继续执行的线程释放Lock对象,Condition对象也可以唤醒其它处于等待的线程，Condition将同步监视器(wait()、notify()、notifyAll())分解成截然不同的对象，以便通过将这些对象与Lock对象组合使用，为每个对象提供多个等待集（wait-set）。在这种情况下，Lock替代了同步方法和同步代码块，Condition替代同步监视器的功能。

    Condition实例实质上被绑定在一个Lock对象上，要获得特定的Lock实例的Condition实例，调用Lock对象的newCondition即可。    

使用阻塞队列(BlockingQueue)控制线程通信

    java中阻塞BlockingQueue 接口实现类中用的较多的通常是ArrayBlockingQueue,LinkedBlockingQueue.它们都是线程安全的.ArrayBlockingQueue以数组的形式存储,LinkedBlockingQueue以node节点的方式进行存储.

    开发中如果队列的插入操作比较频繁建议使用LinkedBlockingQueue,因为每个node节点都有一个前后指针,插入新元素仅需要变更前后的指针引用即可, ArrayBlockingQueue插入新元素,则新元素之后的元素数组下标位置都要发生变化,性能较差. 如果队列的读取操作比较频繁建议使用ArrayBlockingQueue, ArrayBlockingQueue通过数组下标直接能找到对应元素,LinkedBlockingQueue则需要遍历node链来找到元素.

    BlockingQueue 队列常用的操作方法:

    1.往队列中添加元素: add(), put(), offer()

    2.从队列中取出或者删除元素: remove() element()  peek()   pool()  take()

    队列添加新元素一般都是往队尾添加元素,

    offer()方法往队列添加元素如果队列已满直接返回false,队列未满则直接插入并返回true;

    add()方法是对offer()方法的简单封装.如果队列已满,抛出异常new IllegalStateException("Queue full");

    put()方法往队列里插入元素,如果队列已经满,则会一直等待直到队列为空插入新元素,或者线程被中断抛出异常.

    队列中取出或者删除元素都是针对队头的元素

    remove()方法直接删除队头的元素:

    peek()方法直接取出队头的元素,并不删除.

    element()方法对peek方法进行简单封装,如果队头元素存在则取出并不删除,如果不存在抛出异常NoSuchElementException()

    pool()方法取出并删除队头的元素,当队列为空,返回null;

    take()方法取出并删除队头的元素,当队列为空,则会一直等待直到队列有新元素可以取出,或者线程被中断抛出异常

    offer()方法一般跟pool()方法相对应, put()方法一般跟take()方法相对应.日常开发过程中offer()与pool()方法用的相对比较频繁.

sleep()和yield()的区别

    sleep()和yield()的区别:sleep()使当前线程进入停滞状态(阻塞态)，失去锁的占有权，所以执行sleep()的线程在指定的时间内肯定不会被执行；yield()不会阻塞线程，它只是将该线程转入就绪态。yield()只是让当前线程暂停一下，让系统的线程调度器重新调度一次，完全可能的情况是:当某个线程调用了yield()方法暂停之后，线程调度器又将其调度出来重新执行。

    sleep方法使当前运行中的线程睡眠一段时间，进入不可运行状态(阻塞态)，这段时间的长短是由程序设定的，yield方法使当前线程让出CPU占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把CPU 的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程。

    另外，sleep方法允许较低优先级的线程获得运行机会，但 yield()方法执行时，当前线程仍处在可运行状态(仍未失去锁)，所以，不可能让出较低优先级的线程些时获得CPU占有权。在一个运行系统中，如果较高优先级的线程没有调用sleep方法，又没有受到I\O阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。

死锁与线程阻塞的区别

死锁

  所谓死锁: 是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。   

     那么为什么会产生死锁呢？

    1.因为系统资源不足。

    2.进程运行推进的顺序不合适。   

    3.资源分配不当。            

    学过操作系统的朋友都知道：产生死锁的条件有四个：

    1.互斥条件：所谓互斥就是进程在某一时间内独占资源。

    2.请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

    3.不剥夺条件:进程已获得资源，在末使用完之前，不能强行剥夺。

    4.循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

阻塞

    线程被堵塞可能是由下述五方面的原因造成的：

    (1) 调用sleep(毫秒数)，使线程进入“睡眠”状态。在规定的时间内，这个线程是不会运行的。

    (2) 用suspend()暂停了线程的执行。除非线程收到resume()消息，否则不会返回“可运行”状态。

    (3) 用wait()暂停了线程的执行。除非线程收到nofify()或者notifyAll()消息，否则不会变成“可运行”。

    (4) 线程正在等候一些IO（输入输出）操作完成。

    (5) 线程试图调用另一个对象的“同步”方法，但那个对象处于锁定状态，暂时无法使用。

   亦可调用yield()（Thread类的一个方法）自动放弃CPU，以便其他线程能够运行。然而，假如调度机制觉得我们的线程已拥有足够的时间，并跳转到另一个线程，就会发生同样的事情。也就是说，没有什么能防止调度机制重新启动我们的线程。

 

 

 

 

 

 

（6）剑指Offer——全排列递归思路

前言

      全排列，full permutation, 可以利用二叉树的遍历实现。二叉树的递归遍历，前中后都简洁的难以置信，但是都有一个共同特点，那就是一个函数里包含两次自身调用。

所以，如果一个递归函数中包含了两次自身调用，那么这类问题就是归纳成二分问题。也就是to be or not to be , is the problem。如果一个使用相同手段并且每一个点上可分为两种情况的问题，基本都可以转化为递归问题。当然，如果是有三个孩子的树，那么我们可能需要在一个递归函数中调用自身三次。

      这里的递归，和我们计算的阶乘又有不一样，因为他没有返回，是发散的。也就是从一个节点，发散到N个节点，我们要的结果是叶子节点。

      计算全排列，我们可以单独拿出每一个元素作为根节点来构成一棵树，所有的可能排列情况就都隐藏在森林中了。现在来看每一颗树，假如4个元素，A，B，C，D，以A为根是第一颗，表示以A开头的排列。

      那么，第二个位置可以选着B，C，D，如果我们选择了B，那么B下还有 C， D可以选择， 如果我们选了C，那么最后只剩下D，这样，就列出第一种。如图所示：

      我们可以看到，这里的孩子个数是递减的，直到最后一个元素，就不用选择了，同时也得到一种可能。

      要枚举出所有的，那么就遍历这样一颗树。好了，先上代码。

 

package cn.edu.ujn.nk;

public class FullPermutation {
/**
     * recursive method, used for the tree traversal.
     *
     * @param inStr
     *            the elements need to be choose
     * @param pos
     *            the position of the elements we choose
     * @param parentData
     *            the elements have been chosen
     */
    public void permutation(String inStr, int pos, StringBuffer parentData) {
        if (inStr.length() == 0) {
            return;
        }
        if (inStr.length() == 1) {
            System.out.println("{" + inStr + "}");
            return;
        }
        // here we need a new buffer to avoid to pollute the other nodes.
        StringBuffer buffer = new StringBuffer();
        // copy from the parent node
        buffer.append(parentData.toString());

        // choose the element
        buffer.append(inStr.charAt(pos));

        // get the remnant elements.
        String subStr = kickChar(inStr, pos);

        // got one of the result
        if (subStr.length() == 1) {
            buffer.append(subStr);
            System.out.println(buffer.toString());
            return;
        }

        // here we use loop to choose other children.
        for (int i = 0; i < subStr.length(); i++) {
            permutation(subStr, i, buffer);
        }

    }

    // a simple method to delete the element we choose
    private String kickChar(String src, int pos) {
        StringBuffer srcBuf = new StringBuffer();
        srcBuf.append(src);
        srcBuf.deleteCharAt(pos);
        return srcBuf.toString();
    }

    public static void main(String args[]) {
        FullPermutation p = new FullPermutation();
        StringBuffer buffer = new StringBuffer();
        String input = "ABCD";
        for (int i = 0; i < input.length(); i++) {
            p.permutation(input, i, buffer);
        }
    }
}