领域驱动设计（Domain-Driven Design，简称 DDD）是一种软件架构方法，旨在通过分层和领域建模的方式来管理复杂业务逻辑。DDD 主要通过分层架构来组织代码，以实现高内聚、低耦合。

多态包括编译时多态和运行时多态。编译时多态，即静态绑定，通常通过方法重载实现。运行时多态则是在代码运行时确定具体调用的方法。从Java的角度看，严格意义上的多态需要满足三个条件：继承、方法覆盖和父类引用子类对象。Java完全符合这些要求，实现了严格意义上的多态。尽管Go语言、Python和JavaScript不完全符合严格意义上的多态，它们仍能够实现多态效果。多态的核心在于动态确定运行的方法，从而使代码更加灵活、易于维护和扩展。Go语言虽然没有继承和方法重载，但仍能实现多态效果。

数组(含List)去重复在日常工作中经常遇到，很多时候用到Set数据结构，但有时候我们需要针对数据进行干预，这时候就需要用其他的实现方式了。以下列出各种的去重方式，基本含括了所有情况。

【代码】C、Java、Python实现二分查找比较。

归并排序（Merge Sort）算法，也叫合并排序，是创建在归并操作上的一种有效的排序算法。算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。归并排序思路简单，速度仅次于快速排序，为稳定排序算法，一般用于对总体无序，但是各子项相对有序的数列。归并排序和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。代价是需要额外的内存空间。

访问者模式（Visitor Pattern）是一种行为型模式。它封装一个访问者类，把各元素类的操作集合起来，目的是将数据结构与数据操作分离。在不改变原有元素类数据结构的前提下，改变了元素类的执行算法。当某些较为稳定的东西（数据结构或算法），不想直接被改变但又想扩展功能，这时候适合用访问者模式。访问者模式的使用频率并不是很高，大多数情况下，你并不需要使用访问者模式，但是当你一旦需要使用它时，那你就是需要使用它了。

模板方法模式（Template Method Pattern）也叫模板模式，是一种行为型模式。它定义了一个抽象公开类，包含基本的算法骨架，而将一些步骤延迟到子类中，模板方法使得子类可以不改变算法的结构，只是重定义该算法的某些特定步骤。不同的子类以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。以此基于公共的模板，来实现实现不同的功能。模板模式适用于一些复杂操作进行步骤分割、抽取公共部分由抽象父类实现、将不同的部分在父类中定义抽象实现、而将具体实现过程由子类完成。

策略模式（Strategy Pattern）属于行为型设计模式。将每一个算法封装到具有共同接口的独立类中，根据需要来绑定策略，使得具体实现和策略解耦。当你想使用对象中各种不同的算法变体，使用if...else 所带来的复杂和难以维护，可使用策略模式。或者当有许多相同类，它们仅在执行某些行为时略有不同，可使用策略模式。

单例模式（Singleton Pattern）属于创建型设计模式，这种模式只创建一个单一的类，保证一个类只有一个实例，并提供一个访问该实例的全局节点。当您想控制实例数目，节省系统资源，并不想混用的时候，可以使用单例模式。单例有很多种实现方式，主要分为懒汉和饿汉模式，同时要通过加锁来避免线程安全。不同语言的单例实现略有差异，可以通过查看不同版本的源码来深入理解其中的差异。

代理模式（Proxy Pattern）是一种结构型设计模式，用一个类来代理另一个类或几个类的功能。在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。延迟初始化（虚拟代理）。如果你有一个偶尔使用的重量级服务对象，一直保持该对象运行会消耗系统资源时，可使用代理模式。访问控制（保护代理）。如果你只希望特定客户端使用服务对象，这里的对象可以是操作系统中非常重要的部分，而客户端则是各种已启动的程序 （包括恶意程序）， 此时可使用代理模式。

原型模式（Prototype Pattern）是一种创建型设计模式，使你能够复制已有对象，而无需使代码依赖它们所属的类，同时又能保证性能。这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。如果你需要复制一些对象，同时又希望代码独立于这些对象所属的具体类，可以使用原型模式。

观察者模式（Observer Pattern）是一种行为型模式。它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。观察者模式使用三个类Subject、Observer和Client。Subject对象带有绑定观察者到Client对象和从Client对象解绑观察者的方法。我们创建Subject类、Observer抽象类和扩展了抽象类Observer的实体类。

