世界上存在成千上万种学习法，如果上天只让我掌握一种，那一定就是“费曼学习法”。


## 介绍
费曼学习法是由诺贝尔物理学奖获得者理查德·费曼提出的一种学习方法，其核心思想是将所学内容用自己的话表达出来，以此检验自己对知识的掌握程度。

费曼学习法可以简化为四个单词：**Concept**、**Teach**、**Review**、**Simplify**

具体而言，费曼学习法包括以下几个步骤：

- **Concept**：选择一个主题，并尽可能全面地了解这个主题；

- **Teach**：将所学内容以简明易懂的语言写下来或讲述给别人听，使用通俗易懂的语言和例子，避免使用学术术语和复杂的句子；

- **Review**：检查自己的表达是否清晰明了，是否有遗漏或错误；

- **Simplify**：基于反馈修正自己的表达，直到能够清晰表达该主题。

其优点是：

- 突出重点：在解释一个概念时，我们不得不选取最重要的信息，并将其用自己的话表达出来。这种方式可以帮助我们更好地理解和记忆知识点。

- 发现问题：当我们尝试用自己的话阐述某个主题时，常常会发现自己对某些内容并不理解或者存在疑问。这种方式可以帮助我们及时发现自己的盲点和问题，促进深层次的学习。

- 加深印象：通过不断反复的讲解和修正，我们能够形成对于某个主题的深层次理解，并加深对于相关概念的印象。

## 数据

美国学术界在1946年一项研究显示了不同学习方式的效益，准确的说，是学习者在两周以后还能记住内容（平均学习保持率）的多少。

下图是当时美国教育学家Engar Dale研究出的“学习金字塔”（The Cone of Learning）。

