程序员编程艺术-----第十五 ~ 二十章-----全排列、跳台阶、奇偶、第一个出现一次字符、一致性hash

第十六~第二十章：全排列，跳台阶，奇偶排序，第一个只出现一次等问题

作者：July、2011.10.16。
出处： http://blog.csdn.net/v_JULY_v 。

引言

    最近这几天闲职在家，一忙着投简历，二为准备面试而搜集整理各种面试题。故常常关注个人所建的Algorithms1-14群内朋友关于笔试，面试，宣讲会，offer，薪资的讨论以及在群内发布的各种笔/面试题，常感言道：咱们这群人之前已经在学校受够了学校的那种应试教育，如今出来找工作又得东奔西走去参加各种笔试/面试，着实亦不轻松。幻想，如果在企业与求职者之间有个中间面试服务平台就更好了。

    ok，闲话少扯。在上一篇文章中，已经说过，“个人正在针对那100题一题一题的写文章，多种思路，不断优化，即成程序员编程艺术系列。”现本编程艺术系列继续开始创作，你而后自会和我有同样的感慨：各种面试题千变万化，层出不穷，但基本类型，解决问题的思路基本一致。

    本文为程序员编程艺术第十六章~第二十章，包含以下5个问题：

1. 全排列；
2. 跳台阶；
3. 奇偶排序；
4. 第一个只出现一次的字符；
5. 一致性哈希算法。

    同时，本文会在解答去年微软面试100题的部分题目时，尽量结合今年最近各大IT公司最新的面试题来讲解，两相对比，彼此对照，相信你会更加赞同我上面的话。且本文也不奢望读者能从中学到什么高深技术之类的东西，只求读者看此文看着舒服便可，通顺流畅以致一口气读完而无任何压力。ok，有任何问题，欢迎不吝指正。谢谢。

第十六章、全排列问题

53.字符串的排列。
题目：输入一个字符串，打印出该字符串中字符的所有排列。
例如输入字符串abc，则输出由字符a、b、c 所能排列出来的所有字符串
abc、acb、bac、bca、cab 和cba。

    分析：此题最初整理于去年的微软面试100题中第53题，第二次整理于微软、Google等公司非常好的面试题及解答[第61-70题] 第67题。无独有偶，这个问题今年又出现于今年的2011.10.09百度笔试题中。ok，接下来，咱们先好好分析这个问题。

• 一、递归实现
  从集合中依次选出每一个元素，作为排列的第一个元素，然后对剩余的元素进行全排列，如此递归处理，从而得到所有元素的全排列。以对字符串abc进行全排列为例，我们可以这么做：以abc为例
  固定a，求后面bc的排列：abc，acb，求好后，a和b交换，得到bac
  固定b，求后面ac的排列：bac，bca，求好后，c放到第一位置，得到cba
  固定c，求后面ba的排列：cba，cab。代码可如下编写所示：

1. template <typename T>  
2. void CalcAllPermutation_R(T perm[], int first, int num)  
3. {  
4.     if (num <= 1) {  
5.         return;  
6.     }  
7.       
8.     for (int i = first; i < first + num; ++i) {  
9.         swap(perm[i], perm[first]);  
10.         CalcAllPermutation_R(perm, first + 1, num - 1);  
11.         swap(perm[i], perm[first]);  
12.     }  
13. }  

    或者如此编写，亦可：

1. void Permutation(char* pStr, char* pBegin);  
2.   
3. void Permutation(char* pStr)  
4. {  
5.       Permutation(pStr, pStr);  
6. }  
7.   
8. void Permutation(char* pStr, char* pBegin)  
9. {  
10.     if(!pStr || !pBegin)  
11.         return;  
12.       
13.     if(*pBegin == '\0')  
14.     {  
15.         printf("%s\n", pStr);  
16.     }  
17.     else  
18.     {  
19.         for(char* pCh = pBegin; *pCh != '\0'; ++ pCh)  
20.         {  
21.             // swap pCh and pBegin  
22.             char temp = *pCh;  
23.             *pCh = *pBegin;  
24.             *pBegin = temp;  
25.               
26.             Permutation(pStr, pBegin + 1);    
27.             // restore pCh and pBegin  
28.             temp = *pCh;  
29.             *pCh = *pBegin;  
30.             *pBegin = temp;  
31.         }  
32.     }  
33. }  