备忘录模式（Memento Pattern）是一种结构型设计模式。这种模式就是在不破坏封装的条件下，将一个对象的状态捕捉(Capture)住，并放在外部存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。备忘录模式常常与命令模式和迭代子模式一同使用。备忘录模式的角色有三个：备忘录(Memento)角色、发起人(Originator)角色、负责人(Caretaker)角色备忘录模式是由发起人（Originator）对象负责生成状态快照，其他对象不可修改状态。

中介者模式（Mediator Pattern）是一种行为型模式。它限制对象之间的直接交互，它用一个中介对象来封装一系列的动作，以让对象之间进行交流。中介者使各个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。当一些对象和其他对象紧密耦合以致难以对其进行修改时，或当组件因过于依赖其他组件而无法在不同应用中复用时，可使用中介者模式。

迭代器模式（Iterator Pattern），是一种结构型设计模式。给数据对象构建一套按顺序访问集合对象元素的方式，而不需要知道数据对象的底层表示。迭代器模式是与集合共存的，我们只要实现一个集合，就需要同时提供这个集合的迭代器，就像Java中的Collection，List、Set、Map等，这些集合都有自己的迭代器。假如我们要实现一个这样的新的容器，就可以引入迭代器模式，给我们的容器实现一个迭代器。

解释器模式（Interpreter Pattern）是一种行为型设计模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式常被用在 SQL 解析、符号处理引擎等。解释器模式常用于对简单语言的编译或分析实例中，为了掌握好它的结构与实现，必须先了解编译原理中的“文法、句子、语法树”等相关概念。

享元模式（Flyweight Pattern），是一种结构型设计模式。主要用于减少创建对象的数量，以减少内存占用和提高性能。它摒弃了在每个对象中保存所有数据的方式，通过共享多个对象所共有的相同状态，让你能在有限的内存容量中载入更多对象。当程序需要生成数量巨大的相似对象时，可能对内存有大量损耗，而对象中包含可抽取且能在多个对象间共享的重复状态，您可以采取享元模式。内部状态 vs. 外部状态。

外观模式（Facade Pattern），也叫门面模式，是一种结构型设计模式。它向现有的系统添加一个高层接口，隐藏子系统的复杂性，这个接口使得子系统更加容易使用。如果你需要一个指向复杂子系统的直接接口，且该接口的功能有限，则可以使用外观模式。或者需要将子系统组织为多层结构，可以使用外观。

过滤器模式（Filter Pattern）或标准模式（Criteria Pattern），是一种结构型模式。这种模式允许使用不同的标准条件来过滤一组对象，并通过逻辑运算的方式把各条件连接起来，它结合多个标准来获得单一标准。例子将创建一个 Person 对象、Criteria 接口和实现了该接口的实体类，来过滤 Person 对象的列表。Test 类使用 Criteria 对象，基于各种标准和它们的结合来过滤 Person 对象的列表。

装饰器模式（Decorator Pattern）是一种结构型设计模式。将对象放入到一个特殊封装的对象中，为这个对象绑定新的行为，具备新的能力，同时又不改变其原有结构。如果你希望在无需修改代码的情况下即可使用对象，且希望在运行时为对象新增额外的行为，可以使用装饰模式。或者你用继承来扩展对象行为的方案难以实现或者根本不可行，你可以使用该模式。

每一种语言都有自己的特色，设计模式首推用Java语言来实现，因为Java相对最全面，也非常规整。其他语言有自己的优势，并不需要像Java那么啰嗦就可以实现良好的设计模式。因此通过不同语言之间的对比，可以更好地理解各种语言的差异，真正理解编程之道。经典设计模式源码详解，用不同语言来实现，包括Java/JS/Python/TypeScript/Go等。结合实际场景，充分注释说明，每一行代码都经过检验，确保可靠。设计模式是一个程序员进阶高级的必然选择，不懂设计模式，就像写文章不懂得层次，盖房子没有结构。

组合模式（Composite Pattern），又叫部分整体模式，是一种结构型设计模式。用于把一组类似的对象当作一个单一的对象来看。组合模式依据树形结构来组合对象，用不同组件来构建某个部分或整体对象。如果你需要实现树状对象结构，可以使用组合模式。如果你希望客户端代码以相同方式处理简单和复杂元素，可以使用该模式。

