面试准备

C++/C++基础/1.2 复合类型.md

@@ -176,7 +176,7 @@ for(int i=0;i<row_cnt;i++){
 ![](image/2021-03-04-17-20-26.png)
 
 
-## 字符串
+## 4 字符串
 
 
 ### C 风格的字符串

C++/C++基础/12 关键词解释.md

@@ -173,4 +173,25 @@ int main()
 ## 11 final关键字
 
 * final类不能被继承。
-* final函数不能被子类重写或重定义。
+* final函数不能被子类重写或重定义。
+
+
+## 12 static
+### 1 全局static
+
+* 在函数体、块作用域之外声明的变量与函数是全局的。
+* 对于全局函数和全局变量，static修改标识符的链接属性，由默认的external变为internal，作用域和存储类型不改变，这些符号只能在声明它们的源文件中访问。
+
+
+### 2 代码块 static
+
+* 对于代码块内部的变量。static修改标识符的存储类型，由自动变量改为静态变量，作用域和链接属性不变。这种变量在程序执行之前就创建，在程序执行的整个周期都存在。
+* 对于代码块内的函数，其只能在定义它的源文件中使用，不能在其他源文件中被引用
+
+### 3 类成员 static
+
+1. **类的静态成员**：在类中，静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。因此，静态成员是类的所有对象中共享的成员，而不是某个对象的成员。对多个对象来说，静态数据成员只存储一处，供所有对象共用
+
+2. **类的静态函数**：静态成员函数和静态数据成员一样，它们都属于类的静态成员，它们都不是对象成员。因此，对静态成员的引用不需要用对象名。
+
+3. 在静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员（这点非常重要）。如果静态成员函数中要引用非静态成员时，可通过对象来引用。从中可看出，调用静态成员函数使用如下格式：<类名>::<静态成员函数名>(<参数表>);

C++/标准库/12 动态内存.md

@@ -92,6 +92,11 @@ const int * pci = new const int(1024);
 * 不能delete get()返回的普通指针
 * 不能用get()返回的指针初始化或reset另一个智能指针。
 * 如果使用智能指针管理的资源**不是new分配的内存**，传递给他一个删除器。（new分配的动态内存对应的删除器是delete）
+* 当两个智能指针指向的对象相互使用一个shared_ptr成员变量指向对方，会造成循环引用，使引用计数失效，从而导致内存泄漏。例如他们同时超出作用域，但是因为相互之间还保留一次引用计数，而没有办法销毁任何一个。
+### 智能指针概述
+
+* 智能指针主要用于管理在堆上分配的内存，它将普通的指针封装为一个栈对象。当栈对象的生存周期结束后，会在析构函数中释放掉申请的内存，从而防止内存泄漏。
+* C++ 11中最常用的智能指针类型为shared_ptr,它采用引用计数的方法，记录当前内存资源被多少个智能指针引用。**该引用计数的内存在堆上分配**。当新增一个时引用计数加1，当过期时引用计数减一。只有引用计数为0时，智能指针才会自动释放引用的内存资源。对shared_ptr进行初始化时不能将一个普通指针直接赋值给智能指针，因为一个是指针，一个是类。可以通过make_shared函数或者通过构造函数传入普通指针。并可以通过get函数获得普通指针。
 
 ## 2 动态内存管理shared_ptr
 ### shared_ptr的操作
@@ -232,7 +237,25 @@ alloc.deallocate(p,n)
 ![](image/2021-03-06-22-42-35.png)
 
 
-### allocator的简单实现
+
+### allocator 原理
+
+* STL的分配器用于封装STL容器在内存管理上的底层细节。在C++中，其内存配置和释放如下：
+
+* new运算分两个阶段：
+  1. 调用::operator new配置内存;
+  2. 调用对象构造函数构造对象内容
+
+* delete运算分两个阶段：
+  1. 调用对象希构函数；
+  2. 调用::operator delete释放内存
+
+* 为了精密分工，STL allocator将两个阶段操作区分开来：内存配置有alloc::allocate()负责，内存释放由alloc::deallocate()负责；对象构造由::construct()负责，对象析构由::destroy()负责。
+
+* 同时为了提升内存管理的效率，减少申请小内存造成的内存碎片问题，SGI STL采用了两级配置器，当分配的空间大小超过128B时，会使用第一级空间配置器；当分配的空间大小小于128B时，将使用第二级空间配置器。第一级空间配置器直接使用malloc()、realloc()、free()函数进行内存空间的分配和释放，而第二级空间配置器采用了内存池技术，通过空闲链表来管理内存。
+
+
+## 6 实例——allocator的简单实现
 
 ```C++
 #ifndef __JJALLOC__
@@ -310,3 +333,114 @@ namespace JJ{
     };
 }
 ```
+## 7 实例——shared_ptr的简单实现
+
+```C++
+template <typename T>
+class SmartPtr
+{
+private:
+    T *ptr; //底层真实的指针
+
+    int *use_count; //保存当前对象被多少指针引用计数
+
+public:
+    SmartPtr(T *p); //SmartPtr<int>p(new int(2));
+
+    SmartPtr(const SmartPtr<T> &orig); //SmartPtr<int>q(p);
+
+    SmartPtr<T> &operator=(const SmartPtr<T> &rhs); //q=p
+
+    ~SmartPtr();
+
+    T operator*(); //为了能把智能指针当成普通指针操作定义解引用操作
+
+    T *operator->(); //定义取成员操作
+
+    T *operator+(int i); //定义指针加一个常数
+
+    int operator-(SmartPtr<T> &t1, SmartPtr<T> &t2); //定义两个指针相减
+
+    void getcount() { return *use_count }
+};
+
+// int SmartPtr<T>::operator-(SmartPtr<T> &t1, SmartPtr<T> &t2) { 
+//     return t1.ptr - t2.ptr; 
+// }
+
+template <typename T>
+SmartPtr<T>::SmartPtr(T *p)
+{
+    ptr = p;
+    try
+    {
+        use_count = new int(1);
+    }
+    catch (...)
+    {
+        delete ptr; //申请失败释放真实指针和引用计数的内存
+
+        ptr = nullptr;
+        delete use_count;
+        use_count = nullptr;
+    }
+}
+template <typename T>
+SmartPtr<T>::SmartPtr(const SmartPtr<T> &orig) //复制构造函数
+
+{
+
+    use_count = orig.use_count; //引用计数保存在一块内存，所有的SmarPtr对象的引用计数都指向这里
+
+    this->ptr = orig.ptr;
+
+    ++(*use_count); //当前对象的引用计数加1
+}
+template <typename T>
+SmartPtr<T> &SmartPtr<T>::operator=(const SmartPtr<T> &rhs)
+{
+    //重载=运算符，例如SmartPtr<int>p,q; p=q;这个语句中，首先给q指向的对象的引用计数加1，因为p重新指向了q所指的对象，所以p需要先给原来的对象的引用计数减1，如果减一后为0，先释放掉p原来指向的内存，然后讲q指向的对象的引用计数加1后赋值给p
+
+    ++*(rhs.use_count);
+    if ((--*(use_count)) == 0)
+    {
+        delete ptr;
+        ptr = nullptr;
+        delete use_count;
+        use_count = nullptr;
+    }
+    ptr = rhs.ptr;
+    *use_count = *(rhs.use_count);
+    return *this;
+}
+template <typename T>
+SmartPtr<T>::~SmartPtr()
+{
+    getcount();
+    if (--(*use_count) == 0) //SmartPtr的对象会在其生命周期结束的时候调用其析构函数，在析构函数中检测当前对象的引用计数是不是只有正在结束生命周期的这个SmartPtr引用，如果是，就释放掉，如果不是，就还有其他的SmartPtr引用当前对象，就等待其他的SmartPtr对象在其生命周期结束的时候调用析构函数释放掉
+
+    {
+        getcount();
+        delete ptr;
+        ptr = nullptr;
+        delete use_count;
+        use_count = nullptr;
+    }
+}
+template <typename T>
+T SmartPtr<T>::operator*()
+{
+    return *ptr;
+}
+template <typename T>
+T *SmartPtr<T>::operator->()
+{
+    return ptr;
+}
+template <typename T>
+T *SmartPtr<T>::operator+(int i)
+{
+    T *temp = ptr + i;
+    return temp;
+}
+```

C++/面向对象/1 构造函数和析构函数.md

@@ -15,8 +15,27 @@
 > * 赋值——拷贝赋值运算符、移动赋值运算符
 > * 销毁——析构函数
 
+## 1 构造函数
 
-## 1. 拷贝构造函数
+> 与类同名的，没有返回值的函数，用来创建、赋值、移动、销毁该类的对象。
+## 1.1 合成构造函数
+
+编译器自动生成的一系列构造函数。包括以下几种
+* 合成默认构造函数
+  * 当用户定义了任意类型的构造函数，编译器不再自动生成合成默认构造函数
+* 合成拷贝构造函数
+  * 即是用户定义了其他类型的构造函数，编译器还会自动生成合成拷贝构造函数。
+  * 编译器自动生成的拷贝构造函数。从给定的对象中依次将每个非static成员拷贝到正在创建的对象当中。
+* 合成析构函数
+  * 系统自动生成的析构函数。
+
+## 1.2 默认构造函数
+
+无参构造函数。
+
+## 1.3 拷贝构造函数
+
+唯一参数是当前类类型，或者当前类型的const引用。
 
 ### 示例
 ```
@@ -25,11 +44,10 @@ class Foo{
     Foo(const Foo&)//拷贝构造函数
 }
 ```
-### 合成拷贝构造函数
 
-* 编译器自动生成的拷贝构造函数。从给定的对象中依次将每个非static成员拷贝到正在创建的对象当中。
+### 赋值初始化（拷贝构造函数）
 
-### 赋值初始化
+> 赋值初始化的时候会自动调用拷贝构造函数。
 
 ```
 string nies = string("efji");
@@ -39,15 +57,26 @@ string nies = string("efji");
 * 从一个返回类型为费引用类型的函数返回一个对象
 * 用花括号列表初始化一个数组中的元素或一个聚合类中的成员
 
-### 拷贝赋值运算符
+### 赋值运算符（拷贝运算符）
+
+> 普通赋值的时候，会调用重载的赋值运算符。
 
 * 编译器会自动生成合成拷贝赋值运算符
 * 需要重载赋值运算符。
 
+## 1.4 移动构造函数
+
+
+## 1.5 委托构造函数
+
+* 使用已有的构造函数初始化。
+
+
 ## 2 析构函数
 
 ### 定义析构函数
-* 类的成员函数，由拨浪汉接类名构成，没有返回值，不接受参数。不能被重载，一个类只有一个析构函数。
+* 析构函数与构造函数对应，当对象结束其生命周期，如对象所在的函数已调用完毕时，系统会自动执行析构函数。
+* 类的成员函数，由拨浪号接类名构成，没有返回值，不接受参数。不能被重载，一个类只有一个析构函数。
 
 ```
 class Foo{
@@ -65,7 +94,20 @@ class Foo{
 * 容器被销毁
 * 动态对象，使用delete
 
+### 对象析构顺序
+
+1. 派生类本身的析构函数；
+2. 对象成员析构函数；
+3. 基类析构函数。
 
 
+## 3 虚函数与构造函数和析构函数
 
+### 构造函数不必是虚函数
 
+1. 对象通过虚函数指针访问虚函数。在执行构造函数之前，虚函数指针没有创建，所以即使声明为虚函数，也不会有多态，所以不必要是虚函数。
+
+### 析构函数必须是虚函数
+
+1. 删除动态运行时的具体对象。
+2. 普通对象如果不被继承，析构函数可以不使用虚函数。避免生成虚函数表和虚函数指针，浪费内存空间。

C++/面向对象/2 运算符重载两种方式.md

@@ -503,3 +503,4 @@ int main()
 	return 0;
 }
 ```
+

C++/面向对象/2.cpp

@@ -0,0 +1,107 @@
+template <typename T>
+class SmartPtr
+{
+private:
+    T *ptr; //底层真实的指针
+
+    int *use_count; //保存当前对象被多少指针引用计数
+
+public:
+    SmartPtr(T *p); //SmartPtr<int>p(new int(2));
+
+    SmartPtr(const SmartPtr<T> &orig); //SmartPtr<int>q(p);
+
+    SmartPtr<T> &operator=(const SmartPtr<T> &rhs); //q=p
+
+    ~SmartPtr();
+
+    T operator*(); //为了能把智能指针当成普通指针操作定义解引用操作
+
+    T *operator->(); //定义取成员操作
+
+    T *operator+(int i); //定义指针加一个常数
+
+    int operator-(SmartPtr<T> &t1, SmartPtr<T> &t2); //定义两个指针相减
+
+    void getcount() { return *use_count }
+};
+
+// int SmartPtr<T>::operator-(SmartPtr<T> &t1, SmartPtr<T> &t2) { 
+//     return t1.ptr - t2.ptr; 
+// }
+
+template <typename T>
+SmartPtr<T>::SmartPtr(T *p)
+{
+    ptr = p;
+    try
+    {
+        use_count = new int(1);
+    }
+    catch (...)
+    {
+        delete ptr; //申请失败释放真实指针和引用计数的内存
+
+        ptr = nullptr;
+        delete use_count;
+        use_count = nullptr;
+    }
+}
+template <typename T>
+SmartPtr<T>::SmartPtr(const SmartPtr<T> &orig) //复制构造函数
+
+{
+
+    use_count = orig.use_count; //引用计数保存在一块内存，所有的SmarPtr对象的引用计数都指向这里
+
+    this->ptr = orig.ptr;
+
+    ++(*use_count); //当前对象的引用计数加1
+}
+template <typename T>
+SmartPtr<T> &SmartPtr<T>::operator=(const SmartPtr<T> &rhs)
+{
+    //重载=运算符，例如SmartPtr<int>p,q; p=q;这个语句中，首先给q指向的对象的引用计数加1，因为p重新指向了q所指的对象，所以p需要先给原来的对象的引用计数减1，如果减一后为0，先释放掉p原来指向的内存，然后讲q指向的对象的引用计数加1后赋值给p
+
+    ++*(rhs.use_count);
+    if ((--*(use_count)) == 0)
+    {
+        delete ptr;
+        ptr = nullptr;
+        delete use_count;
+        use_count = nullptr;
+    }
+    ptr = rhs.ptr;
+    *use_count = *(rhs.use_count);
+    return *this;
+}
+template <typename T>
+SmartPtr<T>::~SmartPtr()
+{
+    getcount();
+    if (--(*use_count) == 0) //SmartPtr的对象会在其生命周期结束的时候调用其析构函数，在析构函数中检测当前对象的引用计数是不是只有正在结束生命周期的这个SmartPtr引用，如果是，就释放掉，如果不是，就还有其他的SmartPtr引用当前对象，就等待其他的SmartPtr对象在其生命周期结束的时候调用析构函数释放掉
+
+    {
+        getcount();
+        delete ptr;
+        ptr = nullptr;
+        delete use_count;
+        use_count = nullptr;
+    }
+}
+template <typename T>
+T SmartPtr<T>::operator*()
+{
+    return *ptr;
+}
+template <typename T>
+T *SmartPtr<T>::operator->()
+{
+    return ptr;
+}
+template <typename T>
+T *SmartPtr<T>::operator+(int i)
+{
+    T *temp = ptr + i;
+    return temp;
+}

C++/面向对象/5 多态与虚函数.md

@@ -17,7 +17,7 @@
 
 > 也就是说多态性体现在指针和引用的不确实能够性上。但对象在内存中的状态是确定的。当且晋档通过指针或引用调用虚函数是，才会在运行时解析该调用，也只有在这种情况下对动态类型才有可能与静态类型不同。
 
-```
+```C++
     Bulk_quote a();//定义了对象a。这时候，无法触发多态。
     Bulk_quote* b = new Bulk_quote();//指针可以指向不同的类型的对象。
     Bulk_quote &b = a;//引用可以指向不同类型的对象。
@@ -27,7 +27,7 @@
 * 重定义：基类中没有声明函数是虚函数。派生类中对普通函数进行了重定义。只是作用域上的覆盖，没有触发多态和动态绑定。
 * 重定义不能触发动态多态。无论指针或引用绑定的是什么对象，都会根据指针或引用的类型，调用该类型的函数。而不是使用虚指针查找虚函数表。只有调用虚函数的时候，才会去根据对象的虚函数指针，查找类中的虚函数表。
 
-```
+```C++
 class A{
 public:
     int a;
@@ -66,7 +66,7 @@ int main(){
 ```
 ### 实现条件
 运行时多态的条件：
-* 必须是集成关系
+* 必须是j继承关系
 * 基类中必须包含虚函数，并且派生类中一定要对基类中的虚函数进行重写。
 * 通过基类对象的指针或者引用调用虚函数。
 

C++/面试/15.构造函数和析构函数.md

@@ -1,28 +0,0 @@
-# 类的构造函数
-
-> 与类同名的，没有返回值的函数，用来创建、赋值、移动、销毁该类的对象。
-
-## 合成构造函数
-
-编译器自动生成的一系列构造函数。包括以下几种
-* 合成默认构造函数
-  * 当用户定义了任意类型的构造函数，编译器不再自动生成合成默认构造函数
-* 合成拷贝构造函数
-  * 即是用户定义了其他类型的构造函数，编译器还会自动生成合成拷贝构造函数。
-* 合成析构函数
-  * 系统自动生成的析构函数。
-
-## 默认构造函数
-
-无参构造函数。
-
-## 拷贝构造函数
-
-唯一参数是当前类类型，或者当前类型的const引用。
-
-## 移动构造函数
-
-
-## 委托构造函数
-
-使用已有的构造函数初始化。

C++/面试/2.全局变量和静态变量.md

@@ -1,4 +0,0 @@
-
-* 全局变量在main方法之前声明，不显示使用static关键字。作用域是整个工程。在定义的本文件内直接使用。而其他的文件加上extern关键字声明后，也可以使用。
-* 局部静态变量由static关键字声明，他的作用域只在定义的文件，外部的文件不能用extern的方式进行使用。
-* 也就是说全局变量一定是静态变量，而静态变量不一定是全局的。anyway，这两个变量都存储在全局静态区。

C++/面试/2.全局变量和静态变量和static.md

@@ -0,0 +1,38 @@
+# 全局变量和静态变量
+
+## 1 介绍
+### 主要从两个维度进行介绍：
+
+1. 静态函数和静态变量。用来修饰不同的类型。
+2. 在类中、在块中、在全局中修饰的区别。
+
+### 主要影响的有两个过程
+1. 作用域范围。全局、文件中、块作用域内
+2. 存储类型。静态类型。
+
+### 补充的基础情况
+
+1. 默认情况下，全局变量是静态变量和全局变量。
+
+### 相关的关键字
+
+* static的用法
+
+## 2 全局static
+
+* 在函数体、块作用域之外声明的变量与函数是全局的。
+* 对于全局函数和全局变量，static修改标识符的链接属性，由默认的external变为internal，作用域和存储类型不改变，这些符号只能在声明它们的源文件中访问。
+
+
+## 2 代码块 static
+
+* 对于代码块内部的变量。static修改标识符的存储类型，由自动变量改为静态变量，作用域和链接属性不变。这种变量在程序执行之前就创建，在程序执行的整个周期都存在。
+* 对于代码块内的函数，其只能在定义它的源文件中使用，不能在其他源文件中被引用
+
+## 3 类成员 static
+
+1. **类的静态成员**：在类中，静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。因此，静态成员是类的所有对象中共享的成员，而不是某个对象的成员。对多个对象来说，静态数据成员只存储一处，供所有对象共用
+
+2. **类的静态函数**：静态成员函数和静态数据成员一样，它们都属于类的静态成员，它们都不是对象成员。因此，对静态成员的引用不需要用对象名。
+
+3. 在静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员（这点非常重要）。如果静态成员函数中要引用非静态成员时，可通过对象来引用。从中可看出，调用静态成员函数使用如下格式：<类名>::<静态成员函数名>(<参数表>);

C++/面试/21.数组和指针的区别.md

@@ -0,0 +1,18 @@
+
+
+### const char * arr = "123"; char * brr = "123"; const char crr[] = "123"; char drr[] = "123";
+
+const char * arr = "123";
+//字符串123保存在常量区，const本来是修饰arr指向的值不能通过arr去修改，但是字符串“123”在常量区，本来就不能改变，所以加不加const效果都一样
+
+char * brr = "123";
+
+//字符串123保存在常量区，这个arr指针指向的是同一个位置，同样不能通过brr去修改"123"的值
+
+const char crr[] = "123";
+
+//这里123本来是在栈上的，但是编译器可能会做某些优化，将其放到常量区
+
+char drr[] = "123";
+
+//字符串123保存在栈区，可以通过drr去修改

Python/conda/1 概述.md

@@ -0,0 +1,82 @@
+# conda 对比
+
+> 参考文献
+> * [jianshu.com/p/62f155eb6ac5](jianshu.com/p/62f155eb6ac5)
+
+
+## 简介
+
+Anaconda（官方网站）就是可以便捷获取包且对包能够进行管理，同时对环境可以统一管理的发行版本。Anaconda包含了conda、Python在内的超过180个科学包及其依赖项。
+
+## 1 Anaconda
+* Anaconda是一个包含180+的科学包及其依赖项的发行版本。其包含的科学包包括：conda, numpy, scipy, ipython notebook等。
+
+## 2 conda
+
+* conda是包及其依赖项和环境的管理工具。
+* 既是一个包管理工具，同pip，也是一个环境管理工具，同virtualenv
+
+* 适用语言：Python, R, Ruby, Lua, Scala, Java, JavaScript, C/C++, FORTRAN。
+
+* 适用平台：Windows, macOS, Linux
+
+### 用途：
+
+1. 快速安装、运行和升级包及其依赖项。
+2. 在计算机中便捷地创建、保存、加载和切换环境。
+
+> 如果你需要的包要求不同版本的Python，你无需切换到不同的环境，因为conda同样是一个环境管理器。仅需要几条命令，你可以创建一个完全独立的环境来运行不同的Python版本，同时继续在你常规的环境中使用你常用的Python版本。——conda官方网站
+
+3. conda为Python项目而创造，但可适用于上述的多种语言。
+4. conda包和环境管理器包含于Anaconda的所有版本当中。
+
+## 3 pip
+* pip是用于安装和管理软件包的包管理器。
+
+* pip编写语言：Python。
+
+* Python中默认安装的版本：
+    * Python 2.7.9及后续版本：默认安装，命令为pip
+    * Python 3.4及后续版本：默认安装，命令为pip3
+* pip名称的由来：pip采用的是递归缩写进行命名的。其名字被普遍认为来源于2处：
+    * “Pip installs Packages”（“pip安装包”）
+    * “Pip installs Python”（“pip安装Python”）
+## 4 virtualenv
+* virtualenv：用于创建一个独立的Python环境的工具。
+
+### 解决问题：
+
+* 当一个程序需要使用Python 2.7版本，而另一个程序需要使用Python 3.6版本，如何同时使用这两个程序？
+  1. 如果将所有程序都安装在系统下的默认路径，如：/usr/lib/python2.7/site-packages，当不小心升级了本不该升级的程序时，将会对其他的程序造成影响。
+  2. 如果想要安装程序并在程序运行时对其库或库的版本进行修改，都会导致程序的中断。
+
+* 在共享主机时，无法在全局site-packages目录中安装包。
+
+* virtualenv将会为它自己的安装目录创建一个环境，这并不与其他virtualenv环境共享库；同时也可以选择性地不连接已安装的全局库。
+
+## 5 pip 与 conda 比较
+### 依赖项检查
+pip：
+* 不一定会展示所需其他依赖包。
+* 安装包时或许会直接忽略依赖项而安装，仅在结果中提示错误。
+
+conda：
+* 列出所需其他依赖包。
+* 安装包时自动安装其依赖项。
+* 可以便捷地在包的不同版本中自由切换。
+
+### 环境管理
+* pip：维护多个环境难度较大。
+* conda：比较方便地在不同环境之间进行切换，环境管理较为简单。
+
+### 对系统自带Python的影响
+* pip：在系统自带Python中包的**更新/回退版本/卸载将影响其他程序。
+* conda：不会影响系统自带Python。
+
+### 适用语言
+* pip：仅适用于Python。
+* conda：适用于Python, R, Ruby, Lua, Scala, Java, JavaScript, C/C++, FORTRAN。
+
+## 6 conda与pip、virtualenv的关系
+
+* conda结合了pip和virtualenv的功能。

Python/conda/2 管理conda.md

@@ -0,0 +1,36 @@
+# 管理conda
+
+
+> 参考文献
+> * [jianshu.com/p/62f155eb6ac5](jianshu.com/p/62f155eb6ac5)
+
+
+> Windows用户请打开“Anaconda Prompt”；
+
+## 1. 验证conda已被安装
+```
+conda --version
+```
+* 终端上将会以conda 版本号的形式显示当前安装conda的版本号。如：conda 3.11.0
+
+* 注意：如果出现错误信息，则需核实是否出现以下情况：
+  * 使用的用户是否是安装Anaconda时的账户。
+  * 是否在安装Anaconda之后重启了终端。
+
+## 2. 更新conda至最新版本
+```
+conda update conda
+```
+* 执行命令后，conda将会对版本进行比较并列出可以升级的版本。同时，也会告知用户其他相关包也会升级到相应版本。
+
+* 当较新的版本可以用于升级时，终端会显示Proceed ([y]/n)?，此时输入y即可进行升级。
+
+## 3. 查看conda帮助信息
+
+```
+conda --help
+```
+或
+```
+conda -h
+```

Python/conda/3 管理环境.md

@@ -0,0 +1,80 @@
+#  管理环境
+> Windows用户请打开“Anaconda Prompt”；
+
+
+> 参考文献
+> * [jianshu.com/p/62f155eb6ac5](jianshu.com/p/62f155eb6ac5)
+
+
+## 1 创建新环境
+
+```
+conda create --name <env_name> <package_names>
+```
+
+注意：
+
+* `<env_name>`即创建的环境名。建议以英文命名，且不加空格，名称两边不加尖括号“<>”。
+* `<package_names>`即安装在环境中的包名。名称两边不加尖括号“<>”。
+  * 如果要安装指定的版本号，则只需要在包名后面以=和版本号的形式执行。如：conda create --name python2 python=2.7，即创建一个名为“python2”的环境，环境中安装版本为2.7的python。
+  * 如果要在新创建的环境中创建多个包，则直接在`<package_names>`后以空格隔开，添加多个包名即可。如：conda create -n python3 python=3.5 numpy pandas，即创建一个名为“python3”的环境，环境中安装版本为3.5的python，同时也安装了numpy和pandas。
+
+* `--name`同样可以替换为-n。
+
+> 提示：默认情况下，新创建的环境将会被保存在`/Users/<user_name>/anaconda3/env`目录下，其中，`<user_name>`为当前用户的用户名。
+
+## 2. 切换环境
+### Linux 或 macOS
+```
+source activate <env_name>
+```
+### Windows
+```
+activate <env_name>
+```
+### 提示
+* 如果创建环境后安装Python时没有指定Python的版本，那么将会安装与Anaconda版本相同的Python版本，即如果安装Anaconda第2版，则会自动安装Python 2.x；如果安装Anaconda第3版，则会自动安装Python 3.x。
+* 当成功切换环境之后，在该行行首将以“(env_name)”或“[env_name]”开头。其中，“env_name”为切换到的环境名。如：在macOS系统中执行source active python2，即切换至名为“python2”的环境，则行首将会以(python2)开头。
+
+## 3. 退出环境至root
+### Linux 或 macOS
+```
+source deactivate
+```
+### Windows
+```
+deactivate
+```
+### 提示
+* 当执行退出当前环境，回到root环境命令后，原本行首以“(env_name)”或“[env_name]”开头的字符将不再显示。
+
+## 4. 显示已创建环境
+```
+conda info --envs
+conda info -e
+conda env list
+```
+例如：
+
+![](image/2021-04-16-17-45-55.png)
+
+* 结果中星号“*”所在行即为当前所在环境。macOS系统中默认创建的环境名为“base”。
+
+## 5. 复制环境
+```
+conda create --name <new_env_name> --clone <copied_env_name>
+```
+注意：
+* <copied_env_name>即为被复制/克隆环境名。环境名两边不加尖括号“<>”。
+
+* <new_env_name>即为复制之后新环境的名称。环境名两边不加尖括号“<>”。
+
+* 如：conda create --name py2 --clone python2，即为克隆名为“python2”的环境，克隆后的新环境名为“py2”。此时，环境中将同时存在“python2”和“py2”环境，且两个环境的配置相同。
+
+## 6. 删除环境
+
+```
+conda remove --name <env_name> --all
+```
+
+* 注意：<env_name>为被删除环境的名称。环境名两边不加尖括号“<>”

Python/conda/4 管理包.md

@@ -0,0 +1,111 @@
+# 管理包
+
+
+## 1. 查找可供安装的包版本
+### 精确查找
+```
+conda search --full-name <package_full_name>
+```
+* 注意：
+  * --full-name为精确查找的参数。
+  * <package_full_name>是被查找包的全名。包名两边不加尖括号“<>”。
+* 例如：conda search --full-name python即查找全名为“python”的包有哪些版本可供安装。
+
+### 模糊查找
+```
+conda search <text>
+```
+* 注意：<text>是查找含有此字段的包名。此字段两边不加尖括号“<>”。
+
+* 例如：conda search py即查找含有“py”字段的包，有哪些版本可供安装。
+
+## 2. 获取当前环境中已安装的包信息
+```
+conda list
+```
+* 执行上述命令后将在终端显示当前环境已安装包的包名及其版本号。
+
+## 3. 安装包
+### 在指定环境中安装包
+```
+conda install --name <env_name> <package_name>
+```
+* 注意：
+  * <env_name>即将包安装的指定环境名。环境名两边不加尖括号“<>”。
+  * <package_name>即要安装的包名。包名两边不加尖括号“<>”。
+
+* 例如：conda install --name python2 pandas即在名为“python2”的环境中安装pandas包。
+
+### 在当前环境中安装包
+```
+conda install <package_name>
+```
+* 注意：
+  * <package_name>即要安装的包名。包名两边不加尖括号“<>”。
+  * 执行命令后在当前环境中安装包。
+* 例如：conda install pandas即在当前环境中安装pandas包。
+
+### 使用pip安装包
+* 使用场景
+  * 当使用conda install无法进行安装时，可以使用pip进行安装。例如：see包。
+
+* 命令
+  * 注意：<package_name>为指定安装包的名称。包名两边不加尖括号“<>”。如：pip install see即安装see包。
+```
+pip install <package_name>
+```
+
+* 注意
+  * pip只是包管理器，无法对环境进行管理。因此如果想在指定环境中使用pip进行安装包，则需要先切换到指定环境中，再使用pip命令安装包。
+  * pip无法更新python，因为pip并不将python视为包。
+  * pip可以安装一些conda无法安装的包；conda也可以安装一些pip无法安装的包。因此当使用一种命令无法安装包时，可以尝试用另一种命令。
+
+### 从Anaconda.org安装包
+* 使用场景
+  * 当使用conda install无法进行安装时，可以考虑从Anaconda.org中获取安装包的命令，并进行安装。
+
+* 注意
+  * 从Anaconda.org安装包时，无需注册。
+  * 在当前环境中安装来自于Anaconda.org的包时，需要通过输入要安装的包在Anaconda.org中的路径作为获取途径（channel）。查询路径的方式如下：
+  * 在浏览器中输入：http://anaconda.org，或直接点击Anaconda.org
+  * 在新页面“Anaconda Cloud”的上方搜索框中输入要安装的包名，然后点击右边“放大镜”标志。
+  * 搜索结果中有数以千计的包可供选择，此时点击“Downloads”可根据下载量进行排序，最上面的为下载最多的包。（图中以搜索bottleneck包为例）
+  * 选择满足需求的包或下载量最多的包，点击包名。
+  * 复制“To install this package with conda run:”下方的命令，并粘贴在终端中执行。
+  * 完成安装。
+
+## 4. 卸载包
+### 卸载指定环境中的包
+```
+conda remove --name <env_name> <package_name>
+```
+* 注意：
+  * <env_name>即卸载包所在指定环境的名称。环境名两边不加尖括号“<>”。
+  * <package_name>即要卸载包的名称。包名两边不加尖括号“<>”。
+
+* 例如：conda remove --name python2 pandas即卸载名为“python2”中的pandas包。
+
+### 卸载当前环境中的包
+```
+conda remove <package_name>
+```
+* 注意：
+  * <package_name>即要卸载包的名称。包名两边不加尖括号“<>”。
+  * 执行命令后即在当前环境中卸载指定包。
+* 例如：conda remove pandas即在当前环境中卸载pandas包。
+
+## 5. 更新包
+### 更新所有包
+```
+conda update --all
+conda upgrade --all
+```
+* 建议：在安装Anaconda之后执行上述命令更新Anaconda中的所有包至最新版本，便于使用。
+### 更新指定包
+```
+conda update <package_name>
+conda upgrade <package_name>
+```
+* 注意：
+  * <package_name>为指定更新的包名。包名两边不加尖括号“<>”。
+  * 更新多个指定包，则包名以空格隔开，向后排列。如：conda update pandas numpy matplotlib即更新pandas、numpy、matplotlib包。

Tensorflow/TensorFlow1.0/1 TensorFlow概述.md

@@ -1,10 +1,10 @@
-## 基本概念
+# 基本概念
 
-##### 人工智能
+## 人工智能
 
 机器模拟人的意识和思维。是一种科研领域。
 
-##### 机器学习
+## 机器学习
 
 1. 定义：机器学习是一种统计学方法。计算机利用已有数据，得出某种模型，再利用此模型预测结果。
 2. 应用：对连续数据的预测；对离散数据的分类。
@@ -12,7 +12,7 @@
 
 > 决策树模型是一种简单的深度学习模型。
 
-##### 深度学习
+## 深度学习
 是基于深层次神经网络的学习模型，是机器学习的一种方式。机器学习还有很多种学习模型。机器学习是一种领域，而深度学习，是一种算法。（之前好像写过相关的区别。
 
 > 神经网络的发展过程：单层神经网络（感知机）->双层次神经网络->深度神经网络+卷积神经网络+循环神经网络。

Tensorflow/TensorFlow1.0/TensorFlow-IO.md

@@ -6,7 +6,7 @@
 ### preload
 
 直接将数据设置为常量，加载到TensorFlow的graph中。
-```
+```py
 import tensorflow as tf
 x1 = tf.constant([2,3,4])
 x2 = tf.constant([4,0,1])
@@ -37,7 +37,7 @@ with tf.Session() as sess:
 
 > 基于队列（Queue）API构建输入通道（pipelines）,读取文件中的数据
 
-##### 原理介绍
+### 原理介绍
 
 * 使用字符串张量(比如["file0", "file1"]) 或者tf.train.match_filenames_once 函数来产生文件名列表。
 * 文件名打乱（可选）（Optional filename shuffling）。

Tensorflow/TensorFlow1.0/TensorFlow-自定义IO.md

@@ -1,8 +1,8 @@
-## TensorFlow-自定义IO
+# TensorFlow-自定义IO
 
-### 基本介绍
+## 基本介绍
 
-##### 架构
+### 架构
 
 * 文件格式: 我们使用 Reader Op来从文件中读取一个 record (可以使任意字符串)。
 * 记录格式: 我们使用解码器或者解析运算将一个字符串记录转换为TensorFlow可以使用的张量。

Tensorflow/TensorFlow1.0/说明.md

@@ -1,15 +0,0 @@
-## 基本概念
-
-### 人工智能
-机器模拟人的意识和思维。是一种科研领域。
-
-### 机器学习
-定义：机器学习是一种统计学方法。计算机利用已有数据，得出某种模型，再利用此模型预测结果。
-应用：对连续数据的预测；对离散数据的分类。
-是人工智能的一种方法。
-决策树模型是一种简单的深度学习模型。
-
-### 深度学习
-是基于深层次神经网络的学习模型，是机器学习的一种方式。机器学习还有很多种学习模型。机器学习是一种领域，而深度学习，是一种算法。（之前好像写过相关的区别。
-
-> 神经网络的发展过程：单层神经网络（感知机）->双层次神经网络->深度神经网络+卷积神经网络+循环神经网络。

Tensorflow/TensorFlow2.0/004.md

@@ -1 +0,0 @@
-# 初级

Tensorflow/TensorFlow2.0/005.md

@@ -1 +0,0 @@
-# Keras 机器学习基础知识

Tensorflow/TensorFlow2.0/009.md

@@ -120,8 +120,6 @@ dataset['Japan'] = (origin == 3)*1.0
 dataset.tail() 
 ```
 
-<devsite-iframe><iframe src="/tutorials/keras/regression_e0297b2db24ea564c306921a48f1bc40c18ddc626a86746db61cd82dbc3c3c20.frame" class="framebox inherit-locale " allowfullscreen="" is-upgraded=""></iframe></devsite-iframe>
-
 ### 拆分训练数据集和测试数据集
 
 现在需要将数据集拆分为一个训练数据集和一个测试数据集。
@@ -157,8 +155,6 @@ train_stats = train_stats.transpose()
 train_stats 
 ```
 
-<devsite-iframe><iframe src="/tutorials/keras/regression_ba0849c742fe92394897de4a92ca81859740311a71cec773244f86a46b761fea.frame" class="framebox inherit-locale " allowfullscreen="" is-upgraded=""></iframe></devsite-iframe>
-
 ### 从标签中分离特征
 
 将特征值从目标值或者"标签"中分离。 这个标签是你使用训练模型进行预测的值。
@@ -305,8 +301,6 @@ hist['epoch'] = history.epoch
 hist.tail() 
 ```
 
-<devsite-iframe><iframe src="/tutorials/keras/regression_52ac85b91795872c54d7abf74ad7251d16b43867b9d311b29a56d2648222a3f7.frame" class="framebox inherit-locale " allowfullscreen="" is-upgraded=""></iframe></devsite-iframe>
-
 ```py
 def plot_history(history):
   hist = pd.DataFrame(history.history)

工作日志/2021年2月27日-三月份计划.md

@@ -14,13 +14,13 @@
     - [x] 基础语法 √
     - [x] 标准库 STL√
     - [x] 面向对象 √
-    - [ ] 设计模式（有道云笔记，源网址，gitee设计模式库，书）
+    - [x] 设计模式（有道云笔记，源网址，gitee设计模式库，书）√
     - [ ] effective 系列
     - [ ] 系列视频（知乎上收藏的内容）
       - [ ] 狂神java、linux系列
       - [ ] C++ coding系列
     - [ ] 看大佬写C++。(chermo)
-    - [ ] 问题专项解决
+    - [x] 面试问题专项解决
   - Java（四周）
     - [ ] 语法
     - [ ] 标准库-网络编程
@@ -31,6 +31,7 @@
     - [ ] 《大话数据结构》
     - [ ] 《数据结构与算法分析》
     - [ ] 《算法图解》
+    - [x] 数据结构笔记（线性、堆栈、树、图）
   - 算法（一周）
     - [x] 学习、复习枚举法
     - [x] 学习、复习分治法（把相关思想下的问题和算法补充完整）

工作日志/2021年3月19日-四月份计划.md

@@ -47,8 +47,9 @@
     - [ ] pandas
   - [ ] sklearn复习
   - [ ] pytorch复习
+  - [ ] tensorflow复习
 
-- 视频教程
+- 复习（视频教程）
   - [ ] pandas
   - [ ] sklearn
   - [ ] pytorch
@@ -58,12 +59,6 @@
 > 1. 首先，学习完成所有的内容，大致会用，完成第一次开发。
 > 2. 然后看论文，进行第二轮复习，完成第二轮开发。第二论复习主要使用xmind进行知识的整理和规划。第二轮开发主要是结合论文中的方法，对论文中方法进行复现。
 
-### **联邦学习文章复现（四周）**
-
-> 阅读当前最新的联邦学习文章。使用别人的代码复现联邦学习的过程。复习和复现
-
-- [ ] DeepAMD
-- [ ] CIC
 
 ### **恶意软件数据处理（四周）**
 
@@ -120,16 +115,13 @@
 ## 计划
 
 在笔记本上的阶段性安排：
-1. 第四周：完成上一周的算法的收尾。
-2. 第五周：主要课程的复习
-3. 第六周：机器学习技术栈的全部完成
-4. 第七周：基本数据处理-工程实现完成
-5. 第八周：论文的阅读和复现工作。包括联邦学习和恶意软件机器学习。
+1. 第六周：机器学习技术栈的全部完成
+2. 第七周：基本数据处理-工程实现完成
+3. 第八周：论文的阅读和复现工作。包括联邦学习和恶意软件机器学习。
 
 ## 收获
 
-* 第六周（4.5-4.11）
-* 第七周（4.12-4.18）
+* 第六周（4.5-4.11）:本来应该完成的任务都没有完成。基础知识没有学习完，一直在准备面试笔试相关的东西。
+* 第七周（4.12-4.18）：已经收尾了本来应该完成的任务也一直没有完成。至少把之前的计划完成。四月份计划彻底解决。
 * 第八周（4.19-4.25）
-* 第九周（4.25-4.30）
 

工作日志/2021年3月20日-今日计划.md

@@ -17,7 +17,7 @@
 2. 每天一个联邦学习框架
    - [x] pytorch学习
 3. 每天一篇联邦学习的文章。
-   - [ ] deepAMD
+   - [ ] ~~deepAMD~~
 4. 每天数据集处理一小步。
    - [X] 获取2020年的两个超大型数据集，并存到云盘当中
    - [X] 获取CIC关于恶意软件分析的论文

工作日志/2021年3月21日-今日计划.md

@@ -4,7 +4,7 @@
 2. 每天一个联邦学习框架
    - [x] pytorch
 3. 每天一篇联邦学习的文章。
-   - [ ] 联邦半监督学习
+   - [ ] ~~联邦半监督学习~~
 
 
 > 明天实现动态数据处理的脚本

工作日志/2021年4月10日-今日计划.md

@@ -11,3 +11,8 @@
 
 ## 收获
 
+* 主要学习了各种设计模式。创建型设计模式包括单例模式（如何做到线程安全）、工厂方法、抽象工厂、生成器、原型模式等。用来创建指定的类的对象。
+* 结构型设计模式。主要包括适配器模式，用来封装一个类，以使其使用某个接口，一般是依赖一个具体类的对象，继承一个接口类。桥接模式、使用两个抽象的接口，实现两个角色的相互连接。比如电视有很多实现、遥控器有很多实现。他们之间只要通过接口中的一个对象连接在一块，电视的实现不需要知道使用的是哪个具体的遥控器，遥控器也不需要知道用哪个具体的电视。组合模式，通过**子类依赖多个父类的对象**，将父类的多个实现进行组合。装饰器模式，一般使用来丰富一个对象的内容，但是不是通过多重继承的方法，而是通过**子类依赖一个父类的对象**，在父类的某个实现上动态添加更多的功能。外观模式，主要提供一组类的统一的接口。享元模式主要是用来避免创建大量重复类型的对象，有一个享元工厂，根据想享元的状态判别是否存在相同状态的享元，如果存在就不会创建新的对象，而是直接使用线程的对象。
+* 行为型设计模式。这里主要提一部分。责任链模式，主要定义了一系列相互关联的类，用来流水线处理数据，与装饰器模式相似，动态添加一系列功能或者。迭代器主要是用来实现一个迭代器接口，可以用来next来访问下一个。用来迭代内部的空间。命令模式、解释模式、中介者模式、备忘录模式、观察者模式、装状态模式、策略模式、模板方法、访问者模式、空对象模式等以后再了解。
+* IO设计模式主要包括reactor和Proactor两种设计模式。前者是被动的，通过IO多路复用实现，多个阻塞IO，准备好后通过中断的方式通知线程处理数据。后者是用户自己实现的，维护一个队列，当数据准备好后，主动调用回调函数实现并行。
+

工作日志/2021年4月13日-今日计划.md

@@ -4,7 +4,7 @@
 - [x] 参加腾讯面试
 - [x] 整理完成Union、Enum两个类型的数据
 - [x] 实现C++ string类
-- [ ] 面向对象——虚函数：构造函数能够是虚函数、多态虚函数/纯虚函数知识补充。（感觉这个东西可放到C++基础中进行介绍了）
+- [x] 面向对象——虚函数：构造函数能够是虚函数、多态虚函数/纯虚函数知识补充。（感觉这个东西可放到C++基础中进行介绍了）
 - [x] 面向对象——继承C++函数重载和运算符重载整理
 - [x] C字符串整理以及其他函数了解
 

工作日志/2021年4月16日-感悟.md

@@ -0,0 +1,15 @@
+红色的耳机又找不到了。按理说，应该在自己的桌子上或者宿舍里。但感觉好久都没见到了。自从上次回家之后，就再也没有见过。好想开始学习啊。就看视频。看别人怎么操作。已经看说明文档看够了，是时候看点视频学习一下别人怎么一步一步操作了，远比楷书效率来的高。看视频更容易入门。看书更容易深入。
+
+每次都是这样。一旦开始学习就拼命。一旦不知道怎么开始学习，就开始放纵。已经有四天没有做过任何事情了。最近毕设与面试的进度都陷入了停滞状态。
+
+我接下来应该做什么。应该从什么开始做下去？每每到这个时候，总是这两个永恒的问题。每次陷入这种不知所措的境地。
+
+好久没有像现在这样惬意了，在八九年前？还是十几年前？曾经有过相同的感觉，那时候的窗子，还是木头格子的，偶尔会有几篇碎掉的，用那种老化的塑料布贴在上边，似乎是从那种蔬菜大棚上退休的就塑料布，每次有点疯吹过就会呼哧呼哧地响，总会有闲人在上边戳几个窟窿，也不怕夏天的蚊蝇，那些虫子都是从正门大摇大摆地飞进来的。那时候看天空，可能什么都不想，也可能是天马行空地思考，也不会在乎接下来要干什么。玩吧，能有什么计划，从来都是几个人一拍即合的事情，或者走到哪玩到哪。也不是为了吃什么，也不是为了玩什么。单纯地遇到花花草草，遇到形形色色的人，遇到小水库大田野，就很快乐。看到有人放风筝就回家掏出自己的风筝来。
+
+放风筝可能是世界上最放松的事情了。即是一天盯着天空，也没人觉得这个人有些奇怪。就几个人，坐在麦田的田垄上，春天的麦苗没有拔节，随便踩。刚开始的时候跑两步，等上了天，就可以吧手中的线全部放掉了。有的时候，觉得线不够长，就总是把好几个线团接起来。直到风筝在天上看起来已经很小，再远就要消失的是偶才肯罢休。
+
+那时候仰望天空。不会叹气。我的卧室，刚出身的时候，我就睡在那里，那张床上。后来分床睡，我去了小床，后来分屋子睡，我去了西屋。再后来，我又回来了，爸妈买了新床，新装修的屋子睡觉，我又回到了一开始出生时跟爸妈睡在一块的那张床上。果然，那张床要比其他的床，更让人容易入睡。继承了妈妈睡眠不足的坏毛病。索性就晚睡晚起呗。大学之前妈妈总会催命一样一大早叫我起来学习。大学之后，就再也没有在早上叫醒我。我啥时候睡醒，啥时候吃饭。好习惯忘得一干二净。
+
+感觉已经飘过了一大片云彩。是时候开始所谓的五月份计划了。把四月份计划的一部分剥离出来。论文阅读和论文复现应该属于五月份计划的内容。四月份计划三月份就开始执行了。三月份计划执行到四月份还没有完成。如今三四五月份计划，可以并行执行了。任务的切换果然需要消耗大量的精力，多线程不是并发解决问题的最优方案。IO多路复用（基于中断的）或者IO异步才是并行开发的最好方式。处理完一个再一个。
+
+已经整整耽误了一周了。这是第七周的周五。计划中第六周就应该完成了技术栈的补充。第七周已经做完数据处理和基本的训练方式。应该回顾一下前几天的收获。补充一下前几周的计划。之前的学习任务都完成。然后真正地开始五月份计划。开始吧。

工作日志/2021年4月17日-五月份计划.md

@@ -0,0 +1,38 @@
+## 任务
+
+> 四月份计划主要进行基础知识的学习和复习。完成了初步的数据处理。接下来的主要任务是阅读论文并完成论文复习计划。
+
+### **阅读论文计划（100篇计划）**（两周）
+
+### **联邦学习文章复现**（四周）
+
+> 阅读当前最新的联邦学习文章。使用别人的代码复现联邦学习的过程。复习和复现
+
+
+
+### **恶意软件文章复现**（四周）
+
+- [ ] DeepAMD
+- [ ] CIC
+
+
+### **联邦学习+恶意软件文章复现**（四周）
+
+
+> 后续任务：论文撰写计划（六月份计划）
+
+
+## 计划
+
+
+* 第九周（4.26-5.2）完成论文阅读计划
+* 第十周（5.3-5.9）完成论文复现计划1——联邦学习论文复现
+* 第十一周（5.10-5.16）完成论文复现计划2——恶意软件论文复现
+* 第十二周（5.17-5.23）完成论文复现计划3——联邦学习+恶意软件
+* 第十四周（5.24-5.30）完成论文复现计划4——非独立同分布并准备中期答辩。
+
+> 这样一看似乎真的没有时间。自己不过也只剩一个月的时间做完毕设了。
+
+
+## 收获
+

工作日志/2021年4月17日-字节面试感悟.md

@@ -0,0 +1,6 @@
+# 菜
+
+果然，自己还是会耿耿于怀。自己上次的说辞，没有一句话是对自己有利的。可能已经失去了最终的机会。我希望自己能够好好跟他们聊聊，实现自己的人生。
+
+有时候明明都知道结果不好。却还是硬着头皮等靴子落地的声音。不到最后不死心，总是抱着奇怪的幻想，企图用意念改变既定的结果。现在等到的智能有一个结果。没办法从过去中走出来。
+

工作日志/2021年4月19日-今日任务.md

@@ -0,0 +1,10 @@
+## 计划
+
+- [ ] 看完C++面经
+- [ ] 复习一遍面试的基础知识。
+- [ ] LeetCode三道题计划正式开启。
+- [ ] tensorflow针对两个数据集的训练完成
+- [ ] 蚂蚁金服4点的面试
+- [ ] 快手6点的面试
+
+## 收获

工作日志/2021年4月8日-简历投递记录.md

@@ -20,7 +20,7 @@
   - [ ] 04-18 20:00:00 -- 22:00:00 笔试
 > 但是TMD之前的面试进度还在。没办法参加第二次面试了，早知道，直接换个事业群，换一波人说不定还好说话。妈卖批。别是上一个boss
 
-## 商汤科技
+## ~~商汤科技~~
 
 * 岗位：研究院-后端研发工程师
 * 技术要求：
@@ -39,7 +39,7 @@
 ## ~~拼多多~~
 > 只有上海的岗位
 
-## 深睿医疗
+## ~~深睿医疗~~
 * 岗位：后端研发
 * 技术要求：
 * 流程：
@@ -59,7 +59,7 @@
 * 流程
   - [x] 简历投递https://jobs.bytedance.com/campus/position/application
   - [x] 2021-04-11 15:00 1面。北京字节跳动。
-  - [ ] 2021-04-14 11:00 3面。
+  - [x] 2021-04-14 11:00 3面。
 
 ## 阿里巴巴
 * 岗位：研发工程师C++
@@ -70,29 +70,60 @@
   * 或许，你并不熟悉C，C++，但是你不畏挑战，喜欢钻研，能够用你亮眼的成果证明自己超强的学习能力；
   * 或许，你参加过大学生数学建模竞赛，“挑战杯”，机器人足球比赛等；
 * 投递
-  -  [x] 简历投递
+  -  [x] 简历投递https://campus.alibaba.com/myJobApply.htm
   -  [x] 素质测评
   -  [x] 2021年04月09日 19:00 - 2021年04月09日 20:00。完球了没人捞我的专利，待会问问师兄。
+  -  [ ] 2021年4月19日 16:00 一面。终于还是来了。还是要好好准备的。把所有的问题复习一遍。估计很难进。
 
 > 二期简历
 
 -------------
 
-## 快手
-
-* 岗位
-* 技术要求
-* 投递
 ## 华为实习
 
+* 岗位：软件开发实习生
+* 岗位要求：
+  1. 计算机、软件、通信等相关专业本科及以上学历；
+  2. 热爱编程，基础扎实，熟悉掌握但不限于JAVA/C++/C/Python/JS/HTML/GO等编程语言中的一种或数种，有良好的编程习惯；
+  3. 具备独立工作能力和解决问题的能力、善于沟通，乐于合作，热衷新技术，善于总结分享，喜欢动手实践；
+  4. 对数据结构、算法有一定了解；
+  5. 优选条件：熟悉TCP/IP协议及互联网常见应用和协议的原理；有IT应用软件、互联网软件、IOS/安卓等相关产品开发经验，不满足于课堂所学，在校期间积极参加校内外软件编程大赛或积极参于编程开源社区组织；熟悉JS/AS/AJAX/HTML5/CSS等前端开发技术。
+* 流程
+  - [ ] 简历投递https://career.huawei.com/reccampportal/portal5/user-index.html
+
+
 ## 美团
+* 岗位：后端开发工程师
+* 岗位要求
+  1. 掌握一种以上的开发语言，包括但不限于Java、C、C++、Python、Golang等；了解MySQL等基本使用，熟练使用SQL语句；会常用的shell命令；
+  2. 具有扎实的数据结构、操作系统、数据库、算法、网络等计算机基础知识；
+  3. 优秀的学习能力和自驱力，对新技术有强烈的求知精神，能深入代码研究，能通过英文论文等第一手资料了解业界新技术，积极学习新技术提升自我、提升团队；
+  4. 优秀的逻辑思维能力，特别是流程梳理能力和建模能力，善于从复杂系统表象中分析问题。具有较强的解决问题能力，对解决复杂问题充满激情；
+  5. 善于交流，有良好的团队合作精神和协调沟通能力，有一定推动能力。
+* 流程
+  - [ ] 简历投递https://campus.meituan.com/apply-record
 
+## 快手
 
-需要补充的能力：
-* Redis nosql非关系型数据库。
-* 分布式开发
-
-
-
-
-
+* 岗位:C++ 搜索推荐实习生。基础架构中心实习生
+* 岗位要求
+  1. 本科及以上学历，计算机相关专业优先；
+  2. 熟悉C/C++或Rust，有扎实的计算机基础，对数据结构、算法基础有深入理解；
+  3. 熟悉面向对象的设计思想，了解软件开发流程；
+  4. 有实际项目经验或互联网公司实习经历者优先，有OI、ICPC等竞赛经验者优先；
+  5. 热爱互联网，对互联网产品和技术有浓厚的兴趣，热衷于追求技术极致与创新；
+  6. 具有良好的沟通能力和团队合作精神、优秀的分析问题和解决问题的能力。
+* 流程
+  - [x] 简历投递https://zhaopin.kuaishou.cn/recruit/e/#/official/my-apply/
+## 网易
+* 岗位：C++开发实习生
+* 岗位要求
+  1. 不管学的是什么专业，都有一颗对互联网无比热爱，愿意为之付出的心；
+  2. 就是喜欢C. C++这个程序语言，还就爱拿它做项目开发；
+  3. 对网络编程有研究，基本的gdb调试能力？内存泄漏，越界读写等常见问题？对你来说都不是问题；
+  4. 作为一个优秀的程序员，有良好的服务器端编程能力和编程习惯，相关模块设计. 文档编写都是小case；
+  5. 十八般武艺样样精通，掌握多线程并发编程技术，掌握各种数据结构和算法；
+  6. 熟悉windows/linux编程环境，如果有MySQL开发经验那就再 好 不 过 啦！！！
+* 流程
+  - [ ] 简历投递https://campus.163.com/app/personal/apply
+ 

算法/A类：基本算法/4.1 排列组合问题.md

@@ -1,6 +1,6 @@
 # 排列问题
 
-## 1 排列问题-分治法
+## 1 排列问题-分治法、递归法
 
 ### 问题描述
 

算法/B类：数据结构算法/3.4 栈的弹出序列.md

@@ -0,0 +1,61 @@
+## 栈的弹出序列
+
+### 问题描述
+输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。
+
+ 
+
+示例 1：
+```
+输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
+输出：true
+解释：我们可以按以下顺序执行：
+push(1), push(2), push(3), push(4), pop() -> 4,
+push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
+```
+
+示例 2：
+```
+输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
+输出：false
+解释：1 不能在 2 之前弹出。
+```
+[链接](https://leetcode-cn.com/problems/zhan-de-ya-ru-dan-chu-xu-lie-lcof)
+
+### 问题分析
+
+* 之前入栈的元素，在之后只能以逆序出现。也就是说，逆序之后的数字，都是逆序。
+
+### 策略选择
+
+
+### 算法设计
+
+
+### 算法分析
+
+### 算法实现
+```
+#include<stack>
+using namespace std;
+class Solution {
+public:
+    bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
+        stack<int> s;
+        int j=0;
+        for(int i=0;i<pushed.size();i++){
+            s.push(pushed[i]);
+            while(!s.empty()&&s.top()==popped[j]){
+                s.pop();
+                j++;
+            }
+        }
+        if(j<popped.size()){
+            return false;
+        }
+        else{
+            return true;
+        }
+    }
+};
+```

算法/B类：数据结构算法/4.4 线性区间操作.md

@@ -44,7 +44,7 @@
 
 
 ### 算法实现
-```
+```C++
 class BIT {
 private:
     vector<int> tree;

算法/C类：问题类型算法/5.1 字符串全排列.md

@@ -1,14 +1,20 @@
+## 字符串全排列
+
+### 问题描述
 
 
-## 字符串排列
-
-* 递归、回溯。
+### 策略选择
+* 循环构建全排列
+* 递归构建全排列
 * 判断相同字符的选择
 
+### 算法设计
+
+### 算法分析
 * 时间复杂度O(n!)
 * 空间复杂度O(n2)
 
-
+### 算法实现
 ```C++
     vector<string> permutation(string s) {
         vector<string> vec;

算法/C类：问题类型算法/7.1 幂集问题.md

@@ -0,0 +1,4 @@
+
+
+
+[生成幂集](../A类：基本算法/4.11%20生成子集问题.md)