• 二、字典序排列
  把升序的排列（当然，也可以实现为降序）作为当前排列开始，然后依次计算当前排列的下一个字典序排列。
  对当前排列从后向前扫描，找到一对为升序的相邻元素，记为i和j（i < j）。如果不存在这样一对为升序的相邻元素，则所有排列均已找到，算法结束；否则，重新对当前排列从后向前扫描，找到第一个大于i的元素k，交换i和k，然后对从j开始到结束的子序列反转，则此时得到的新排列就为下一个字典序排列。这种方式实现得到的所有排列是按字典序有序的，这也是C++ STL算法next_permutation的思想。算法实现如下：

1. template <typename T>  
2. void CalcAllPermutation(T perm[], int num)  
3. {  
4.     if (num < 1)  
5.         return;  
6.           
7.     while (true) {  
8.         int i;  
9.         for (i = num - 2; i >= 0; --i) {  
10.             if (perm[i] < perm[i + 1])  
11.                 break;  
12.         }  
13.           
14.         if (i < 0)  
15.             break;  // 已经找到所有排列  
16.       
17.         int k;  
18.         for (k = num - 1; k > i; --k) {  
19.             if (perm[k] > perm[i])  
20.                 break;  
21.         }  
22.           
23.         swap(perm[i], perm[k]);  
24.         reverse(perm + i + 1, perm + num);  
25.          
26.     }  
27. }  

  扩展：如果不是求字符的所有排列，而是求字符的所有组合，应该怎么办呢？当输入的字符串中含有相同的字符串时，相同的字符交换位置是不同的排列，但是同一个组合。举个例子，如果输入abc，它的组合有a、b、c、ab、ac、bc、abc。

第十七章、跳台阶问题

27.跳台阶问题
题目：一个台阶总共有n 级，如果一次可以跳1 级，也可以跳2 级。
求总共有多少总跳法，并分析算法的时间复杂度。

    分析：在九月腾讯，创新工场，淘宝等公司最新面试十三题中第23题又出现了这个问题，题目描述如下：23、人人笔试1：一个人上台阶可以一次上1个，2个，或者3个，问这个人上n层的台阶，总共有几种走法？咱们先撇开这个人人笔试的问题（其实差别就在于人人笔试题中多了一次可以跳三级的情况而已），先来看这个第27题。

    首先考虑最简单的情况。如果只有1级台阶，那显然只有一种跳法。如果有2级台阶，那就有两种跳的方法了：一种是分两次跳，每次跳1级；另外一种就是一次跳2级。

    现在我们再来讨论一般情况。我们把n级台阶时的跳法看成是n的函数，记为f(n)。当n>2时，第一次跳的时候就有两种不同的选择：一是第一次只跳1级，此时跳法数目等于后面剩下的n-1级台阶的跳法数目，即为f(n-1)；另外一种选择是第一次跳2级，此时跳法数目等于后面剩下的n-2级台阶的跳法数目，即为f(n-2)。因此n级台阶时的不同跳法的总数f(n)=f(n-1)+(f-2)。

    我们把上面的分析用一个公式总结如下：
        /     1                              n=1
f(n)=      2                              n=2
        \  f(n-1) + f(n-2)            n>2

    原来上述问题就是我们平常所熟知的Fibonacci数列问题。可编写代码，如下：

1. long long Fibonacci_Solution1(unsigned int n)  
2. {  
3.     int result[2] = {0, 1};  
4.     if(n < 2)  
5.         return result[n];  
6.       
7.     return Fibonacci_Solution1(n - 1) + Fibonacci_Solution1(n - 2);  
8. }  

     那么，如果是人人笔试那道题呢?一个人上台阶可以一次上1个，2个，或者3个，岂不是可以轻而易举的写下如下公式：

        /      1                                      n=1
f(n)=      2                                      n=2

              4                                      n=3       //111, 12, 21, 3
        \  f(n-1)+(f-2)+f(n-3)            n>3

    行文至此，你可能会认为问题已经解决了，但事实上没有：

1. 用递归方法计算的时间复杂度是以n的指数的方式递增的，我们可以尝试用递推方法解决。具体如何操作，读者自行思考。
   