命令模式（Command Pattern）是一种数据驱动的设计模式，也是一种行为型设计模式。这种模式的请求以命令的形式包裹在对象中，并传给调用对象。调用对象再寻找合适的对象，并把该命令传给相应的处理者。即把请求或操作封装成单个对象，并使其可以被参数化和延迟执行，这种方式将命令和执行者进行了有效解耦。如果你需要通过操作来参数化对象，可使用命令模式。如果你想要将操作放入队列中、操作的执行或者远程执行操作， 可使用命令模式。如果你想要实现操作回滚功能，可使用命令模式。

它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归或迭代进行，以此让整个数列变成有序序列。

这种模式为请求创建了一个接收者对象的链，允许你将请求沿着处理者链进行发送，每个处理者均可对请求进行处理，或将其传递给链上的下个处理者。当程序需要使用不同方式来处理多种类请求，且请求类型和顺序不可知，或者当必须按顺序执行多个处理时，可以使用责任链模式。避免请求发送者与接收者耦合在一起，客户只需要将请求发送到链上，而无须关心请求的处理细节和请求的传递。创建多个互不干涉的处理器，实现抽象类的next方法，以便不断执行链式检查。抽象处理器类可将各子类按任意组织为链式，以便调用。func.h 头文件函数。

但说实话OC的语法看起来不是很友好，从变量声明到对象调用，看起来与其他语言不是很一致，但总体上来也是类c的，所以本质上还是一样。Rust从语法上足够精炼，风格比较像普通的高级语言，提供的元组（Tuple）和动态数组（Vector）、切片(Slice)模式非常方便，没有C/C++操作数据那么繁琐，但同时其又保持了底层语言的优越性能，能看得出来Rust是牛人精心打造的。当全部分解后，有的情况下最后的得数刚好被质数除尽，最后的得数为1，有的情况则质数的平方大于得数，终止了循环，此时该得数大于1，就是最后的因数。

首先在待排序序列中找到最小（或最大）的元素，追加到已排序序列中，然后继续从待排序序列中寻找最小（或最大）的元素，追加到已排序序列的尾部。比较次数O(n^2)，比较次数与关键字的初始状态无关，总的比较次数N = (n-1) + (n-2) +…选择排序的比较操作为n(n-1)/2次之间。在外循环中将第 1 项与最小值进行交换，然后以第 2 项作为最小值，再重复执行步骤 2，直到遍历完全部待排序区间。设第 1 项为最小值，在内循环中将其逐个与后项进行比较，如果遇到更小的值，则更新最小值，并记录下最小值的下标。

基数排序的方式可以采用LSD（Least significant digital）或MSD（Most significant digital），LSD的排序方式由键值的最右边开始，而MSD则相反，由键值的最左边开始。LSD使用计数排序或桶排序，MSD可以使用桶排序。计数排序：根据数组值设定若干个桶，每个桶对应一个数值，将这些桶的值分别存入下一个桶中用于排序，最后按顺序取出对应桶里的值。桶排序：根据情况分为若干个桶，每个桶存储一定范围的数值，每个桶再单独排序，最后按桶的顺序取出全部数据。

快排是一种通过基准划分区块，再不断交换左右项的排序方式，其采用了分治法，减少了交换的次数。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归或迭代进行，以此让整个数列变成有序序列。将基准点左侧全部项和基点右侧全部项分别通过递归(或迭代)方式重复第1项，直到所有数组都交换完成。空间复杂度：根据实现方式的不同而不同，可以查看不同版本的源码。平均时间复杂度：O(NlogN)

从两个数组的第1项开始比较，将数值小的一项添加到新数组中，并将数值小的指针右移1位，继续两两比较，哪个小就添加到新数组中，并且右移小项的指针，直到遍历完其中一个数组，也就是把1个数组项全部添加到新数组时终止。策略三：将一个数组的长度扩展成两个数组之和，按照任意一种排序，将这个数组当成是已排序部分，遍历另外1个数组，将另外1个数组项逐个插入到这个数组中的位置中去。同时遍历数组1和数组2，比较数组1和数组2里的第一项，哪个小就追加到新数组中，小项的指针后移1位。新建1个空数组，长度为两个数组之和。