![image.png](https://niuery.com/static/img/a270baa53b9f0798e17123dc62717220.image.png)

由上图可以看出，**Learning by teaching 可以说是学习效率最高的方式**。

Learning by teaching --- 费曼学习法

## 引言
软件开发过程中，我们经常会遇到各种设计问题，例如如何管理对象之间的关系、如何优化代码的可复用性和可维护性等等。为了解决这些问题，我们可以使用设计模式。



设计模式是一种被广泛接受的软件设计思想，它提供了一套通用的解决方案，可以帮助我们更好地解决常见的软件设计问题。设计模式是从实践中总结出来的，它不仅可以提高代码的可读性和可维护性，还可以提高开发效率和代码的可复用性。

## 常见设计模式原则
设计模式有常见的五大原则 - [SOLID](https://niuery.com/post/9)
- 单一职责原则（SRP）
- 开放封闭原则（OCP）
- 里氏替换原则（LSP）
- 接口隔离原则（DIP）
- 依赖倒置原则（ISP）


补充第六原则，迪米特法则(Law of Demeter,LoD)也称为最少知识原则(Least Knowledge Principle,LKP)

## 常见设计模式类型
- 创建型模式：负责对象的创建和初始化，共有5种：**工厂方法模式**、**抽象工厂模式**、**单例模式**、**建造者模式**、**原型模式**。
- 结构型模式：负责对象的组合，共有7种：**适配器模式**、**装饰器模式**、**代理模式**、**外观模式**、**桥接模式**、**组合模式**、**享元模式**。
- 行为型模式：负责对象之间的通信，共有11种：**观察者模式**、**策略模式**、**迭代器模式**、**命令模式**、**责任链模式**、**模板方法模式**、**访问者模式**、**中介者模式**、**解释器模式**、**过滤器模式**、**备忘录模式**。
## 目录

### 创建型模式

1. [**抽象工厂模式（Abstract Factory Pattern）**](https://niuery.com/post/10)

抽象工厂模式是一种创建型设计模式，它提供了一种封装一组相关或相互依赖对象创建过程的方法，使得我们可以在不知道具体实现细节的情况下，创建一系列相互协作的对象。

2. [**工厂方法模式（Factory Method Pattern）**](https://niuery.com/post/33)

工厂方法模式是一种创建型设计模式，它提供了一种将对象的创建过程封装起来的方法，使得我们可以在不知道具体实现细节的情况下，创建各种不同类型的对象。

3. [**单例模式（Singleton Pattern）**](https://niuery.com/post/11)

单例模式是一种保证一个类只有一个实例的模式，它可以避免多个实例造成的资源浪费和对象的不一致性。单例模式通常使用一个私有的构造函数和一个静态的实例变量来实现。

4. [**建造者模式（Builder Pattern）**](https://niuery.com/post/13)

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式可以将复杂对象的构建过程抽象出来，从而使得系统更加灵活。

5. [**原型模式（Prototype Pattern）**](https://niuery.com/post/14)

用原型实例指定创建对象的种类，并通过复制这些原型创建新的对象。原型模式可以在运行时动态地创建对象，从而避免了静态工厂方法所带来的编译时耦合。


### 结构型模式
1. [**适配器模式（Adapter Pattern）**](https://niuery.com/post/15)

适配器模式是一种将一个类的接口转换成客户端所期望的另一种接口的模式，它可以让原本不兼容的类能够协同工作。这种模式可以避免因接口不匹配而导致的代码重构和重复开发。

2. [**装饰器模式（Decorator Pattern）**](https://niuery.com/post/16)

装饰器模式是一种在运行时动态地给对象添加新的功能的模式，它通过将对象包装在一个装饰器中来实现。这种模式可以避免使用继承带来的复杂性和静态特性，提高代码的灵活性和可扩展性。

3. [**代理模式（Proxy Pattern）**](https://niuery.com/post/17)

代理模式是一种结构型设计模式，它允许我们创建一个代理对象来控制对另一个对象的访问。代理对象可以充当原始对象的访问接口，从而控制对原始对象的访问。代理模式通常用于远程访问、延迟加载、访问控制等方面。

4. [**外观模式（Facade Pattern）**](https://niuery.com/post/18)

为一组复杂的子系统提供一个简单的接口，从而隐藏子系统的复杂性。外观模式可以降低客户端和子系统之间的耦合度，同时提高客户端的易用性。

5. [**桥接模式（Bridge Pattern）**](https://niuery.com/post/19)

桥接模式是一种将抽象部分与它的实现部分分离开来的模式，使它们可以独立地变化。这种模式可以避免因为实现细节的变化而导致的代码修改和重构。

6. [**组合模式（Composite Pattern）**](https://niuery.com/post/20)

组合模式是一种将对象组合成树形结构的模式，使得客户端可以像处理单个对象一样处理对象的组合。这种模式可以使得对象之间的关系更加清晰，提高代码的可读性和可维护性。

7. [**享元模式（Flyweight Pattern）**](https://niuery.com/post/21)

享元模式是一种结构型设计模式，用于优化对象的创建和使用。该模式通过共享相同的数据，来减少内存的使用和对象的创建。通常情况下，享元模式适用于存在大量相似对象的情况

### 行为型模式

1. [**观察者模式（Observer Pattern）**](https://niuery.com/post/12)

观察者模式是一种对象间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会收到通知并自动更新。这种模式可以降低对象之间的耦合度，提高系统的灵活性和可扩展性。

2. [**策略模式（Strategy Pattern）**](https://niuery.com/post/22)

策略模式是一种定义一系列算法的模式，它将每个算法封装在一个类中，并使它们可以互相替换。这种模式可以避免使用大量的条件语句和重复代码，提高代码的可维护性和可扩展性。

3. [**迭代器模式（Iterator Pattern）**](https://niuery.com/post/23)

迭代器模式是一种访问一个聚合对象中的各个元素的方式，而又不需要暴露该对象的内部表示。这种模式可以让客户端透明地访问聚合对象中的元素，同时避免了聚合对象的数据结构对客户端的依赖。

4. [**命令模式（Command Pattern）**](https://niuery.com/post/25)

将请求封装成对象，从而使不同的请求可以被不同的对象处理。命令模式可以将请求的发送者和接收者解耦，同时支持请求的撤销和重做

5. [**责任链模式（Chain of Responsibility Pattern）**](https://niuery.com/post/26)

将请求的发送者和接收者解耦，通过一条由多个处理对象组成的链来处理请求。责任链模式可以根据需求动态地组合处理对象，从而实现请求的自动转发和处理。

6. [**模板方法模式（Template Method Pattern）**](https://niuery.com/post/27)

定义一个操作中的算法骨架，将一些步骤延迟到子类中。模板方法模式可以提高代码的复用性和可维护性，同时可以避免子类中的代码重复

7. [**状态模式（State Pattern）**](https://niuery.com/post/28)

允许对象在内部状态发生改变时改变它的行为。状态模式将对象的行为和状态进行分离，从而将复杂的条件判断转化为简单的状态切换。

8. [**中介者模式（Mediator Pattern）**](https://niuery.com/post/29)

用一个中介对象来封装一系列的对象交互，从而使对象之间的交互松散耦合。中介者模式可以简化对象之间的交互，同时降低对象之间的依赖关系。

9. [**解释器模式（Interpreter Pattern）**](https://niuery.com/post/30)

给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。解释器模式可以将复杂的语言转化为易于处理的数据结构，从而使得语言的解释更加容易。

10. [**访问者模式（Visitor Pattern）**](https://niuery.com/post/31)

访问者模式是一种行为设计模式，它可以让你将算法与它们操作的对象分离。这样，你可以在不修改对象结构的情况下，向现有的对象结构添加新的操作。

11. [**备忘录模式（Memento Pattern）**](https://niuery.com/post/32)
备忘录模式是一种行为型设计模式，它允许我们将对象的状态保存在备忘录对象中，从而可以在以后恢复对象的状态。该模式通常用于需要撤销、恢复操作的场景，例如文本编辑器、绘图应用等。备忘录模式通过将状态保存在备忘录对象中来实现状态的恢复，从而保证了对象的封装性和数据安全性。

> 参考资料
> 
> https://dofactory.com/net/abstract-factory-design-pattern
> 
> https://refactoring.guru/design-patterns

重温设计模式 --- 前篇

## 引言  
位运算是计算机底层最基础的操作，直接操作二进制位（0 和 1）。尽管现代编程语言提供了高级抽象，但理解位运算的本质能显著提升代码效率和解决特定问题的能力。本文将深入探讨位运算的核心原理、常见技巧及其实际应用场景。



## 一、位运算的本质：二进制视角  
所有位运算都基于二进制数的逐位操作。以下是六种基本操作：  
1. **与（AND）** `&`  
   - 规则：两位均为 1 时结果为 1，否则为 0。  
   - 示例：`1010 & 1100 = 1000`  
   - 本质：掩码操作（保留/清除特定位）。  

2. **或（OR）** `|`  
   - 规则：任意一位为 1 时结果为 1。  
   - 示例：`1010 | 1100 = 1110`  
   - 本质：组合标志位（如权限合并）。  

3. **异或（XOR）** `^`  
   - 规则：两位不同时结果为 1，否则为 0。  
   - 示例：`1010 ^ 1100 = 0110`  
   - 本质：开关特性（两次异或还原原值）。  

4. **非（NOT）** `~`  
   - 规则：按位取反。  
   - 示例：`~1010 = 0101`（假设 4 位）  
   - 本质：数值取反（`~x = -(x+1)`）。  

5. **左移（SHL）** `<<`  
   - 规则：二进制位向左移动，低位补 0。  
   - 示例：`1010 << 2 = 101000`  
   - 本质：乘以 \(2^n\)（无溢出时）。  

6. **右移（SHR）** `>>`  
   - 规则：二进制位向右移动，高位补符号位（算术右移）或 0（逻辑右移）。  
   - 示例：`1010 >> 2 = 0010`（逻辑右移）  
   - 本质：除以 \(2^n\)（向下取整）。  

---

## 二、位运算的实用技巧  
1. **判断奇偶性**  
   ```csharp  
   bool isOdd = (num & 1) == 1; // 末位为 1 则为奇数  
   ```  

2. **交换两个数（无临时变量）**  
   ```csharp  
   a ^= b; // a = a ^ b  
   b ^= a; // b = b ^ (a ^ b) = a  
   a ^= b; // a = (a ^ b) ^ a = b  
   ```  

3. **求绝对值（整数）**  
   ```csharp  
   int mask = num >> 31; // 负数得全1，正数得0  
   int abs = (num ^ mask) - mask; // 负数取反加1  
   ```  

4. **检查第 k 位是否为 1**  
   ```csharp  
   bool isSet = (num & (1 << k)) != 0;  
   ```  

---

## 三、实际应用场景  
1. **状态压缩**  
   - **场景**：用单个整数表示布尔集合（如背包问题、子集枚举）。  
   - **示例**：用 `bitmask` 表示开关状态：  
     ```csharp  
     int state = 0;  
     state |= (1 << 3); // 打开第3位  
     state &= ~(1 << 3); // 关闭第3位  
     ```  

2. **高效数学计算**  
   - **乘法模拟**：`a * 7 = a << 3 - a`（因 \(7 = 8-1\)）。  
   - **2的幂判断**：`(n & (n-1)) == 0`（如 `8 & 7 = 0`）。  

3. **数据加密**  
   - **简单加密**：通过异或密钥实现快速加解密：  
     ```csharp  
     byte encrypted = data ^ key;  
     byte decrypted = encrypted ^ key; // 还原  
     ```  

4. **位图（Bitmap）**  
   - **场景**：海量数据去重（如 40 亿整数中找重复值）。  
   - **原理**：用 1 位表示一个数是否存在，内存占用仅为传统数组的 1/32。  

---

## 四、注意事项  
1. **运算符优先级**：位运算优先级低于算术运算，建议多用括号：  
   ```csharp  
   int result = (a & b) << 2; // 避免歧义  
   ```  

2. **位移边界**  
   - 左移丢弃高位，右移丢弃低位。  
   - 避免位移位数超过数据类型宽度（如 `int << 32` 未定义）。  

3. **有符号数处理**  
   - 算术右移（`>>`）保留符号位，逻辑右移（`>>>`）补 0（C# 用 `>>>`）。  

---

## 结语  
位运算将复杂问题转化为底层二进制操作，在算法优化、系统编程等领域至关重要。掌握其本质后，可灵活应用于性能敏感场景（如游戏引擎、嵌入式系统）。后续文章将探讨位运算在算法题中的实战技巧。

数据结构与算法 --- 位运算

## 引言
最近有一些碎片时间，利用碎片时间在[力扣](https://leetcode.cn/)刷一刷算法题，碰到了一道题，算法过程的子算法需要反转部分链表，看了看题解，觉得这个链表翻转的算法很有趣，也是一种有趣的思路，记录一下。



## 代码实现
还是直接上代码吧

```csharp
public class ListNode
{
	public int val;
	public ListNode next;
	public ListNode(int val = 0, ListNode next = null)
	{
		this.val = val;
		this.next = next;
	}
}

public ListNode ListNodeReverse(ListNode head)
{

	ListNode prev = null;
	ListNode curr = head;
	while (curr != null)
	{
		ListNode nextTemp = curr.next;
		curr.next = prev;
		prev = curr;
		curr = nextTemp;
	}
	return prev;
}
```
算法讲解：
1. 初始状态：`prev` 指向 `null`，`curr` 指向原始链表的头节点（`head`）。
2. 核心逻辑：
    
    通过循环逐个处理节点，每次迭代中：
    
    ①：先保存当前节点的下一个节点（避免指针丢失）。
    
    ②：将当前节点的 `next` 指针反向指向 `prev`（完成一次反转）。
    
    ③：移动 `prev` 和 `curr` 指针，继续处理下一个节点。
3. 终止条件：当 `curr` 指向 `null` 时，说明所有节点已处理完毕，`prev` 此时指向反转后链表的头节点。

## 算法流程图
根据上述的算法，我手绘了算法流程图，以此方便更快的理解上述算法：
![链表的反转.jpg](https://niuery.com/static/img/5e618b936cd96be4e044fa13afd98f8a.%C3%A9%C2%93%C2%BE%C3%A8%C2%A1%C2%A8%C3%A7%C2%9A%C2%84%C3%A5%C2%8F%C2%8D%C3%A8%C2%BD%C2%AC.jpg)

## 小结
该流程的时间复杂度为 O(n)（需遍历所有节点），空间复杂度为 O(1)（仅使用 3 个指针变量），是反转链表的最优解法之一