2. 有一种方法，能在O(logn)的时间复杂度内求解Fibonacci数列问题，你能想到么?
   
   

   第十八章、奇偶调序

   54.调整数组顺序使奇数位于偶数前面。
   题目：输入一个整数数组，调整数组中数字的顺序，使得所有奇数位于数组的前半部分，
   所有偶数位于数组的后半部分。要求时间复杂度为O(n)。

   分析：

   1. 你当然可以从头扫描这个数组，每碰到一个偶数时，拿出这个数字，并把位于这个数字后面的所有数字往前挪动一位。挪完之后在数组的末尾有一个空位，这时把该偶数放入这个空位。由于碰到一个偶数，需要移动O(n)个数字，只是这种方法总的时间复杂度是O(n^２)，不符合要求，pass。
      
   2. 很简单，维护两个指针，一个指针指向数组的第一个数字，向后移动；一个个指针指向最后一个数字，向前移动。如果第一个指针指向的数字是偶数而第二个指针指向的数字是奇数，我们就交换这两个数字。
      
       思路有了，接下来，写代码实现：

   1. //思路，很简答，俩指针，一首一尾  
   2. //如果第一个指针指向的数字是偶数而第二个指针指向的数字是奇数，  
   3. //我们就交换这两个数字  
   4.   
   5. // 2 1 3 4 6 5 7   
   6. // 7 1 3 4 6 5 2  
   7. // 7 1 3 5 6 4 2  
   8.   
   9. //如果限制空间复杂度为O（1），时间为O（N），且奇偶数之间相对顺序不变，就相当于正负数间顺序调整的那道题了。  
   10.   
   11. //copyright@2010 zhedahht。  
   12. void Reorder(int *pData, unsigned int length, bool (*func)(int));  
   13. bool isEven(int n);  
   14. void ReorderOddEven(int *pData, unsigned int length)  
   15. {  
   16.     if(pData == NULL || length == 0)  
   17.         return;  
   18.       
   19.     Reorder(pData, length, isEven);  
   20. }  
   21. void Reorder(int *pData, unsigned int length, bool (*func)(int))  
   22. {  
   23.     if(pData == NULL || length == 0)  
   24.         return;  
   25.     int *pBegin = pData;  
   26.     int *pEnd = pData + length - 1;  
   27.     while(pBegin < pEnd)  
   28.     {  
   29.         // if *pBegin does not satisfy func, move forward  
   30.         if(!func(*pBegin))   //偶数  
   31.         {  
   32.             pBegin ++;  
   33.             continue;  
   34.         }  
   35.           
   36.         // if *pEnd does not satisfy func, move backward  
   37.         if(func(*pEnd))      //奇数  
   38.         {  
   39.             pEnd --;  
   40.             continue;  
   41.         }  
   42.         // if *pBegin satisfy func while *pEnd does not,  
   43.         // swap these integers  
   44.         int temp = *pBegin;  
   45.         *pBegin = *pEnd;  
   46.         *pEnd = temp;  
   47.     }  
   48. }  
   49. bool isEven(int n)  
   50. {  
   51.     return (n & 1) == 0;  
   52. }  
       细心的读者想必注意到了上述程序注释中所说的“如果限制空间复杂度为O（1），时间为O（N）就相当于正负数间顺序调整的那道题了”，没错，它与个人之前整理的一文中的第5题极其类似：5、一个未排序整数数组，有正负数，重新排列使负数排在正数前面，并且要求不改变原来的正负数之间相对顺序 比如： input: 1,7,-5,9,-12,15 ans: -5,-12,1,7,9,15 要求时间复杂度O(N),空间O(1) 。（此题一直没看到令我满意的答案，一般达不到题目所要求的：时间复杂度O(N),空间O(1)，且保证原来正负数之间的相对位置不变）。
       如果你想到了绝妙的解决办法，不妨在本文评论下告知于我，或者来信指导（[email protected]），谢谢。

   第十九章、第一个只出现一次的字符

   第17 题：题目：在一个字符串中找到第一个只出现一次的字符。如输入abaccdeff，则输出b。
   
       分析：这道题是2006 年google 的一道笔试题。它在今年又出现了，不过换了一种形式。即最近的搜狐笔试大题：数组非常长，如何找到第一个只出现一次的数字，说明算法复杂度。此问题已经在程序员编程艺术系列第二章中有所阐述，在此不再作过多讲解。

   代码，可编写如下：

   1. #include <iostream>  
   2. using namespace std;  
   3.   
   4. //查找第一个只出现一次的字符，第1个程序  
   5. //copyright@ Sorehead && July  
   6. //July、updated，2011.04.24.  
   7. char find_first_unique_char(char *str)  
   8. {  
   9.     int data[256];  
   10.     char *p;  
   11.       
   12.     if (str == NULL)  
   13.         return '\0';  
   14.       
   15.     memset(data, 0, sizeof(data));    //数组元素先全部初始化为0  
   16.     p = str;  
   17.     while (*p != '\0')  
   18.         data[(unsigned char)*p++]++;  //遍历字符串，在相应位置++，（同时，下标强制转换）  
   19.       
   20.     while (*str != '\0')  
   21.     {  
   22.         if (data[(unsigned char)*str] == 1)  //最后，输出那个第一个只出现次数为1的字符  
   23.             return *str;  
   24.           
   25.         str++;  
   26.     }  
   27.       
   28.     return '\0';  
   29. }  
   30.   
   31. int main()  
   32. {  
   33.     char *str = "afaccde";  
   34.     cout << find_first_unique_char(str) << endl;  
   35.     return 0;  
   36. }  

     当然，代码也可以这么写（测试正确）： 

   1. //查找第一个只出现一次的字符，第2个程序  
   2. //copyright@ yansha  
   3. //July、updated，2011.04.24.  
   4. char FirstNotRepeatChar(char* pString)  
   5. {  
   6.     if(!pString)  
   7.         return '\0';  
   8.       
   9.     const int tableSize = 256;  
   10.     int hashTable[tableSize] = {0}; //存入数组，并初始化为0  
   11.       
   12.     char* pHashKey = pString;  
   13.     while(*(pHashKey) != '\0')  
   14.         hashTable[*(pHashKey++)]++;  
   15.       
   16.     while(*pString != '\0')  
   17.     {  
   18.         if(hashTable[*pString] == 1)  
   19.             return *pString;  
   20.           
   21.         pString++;  
   22.     }  
   23.     return '\0';  //没有找到满足条件的字符，退出  
   24. }  

   第二十章、一致性哈希算法

   tencent2012笔试题附加题
       问题描述： 例如手机朋友网有n个服务器，为了方便用户的访问会在服务器上缓存数据，因此用户每次访问的时候最好能保持同一台服务器。
   已有的做法是根据ServerIPIndex[QQNUM%n]得到请求的服务器，这种方法很方便将用户分到不同的服务器上去。但是如果一台服务器死掉了，那么n就变为了n-1，那么ServerIPIndex[QQNUM%n]与ServerIPIndex[QQNUM%（n-1）]基本上都不一样了，所以大多数用户的请求都会转到其他服务器，这样会发生大量访问错误。

       问： 如何改进或者换一种方法，使得：
   （1）一台服务器死掉后，不会造成大面积的访问错误，
   （2）原有的访问基本还是停留在同一台服务器上；
   （3）尽量考虑负载均衡。（思路：往分布式一致哈希算法方面考虑。）

    

   1. 最土的办法还是用模余方法：做法很简单，假设有N台服务器，现在完好的是M（M<=N),先用N求模，如果不落在完好的机器上，然后再用N-1求模，直到M.这种方式对于坏的机器不多的情况下，具有更好的稳定性。
      
   2. 一致性哈希算法。

    

       下面，本文剩下部分重点来讲讲这个一致性哈希算法。
   

   应用场景

    

       在做服务器负载均衡时候可供选择的负载均衡的算法有很多，包括：  轮循算法（Round Robin）、哈希算法（HASH）、最少连接算法（Least Connection）、响应速度算法（Response Time）、加权法（Weighted ）等。其中哈希算法是最为常用的算法.

       典型的应用场景是： 有N台服务器提供缓存服务，需要对服务器进行负载均衡，将请求平均分发到每台服务器上，每台机器负责1/N的服务。

       常用的算法是对hash结果取余数 (hash() mod N)：对机器编号从0到N-1，按照自定义的hash()算法，对每个请求的hash()值按N取模，得到余数i，然后将请求分发到编号为i的机器。但这样的算法方法存在致命问题，如果某一台机器宕机，那么应该落在该机器的请求就无法得到正确的处理，这时需要将当掉的服务器从算法从去除，此时候会有(N-1)/N的服务器的缓存数据需要重新进行计算；如果新增一台机器，会有N /(N+1)的服务器的缓存数据需要进行重新计算。对于系统而言，这通常是不可接受的颠簸（因为这意味着大量缓存的失效或者数据需要转移）。那么，如何设计一个负载均衡策略，使得受到影响的请求尽可能的少呢？
       在Memcached、Key-Value Store、Bittorrent DHT、LVS中都采用了Consistent Hashing算法，可以说Consistent Hashing 是分布式系统负载均衡的首选算法。

   Consistent Hashing算法描述

       下面以Memcached中的Consisten Hashing算法为例说明。

       consistent hashing 算法早在 1997 年就在论文 Consistent hashing and random trees 中被提出，目前在 cache 系统中应用越来越广泛；

   1 基本场景

   比如你有 N 个 cache 服务器（后面简称 cache ），那么如何将一个对象 object 映射到 N 个 cache 上呢，你很可能会采用类似下面的通用方法计算 object 的 hash 值，然后均匀的映射到到 N 个 cache ；

   hash(object)%N

   一切都运行正常，再考虑如下的两种情况；

   1. 一个 cache 服务器 m down 掉了（在实际应用中必须要考虑这种情况），这样所有映射到 cache m 的对象都会失效，怎么办，需要把 cache m 从 cache 中移除，这时候 cache 是 N-1 台，映射公式变成了 hash(object)%(N-1) ；
   2. 由于访问加重，需要添加 cache ，这时候 cache 是 N+1 台，映射公式变成了 hash(object)%(N+1) ；

       1 和 2 意味着什么？这意味着突然之间几乎所有的 cache 都失效了。对于服务器而言，这是一场灾难，洪水般的访问都会直接冲向后台服务器；再来考虑第三个问题，由于硬件能力越来越强，你可能想让后面添加的节点多做点活，显然上面的 hash 算法也做不到。

         有什么方法可以改变这个状况呢，这就是consistent hashing。

   2 hash 算法和单调性

   　 Hash 算法的一个衡量指标是单调性（ Monotonicity ），定义如下：

   　 单调性是指如果已经有一些内容通过哈希分派到了相应的缓冲中，又有新的缓冲加入到系统中。哈希的结果应能够保证原有已分配的内容可以被映射到新的缓冲中去，而不会被映射到旧的缓冲集合中的其他缓冲区。

       容易看到，上面的简单 hash 算法 hash(object)%N 难以满足单调性要求。

   3 consistent hashing 算法的原理

       consistent hashing 是一种 hash 算法，简单的说，在移除 / 添加一个 cache 时，它能够尽可能小的改变已存在 key 映射关系，尽可能的满足单调性的要求。

       下面就来按照 5 个步骤简单讲讲 consistent hashing 算法的基本原理。

   3.1 环形hash 空间

       考虑通常的 hash 算法都是将 value 映射到一个 32 为的 key 值，也即是 0~2^32-1 次方的数值空间；我们可以将这个空间想象成一个首（ 0 ）尾（ 2^32-1 ）相接的圆环，如下面图 1 所示的那样。

   
   

   3.2 把对象映射到hash 空间

       接下来考虑 4 个对象 object1~object4 ，通过 hash 函数计算出的 hash 值 key 在环上的分布如图 2 所示。

   hash(object1) = key1;

   … …

   hash(object4) = key4;
   
   

   3.3 把cache 映射到hash 空间

       Consistent hashing 的基本思想就是将对象和 cache 都映射到同一个 hash 数值空间中，并且使用相同的hash 算法。

       假设当前有 A,B 和 C 共 3 台 cache ，那么其映射结果将如图 3 所示，他们在 hash 空间中，以对应的 hash值排列。

   hash(cache A) = key A;

   … …

   hash(cache C) = key C;

   
   

   说到这里，顺便提一下 cache 的 hash 计算，一般的方法可以使用 cache 机器的 IP 地址或者机器名作为hash 输入。

   3.4 把对象映射到cache

       现在 cache 和对象都已经通过同一个 hash 算法映射到 hash 数值空间中了，接下来要考虑的就是如何将对象映射到 cache 上面了。

       在这个环形空间中，如果沿着顺时针方向从对象的 key 值出发，直到遇见一个 cache ，那么就将该对象存储在这个 cache 上，因为对象和 cache 的 hash 值是固定的，因此这个 cache 必然是唯一和确定的。这样不就找到了对象和 cache 的映射方法了吗？！

       依然继续上面的例子（参见图 3 ），那么根据上面的方法，对象 object1 将被存储到 cache A 上； object2和 object3 对应到 cache C ； object4 对应到 cache B ；

   3.5 考察cache 的变动

       前面讲过，通过 hash 然后求余的方法带来的最大问题就在于不能满足单调性，当 cache 有所变动时，cache 会失效，进而对后台服务器造成巨大的冲击，现在就来分析分析 consistent hashing 算法。

   3.5.1 移除 cache

       考虑假设 cache B 挂掉了，根据上面讲到的映射方法，这时受影响的将仅是那些沿 cache B 顺时针遍历直到下一个 cache （ cache C ）之间的对象，也即是本来映射到 cache B 上的那些对象。

       因此这里仅需要变动对象 object4 ，将其重新映射到 cache C 上即可；参见图 4 。

   
   

   3.5.2 添加 cache

       再考虑添加一台新的 cache D 的情况，假设在这个环形 hash 空间中， cache D 被映射在对象 object2 和object3 之间。这时受影响的将仅是那些沿 cache D 逆时针遍历直到下一个 cache （ cache B ）之间的对象（它们是也本来映射到 cache C 上对象的一部分），将这些对象重新映射到 cache D 上即可。

       因此这里仅需要变动对象 object2 ，将其重新映射到 cache D 上；参见图 5 。
   
   

   4 虚拟节点

   考量 Hash 算法的另一个指标是平衡性 (Balance) ，定义如下：

   平衡性

   　　平衡性是指哈希的结果能够尽可能分布到所有的缓冲中去，这样可以使得所有的缓冲空间都得到利用。

       hash 算法并不是保证绝对的平衡，如果 cache 较少的话，对象并不能被均匀的映射到 cache 上，比如在上面的例子中，仅部署 cache A 和 cache C 的情况下，在 4 个对象中， cache A 仅存储了 object1 ，而 cache C 则存储了 object2 、 object3 和 object4 ；分布是很不均衡的。

       为了解决这种情况， consistent hashing 引入了“虚拟节点”的概念，它可以如下定义：

   “虚拟节点”（ virtual node ）是实际节点在 hash 空间的复制品（ replica ），一实际个节点对应了若干个“虚拟节点”，这个对应个数也成为“复制个数”，“虚拟节点”在 hash 空间中以 hash 值排列。

       仍以仅部署 cache A 和 cache C 的情况为例，在图 4 中我们已经看到， cache 分布并不均匀。现在我们引入虚拟节点，并设置“复制个数”为 2 ，这就意味着一共会存在 4 个“虚拟节点”， cache A1, cache A2 代表了 cache A ； cache C1, cache C2 代表了 cache C ；假设一种比较理想的情况，参见图 6 。

   
   

    此时，对象到“虚拟节点”的映射关系为：

   objec1->cache A2 ； objec2->cache A1 ； objec3->cache C1 ； objec4->cache C2 ；

       因此对象 object1 和 object2 都被映射到了 cache A 上，而 object3 和 object4 映射到了 cache C 上；平衡性有了很大提高。

       引入“虚拟节点”后，映射关系就从 { 对象 -> 节点 } 转换到了 { 对象 -> 虚拟节点 } 。查询物体所在 cache时的映射关系如图 7 所示。
   
   

     “虚拟节点”的 hash 计算可以采用对应节点的 IP 地址加数字后缀的方式。例如假设 cache A 的 IP 地址为202.168.14.241 。

       引入“虚拟节点”前，计算 cache A 的 hash 值：

   Hash(“202.168.14.241”);

       引入“虚拟节点”后，计算“虚拟节”点 cache A1 和 cache A2 的 hash 值：

   Hash(“202.168.14.241#1”);  // cache A1

   Hash(“202.168.14.241#2”);  // cache A2

   后记

   1. 以上部分代码思路有参考自此博客：http://zhedahht.blog.163.com/blog/。特此注明下。     
   2. 上文第五部分来源：http://blog.csdn.net/sparkliang/article/details/5279393；
      
   3. 行文仓促，若有任何问题或漏洞，欢迎不吝指正或赐教。谢谢。转载，请注明出处。完。