在我的本科四年中，花了大量时间学习算法，参加算法比赛——成绩很滥，朋友们都说，和我的付出严重不成比例，但是我一点也不后悔花费时间学习算法。算法让我在平时的学习中应对各个科目都从容自如，学习起来事半功倍。

在平时的学习交流中，有时看其他人的代码相当别扭，不是看不懂（有时真看不懂），而是很纳闷，为什么要这么写呢，明明有很明显的顺畅的思路，干吗要写这么绕呢？我将我觉得正确的思路写出来的时候，对方也会觉得这样写顺畅了很多，代码也小了很多。

在一般应用中，不会说让你写一个KMP算法，或者给你设计一个动态规划的题目让你来解。但是如果你会这些算法，掌握了这种优化的思想，在平时的编写中会不知不觉的写出比较高效的代码。

有人说，现在中国的软件现状就是这样，不在乎你实现的有多快，只会在乎你有没有实现所有的功能点，随着硬件条件的改善，一般情况下都能满足要求。这样说也是没错，如果你甘愿只做一名码工，因为对于相当大的一部分软件，效率并不是最重要的，甚至第二、第三重要都排不上。但是对于企业级的应用和软件的核心部分，往往效率是非常重要的。

如果将编程和写作类比的话，可以进行这个的比较。编程必须会语言C/C++、Java、Python等，写作也一定要会一个语言汉语、英语、法语，当然计算机语言有效率的优劣以及适合的应用的场景，而自然语言没有这种属性。算法修养之于编程就像文学修养之于创作，没有一定的文学修养就写不出好的作品，同样没有良好的算法修养也创造不出好的代码。数据结构就像写作中的排比句等，它们是骨架，结构化编程就像是写作中的段落，它们使得层次分明。

在静静的夜晚，明月透过窗子，照进小屋，顿时一种异样的情怀涌上心头。这时有下面几种人，第一种，嚎啕大哭，“妈妈……”；第二种，潸然泪下，“我嚓，想家了是不”；第三种，沉思状，“有首诗可以表达这个情怀”，拿起全唐诗，查找了整晚，夜尽天明时，惊呼“找到了，原来是‘举头望明月，底头思故乡’啊，我记得有的。”；第四种，徘徊低吟“举头望明月，底头思故乡”；第五种，心中油然而生，“独在异乡为异客，明月千里寄乡思”。

同样地，这也反映了一个程序员算法修养的几种境界。第一种，菜鸟，不会表达自己的思想，这种多见于初学语言的人，只会写hello world之类程序的人；第二种，入门，可以表达出自己的想法，但是不懂什么算法，只是凭自己对计算机语言的理解写程序，当然写出的程序功能点可能不少，但是不完善，潜在的bug很多；第三种，有一定的算法基础，但是没有掌握完全，写程序时有高效的意识，对一些核心程序，看着资料也能写出相应的代码，但是不能活学活用；第四种，有不错的算法修养，写出的代码清晰高效，可胜任关键代码的编写；第五种，有很高的算法修养，理解了算法的精髓，自己可以得出算法供世人学习，一般是大师级人物。国内有相当一部分程序员就是处于第二阶段，他们也有稳定的工作，甚至不错的收入，但是总感觉遇到了瓶颈，自己的能力踌躇不前。

有人说，现在各种库都有，那些代码都非常高效，我只要熟练使用这些库就行了，不用学习算法。可以达到熟练使用几个库的程序员也算是第三阶段，但是要想熟练驾驭更多的库，将库函数熟练的使用，没有一定的算法基础是不行的。比如，如果你想熟练使用STL库，那么对各种容器和算法都应该有一定的认识，什么时候使用list，为什么快排不能应用于list？要想回答这些问题，必须掌握初步的算法。

对于想要在技术上有一定作为的程序员，没有算法修养，就如同金庸小说中的学武之人不学习内功，它可以将外功学的炉火纯清，凭着这份功力可以走遍半个江湖，但是一旦遇到高手就挂了；反之如果有内功修为，学习外功可学一知十，触类旁通，内功修为越高将来的成就越大。

学习算法吧！

        典型的激发函数有Sigmod函数：

        双曲正切函数：

          这两个都涉及到指数函数，在C中，为求指数函数，使用exp()函数。

      在数次出错后找到问题，原来是我的指数值过大，数据中有时会出现超过1000的数字，这导致在求值过程中，即使使用double型，也使得结果溢出。

      解决方法是定义一个指数函数，当指数值超过一定界限便指定一个相对无穷大的值，这样也符合数学定义。在我的处理中，将界限设定为15，当该值大于15时，返回3000000；当界限值小于-15时，返回0。

class CStack
{
public:
       CStack();  
       CStack(int  size); 
       CStack(const CStack& st);   //复制构造函数，注意使用引用
private:    
       int _size;
       int _count;
       int* _s;           
};
CStack::CStack(const CStack& st)
{
      _size=st._size;
      if(_size > 0)
      {
               _s = new int[_size];
               _count = st._count;                  //访问st的私有数据
               for(int i=0; i<_count; ++i)
                       _s[i] = st._s[i];             
      }         
      else
      {
          _s =  0;
          _count = 0;           
      }                                            
}

      在C++模型中，保护是在类层次应用的，而不是在对象层次。
      这句话的意思是，类的任意一个对象可以访问该类的另一个对象的内部的任何东西。在上面的例子中，复制构造函数中的赋值语句_size = st._size;访问了st的私有数据。
      这说明，C++中的访问保护是按照层次的原则定义的，那么什么事对象层次的保护呢？
      在Smalltalk中，成员函数可以当前对象的私有数据，但不能访问任何其它对象的私有数据，即使它们属于相同的类。

class CStack
{
public:
       CStack();  
       CStack(int  size=100); 
       CStack(const CStack& st);   //复制构造函数，注意使用引用
private:    
       int _size;
       int _count;
       int* _s;           
};
CStack::CStack(const CStack& st)
{
      _size=st._size;
      if(_size > 0)
      {
               _s = new int[_size];
               _count = st._count;         
               for(int i=0; i<_count; ++i)
                       _s[i] = st._s[i];             
      }         
      else
      {
          _s =  0;
          _count = 0;           
      }                                            
}

int main()
{
    CStack st;
    return 0;    
}

一. 在main()中，对象st不知道该调用哪一个构造函数，因为CStack()和CStack(int  size=100)都满足条件，此时正确的编译器会立即标示这种冲突，强迫实现者解决这个问题。

二. 假设我们已经有了一个CStack对象s1
CSatck s2=s1;      //这个句子将会调用复制构造函数
CStack s3 = CStack(200);   //这个句子将会做什么呢？

首先，产生一个临时CStack对象，不妨命名为sss，并调用构造函数CStack::CStack(200)，随后执行复制构造函数。也就是说，它相当于

CStack sss(200);
CStack s3(sss);

这很浪费时间，不过，大多数编译器还是能优化这种语句。但是我们为什么不养成一个好的习惯，直接写成
CStack s3(200)呢？