归并排序（Merge Sort）算法，也叫合并排序，是创建在归并操作上的一种有效的排序算法。归并排序思路简单，速度仅次于快速排序，为稳定排序算法，一般用于对总体无序，但是各子项相对有序的数列。归并排序和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。将上述两个序列递归合并，按照已排序数组合并，形成（n/4）个序列，每个序列包含4个数字。这里有多种语言的详细源码。

堆排序（Heap Sort）算法，是将数据看成近似完全二叉树结构，并根据完全二叉树的特性来进行排序的一种算法。完全二叉树要求每个节点的值都大于等于其左右子节点的值，称为大顶堆；或者每个节点的值都小于或等于其左右子节点的值，称为小顶堆。先将父节点的最大数取出，并构建最大堆，再将堆继续调整为最大堆，再次将堆顶的最大数取出，这个过程持续到剩余数只有一个时结束。

计数排序（Counting sort）是一种稳定的线性时间排序算法。计数排序使用一个额外的数组，数组的下标对应待排序的数字。就像给每个位置按数字顺序做好标记，然后把对应数组放入其中，最后把下标打印出来即可。计数排序适合数量较少的整数排序，对于浮点不太适合。遍历待排序数组，将数字与计数数组下标对应，按出现次数做标记；Java/Go/Python/JS/C 不同语言实现计数排序算法。新建一个计数数组，长度为最大与最小值的差值+1；平均时间复杂度：O(n + k)最佳时间复杂度：O(n + k)

桶排序（Bucket sort）也称箱排序，是一个排序算法，工作原理是将数组分到几个桶里，桶的数量可由排序数组最大值与最小值关系决定，可以固定几个桶。确定每个桶的大小以及桶的数量，桶大小为可以最大项与最小的差值除以最小值，桶的数量是大小差值除以桶大小；新建一个桶二维数组，用于存放桶数据，桶的数量和每个桶的大小就是第 1 步得到的值；遍历原始列表，再将数组项除以桶的个数得到桶的下标，将当前数组项存入到对应桶中；在存入桶中时，按顺序插入，保持桶内的顺序；平均时间复杂度 O(n+k)最差空间复杂度 O(n。

当你希望使用某个类，但是其接口与其他代码不兼容时，可以使用适配器类。当你需要复用类的共同方法，但是这些共同的方法不是所有子类的共性，你可以通过适配器模式来兼容。适配器模式（Adapter Pattern）是一种结构型设计模式，为两个不兼容的接口之间架设桥梁，使不兼容的对象能够相互合作。有一些可以重复使用的类，这些类不一定有一致的接口。通过转换类来实现（继承或依赖）不同接口的调用。建立接口转换类，将不同的类插入到转换类中。将一个类的接口转换成另外一个接口。使得原本不兼容的接口也能一同工作。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。工厂方法是一个具体工厂，用来创建对象，而抽象工厂则是用来创建工厂的类。如果代码需要与多个不同系列的相关产品交互，但是无法提前获取产品信息， 出于对未来扩展的考虑，不希望代码基于产品的具体实现进行构建，这时可以使用抽象工厂。屏蔽复杂的对象创建逻辑，交由统一的工厂方法，工厂本身也由工厂创建。建立系列产品工厂类，继承自抽象工厂类，负责具体产品的创建。具体工厂类，可以多个，继承或实现基础工厂类。建立抽象工厂类，用于创建产品工厂类。

它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。即通过遍历待排序的数列，一次比较两个元素，根据大小调换位置，直到把最大的或最小的冒出来。内循环每次都从第一项开始，将该项与待排序的后项逐个进行大小比较，再两两交换，将大的数字冒出来。先建立两个循环，外循环用于遍历整个数组，内循环遍历待排序的区间。Java/Go/Python/JS/C 语言实现冒泡排序算法。平均时间复杂度：O(N^2)最差时间复杂度：O(N^2)最佳时间复杂度：O(N)空间复杂度：O(1)

插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是将数据分为已排序和未排序两个序列，对于未排序的数据，在已排序序列中从后向前逐个遍历，找到相应位置插入的方式，其原理跟打扑克牌按顺序插入牌很类似。从未排序序列中选取一项作为比较项，跟已排序列表项自后往前逐个对比，如果比较项小于列表成员，则将列表成员逐个右移，以便空出位置。将数组分为左右两个序列，分别表示已排序和未排序。外循环遍历未排序序列，内循环遍历已排序序列。当比较项大于等于已排序的成员时，将比较项放在该成员的后面。