1.1 定义

当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。

1.2 无状态对象

如果只是看上面的定义是无法弄清楚什么是线程安全的，因此我们需要举一些例子来进行说明，就比如说Java Web开发中经常使用的Servlet，一般来说Servlet是单例的（也可以是多例的，但这里我们只讨论单例的情况）， 实例中的方法会被多个线程进行调用，因此Servlet要保证其是线程安全的。所以Servlet通常都被设计成无状态的，下面给出一个例子：

1
2
3
4
5
6
7
8
9
10
11
12

public class StatelessServlet implments Servlet {
    // ...
    
    @Override
    public void service(ServletRequest req, ServletResponse resp) {
        int i = handleReq(req);
        sendResponse(i);
    }
    
    // ...
}
        

与大多数Servlet相同，StatelessServlet是无状态的：它既不包含任何域，也不包含任何对其他类中域的引用。计算过程中的临时状态仅存在于线程栈上的局部变量中，并且只能由正在执行的线程访问。访问该Servlet的线程不会影响另一个访问同一个Servlet的线程的计算结果，因为这两个线程并没有共享状态，就好像它们都在访问不同的实例。由于线程访问无状态对象的行为并不会影响其他线程中操作的正确性，因此无状态对象是线程安全的。

无状态对象一定是线程安全的

大多数Servlet都是无状态的，从而极大地降低了在实现Servlet线程安全性时的复杂性。只有当Servlet在处理请求时需要保存一些信息，线程安全性才会成为一个问题。

1.3 实例：多窗口售票

假设有一个公园，该公园每天卖100张票，共有3个窗口进行售票，现在需要写一个程序来模拟售票的过程。下面就来实现该需求：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Ticket implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "进行售票: " + ticket--);
            } else {
                break;
            }
        }
    }
}

我们创建了一个Ticket类实现Runnable接口，接下来我们来编写测试类来进行测试：

1
2
3
4
5
6
7
8
9

public class SyncDemo {
    public static void main(String[] args) throws InterruptedException {
        Ticket ticket = new Ticket();
        for (int i = 0; i < 3; i++) {
            Thread t = new Thread(ticket);
            t.start();
        }
    }
}

既然写好了测试类，那我们就来进行测试。结果却出现了下面的情况：

• 注：为了更容易观察出这种结果可以让每个线程执行完ticket--后休眠一段时间。

通过控制台的输出我们可以轻易的观察到不同窗口（线程）竟然出现售出同一张票的情况，这显然是不符合预期的，那么该如何解决这种问题呢？

二、原子性

2.1 竟态条件

在上面多窗口售票的例子中，之所以会出现多个线程售出同一张的情况，原因就在于ticket--虽然看起来只是一个操作，但这个操作是非原子性的，因此并不会作为一个不可分割的操作来执行。实际上，它包含了三个独立的操作：读取ticket的值，将值减1，然后将计算结果写入ticket。这是一个“读取-修改-写入”的操作序列，并且其结果状态依赖于之前的状态。
​

因此在多窗口售票的例子中，在某种情况下，每个线程读到的值都是同一个值，接着执行递减操作，并将ticket的值设为原先的值减1，结果就出现不同窗口（线程）售出同一张票的情况。
​

在并发编程中，这种由于不恰当的执行时序而出现不正确的结果是一种非常重要的情况，它有一个正式的名字：**竞态条件(Race Condition)**。

2.2 实例：错误的单例模式实现

在很多情况下需要某个类是单例的，下面给出单例模式的一种实现：

1
2
3
4
5
6
7
8
9
10

public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

实际上上面的实现是错误的，在getInstance方法中存在竟态条件：假设在A、B线程中同时调用该方法，A判断instance为空，因此实例化一个Singleton对象；而B也判断instance为空，因此又实例化一个Singleton对象，这显然违背了单例模式的要求。

三、加锁机制

多窗口售票和单例模式实现的例子中都包含一组需要以原子方式执行（或者说不可分割）的操作。要避免竞态条件问题，就必须在某个线程修改该变量时，通过某种方式防止其他线程使用这个变量，从而确保其他线程只能在修改操作完成之前或之后读取和修改状态，而不是在修改状态的过程中。如果多窗口售票中的ticket--是原子操作的话，那么竟态条件就不会发生，换句话说就是“读取-修改-写入”这个复合操作要么全部不执行，要么全部执行。
Java的内置锁相当于一种互斥体（互斥锁），这意味着最多只有一个线程能持有这种锁。当线程A尝试获取一个由线程B持有的锁时，线程A必须等待或者阻塞，直到线程B释放这个锁。如果B永远不释放锁，那么A也将永远地等下去。由于每次只能有一个线程执行内置锁保护的代码块，因此，由这个锁保护的同步代码块会以原子方式执行，多个线程在执行该代码块时也不会相互干扰。并发环境中的原子性与事务应用程序中的原子性有着相同的含义一组语句作为一个不可分割的单元被执行。任何一个执行同步代码块的线程，都不可能看到有其他线程正在执行由同一个锁保护的同步代码块。

3.1 synchronized

Java提供了一种内置的锁机制来支持原子性：同步代码块（Synchronized Block）。同步代码块包括两部分：一个作为锁的对象引用，一个作为由这个锁保护的代码块。以关键字_synchronized_来修饰的方法就是一种横跨整个方法体的同步代码块，其中该同步代码块的锁就是方法调用所在的对象，静态的_synchronized_方法以Class对象作为锁。

1
2
3

synchronized(lock) {
    // 访问或修改由锁保护的共享状态
}

每个Java对象都可以用做一个实现同步的锁，这些锁被称为内置锁（Intrinsic Lock）或监视器锁（Monitor Lock）。线程在进人同步代码块之前会自动获得锁，并且在退出同步代码块时自动释放锁，而无论是通过正常的控制路径退出，还是通过从代码块中抛出异常退出。获得内置锁的唯一途径就是进入由这个锁保护的同步代码块或方法。
Java支持通过同步代码块和同步方法的形式进行加锁，下面分别介绍这两种方式：

3.1.1 同步代码块

代码格式如下：

1
2
3

synchronized(lock) {
    // 访问或修改由锁保护的共享状态
}

如果同步代码块处于非静态方法内，则可以选择当前类本身（this）或当前类中任意类型的类对象作为锁；如果如果同步代码块处于静态方法内，则可以选择当前类的Class对象作为锁。

3.1.2 同步方法

代码格式如下：

1
2
3

public synchronized void func() {
    // 访问或修改由锁保护的共享状态
}

同步方法本质上是选择当前类的Class对象作为锁。

3.2 重入

3.2.1 概念

当某个线程请求一个由其他线程持有的锁时，发出请求的线程就会阻塞。然而由于内置锁是可重入的，因此如果某个线程试图获得一个已经由它自己持有的锁，那么这个请求就会成功。“重入”意味着获取锁的操作的粒度是“线程”，而不是“调用”。

3.2.2 原理

重入的一种实现方法是为每个锁关联一个获取计数器值和一个所有者线程。当计数器值为0时，这个锁就被认为是没有被任何线程持有。当线程请求一个未被持有的锁时，JVM将记下锁的持有者，并且将获取计数器值置为1.如果同一个线程再次获取这个锁，计数值将递增，而当线程退出同步代码块时，计数器会相应地递减，当计数值为0时，这个锁将被释放。

3.2.3 为什么使用可重入锁

重入进一步提升了加锁行为的封装性，因此简化了面向对象并发代码的开发。例如下面一段代码：

1
2
3
4
5
6
7
8
9
10
11
12

public class Parent {
    public synchronized void doSomething() {
        // ...
    }
}

public class Child extends Parent {
    public synchronized void doSomething() {
        // ...
        super.doSomething();
    }
}

如果没有可重入锁，那么这段代码将产生死锁。因为 Parent 和 Child 中 doSomething 方法都是 synchronized 方法，因此每个 doSomething 方法在执行前都会获取 Parent 上的锁，如果内置锁不是可重入的，那么在调用 super.doSomething 时将无法获取 Parent 上的锁，因为这个锁已经被持有，从而线程将永远停顿下去，等待一个永远也无法获得的锁。

3.3 实例：线程安全的多窗口售票

我们使用内置锁对上面的代码进行改造：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Ticket implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "进行售票: " + ticket--);
                } else {
                    break;
                }
            }
        }
    }
}

再次运行程序，可以看到控制台已经输出了正确的结果。

3.4 实例：同步的单例模式实现

只需将 getInstance 方法改为同步方法即可：

1
2
3
4
5
6
7
8
9
10

public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public synchronized static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

3.5 实现原理

我们通过一段代码来分析其实现原理：

1
2
3
4
5
6
7
8
9
10
11
12

public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        synchronized (Singleton.class) {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }
}

我们先使用javac编译器对其进行编译，随后使用javap -v命令对编译后的字节码文件进行反编译，结果如下：

注意到monitorenter和monitorexit就是进入和退出同步锁（监视器锁）的指令，这也是 synchronized 的实现原理。

3.6 性能

使用Java的内置锁虽然可以解决线程安全问题，但实际上这是一种很低效的方式，因为同一时刻只能有一个线程能持有锁并执行任务。因此千万不要滥用内置锁，这可能会带来非常严重的性能问题，同时尽量在可能出现线程安全问题的位置使用同步代码块，而不是简单的使用同步方法。
要判断同步代码块的合理大小，需要在各种设计需求之间进行权衡，包括安全性、简单性和性能。

通常，在简单与性能之间存在着相互制约因素。当实现某个同步策略时，一定不要盲目地为了性能而牺牲简单性（这可能会破坏安全性）

当使用锁时，要清楚代码块中实现的功能，以及在执行该代码块时是否需要很长的时间。无论是执行计算密集的操作，还是在执行某个可能阻塞的操作，如果持有锁的时间过长，那么都会带来活跃性或性能问题。
​

注：当执行时间较长的计算或者可能无法快速完成的操作时（例如网络I/O或控制台I/O），一定不要持有锁。

MySQL是目前最流行的开源的关系型数据库管理系统（RDBMS，Relational Database Management System）。

MySQL 由瑞典 MySQL AB 公司开发，目前属于 Oracle 公司。MySQL 是一种关联数据库管理系统，关联数据库将数据保存在不同的表中，而不是将所有数据放在一个大仓库内，这样就增加了速度并提高了灵活性。

• MySQL 是开源的，目前隶属于 Oracle 旗下产品。
• MySQL 支持大型的数据库。可以处理拥有上千万条记录的大型数据库。
• MySQL 使用标准的 SQL 数据语言形式。
• MySQL 可以运行于多个系统上，并且支持多种语言。这些编程语言包括 C、C++、Python、Java、Perl、PHP、Eiffel、Ruby 和 Tcl 等。
• MySQL 对PHP有很好的支持，PHP 是目前最流行的 Web 开发语言。
• MySQL 支持大型数据库，支持 5000 万条记录的数据仓库，32 位系统表文件最大可支持 4GB，64 位系统支持最大的表文件为8TB。
• MySQL 是可以定制的，采用了 GPL 协议，你可以修改源码来开发自己的 MySQL 系统。

MySQL的部分用户：

二、安装

所有平台的MySQL安装地址均为：https://dev.mysql.com/downloads/mysql/，根据个人需求选择 MySQL的平台和版本。下面将介绍在Linux、Windows平台的安装方法，若需获取所有平台的安装方法，请参阅：https://dev.mysql.com/doc/refman/8.0/en/installing.html。

2.1 Linux

接下来在 Centos7 系统下使用 yum 命令安装 MySQL。

2.1.1 下载 yum 包

首先需要去官网下载 yum 包，官网地址：https://dev.mysql.com/downloads/repo/yum/

1
2
3
4

wget https://repo.mysql.com//mysql80-community-release-el7-3.noarch.rpm
rpm -ivh mysql80-community-release-el7-3.noarch.rpm
yum update
yum install mysql-server

2.1.2 权限设置

1

chown -R mysql:mysql /var/lib/mysql

2.1.3 初始化MySQL

1

mysqld --initialize

2.1.4 启动MySQL

1

systemctl start mysqld

2.1.5 验证安装

在成功安装 MySQL 后，一些基础表会表初始化，在服务器启动后，你可以通过简单的测试来验证 MySQL 是否工作正常。我们可以使用 mysqladmin 命令来检查服务器的版本, 在 linux 上该二进制文件位于 /usr/bin 目录，在 Windows 上该二进制文件位于C:\mysql\bin 。

1

mysqladmin --version

若需获取更详细的内容，请参阅：https://dev.mysql.com/doc/refman/8.0/en/linux-installation.html

2.2 Windows

2.2.1 下载安装包

最新版的安装包地址：https://dev.mysql.com/downloads/mysql/，推荐下载ZIP格式的包。

下载完成后在自定义位置进行解压缩即可。

2.2.2 创建配置文件

打开刚才解压缩的文件夹，在根目录下创建my.ini配置文件，使用记事本打开并进行编辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

[client]
# 设置mysql客户端默认字符集
default-character-set=utf8
 
[mysqld]
# 设置3306端口
port = 3306
# 设置mysql的安装目录
basedir=C:\\path\\mysql-8.0.xx
# 设置 mysql数据库的数据的存放目录，MySQL 8+ 不需要以下配置，系统自己生成即可，否则有可能报错
# datadir=C:\\path\\xxxx
# 允许最大连接数
max_connections=20
# 服务端使用的字符集默认为8比特编码的latin1字符集
character-set-server=utf8
# 创建新表时将使用的默认存储引擎
default-storage-engine=INNODB

2.2.3 初始化数据库

以管理员身份打开CMD，切换目录至MySQL安装路径下的bin文件夹中，并执行以下命令：

1

mysqld --initialize --console

执行完成后，会输出 root 用户的初始默认密码，需将此密码记录下来，以便之后使用。

2.2.4 安装数据库

1

mysqld install

2.2.5 初始化Data目录(5.7版本之后)

1

mysqld --initialize-insecure

2.2.6 启动

1

net start mysql

三、使用

3.1 登录

当 MySQL 服务已经运行时，我们就可以通过 MySQL 自带的客户端工具登录到 MySQL 数据库中。首先打开命令提示符，输入以下命令：

1

mysql -h 主机名 -P 端口号 -u 用户名 -p

下面对其中的一些参数进行说明：

• -h : 指定客户端所要登录的 MySQL 主机名, 登录本机(localhost 或 127.0.0.1)该参数可以省略
• -P：指定 MySQL主机的端口号，一般默认为3306
• -u : 登录的用户名
• -p : 告诉服务器将会使用一个密码来登录, 如果所要登录的用户名密码为空, 可以忽略此选项

3.2 修改root密码

如果是首次登录，通常需要修改root密码。在之前安装MySQL时生成了一个初始的root账号密码，首先用这个密码登录，之后输入以下指令：

1

set password for root@localhost = password('新密码');

之后重新使用新密码登录即可。

3.3 可视化管理

如果直接用命令行来管理MySQL数据库会比较麻烦，因此可使用一些可视化的工具来管理MySQL数据库，下面推荐几款比较好用的工具。

3.3.1 Navicat

这是一款很多公司都在使用的数据库管理工具，功能非常强大，官网地址：https://www.navicat.com.cn/

不过该工具需要付费购买，而且价格也不便宜，不过有能力还是尽量支持正版。

3.3.2 SQLyog

这是Webyog公司的一款数据库管理工具，官方网址：https://webyog.com/

这是一款易于使用、快速而简洁的MySQL数据库图形化管理工具，可以直观的在任何地点高效地管理你的数据库。

1、基本介绍

Thread类位于java.lang包中，是Java中表示线程的一个类，实现了Runnable接口。Thread类中常用的方法如下：

若需获取Thread类更多的API，请参阅：java.lang.Thread。

2、创建线程

（1）继承Thread类

可以通过继承Thread类并重写其中的run()方法来创建一个自定义的线程，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("继承Thread类创建线程");
    }
}

public class ThreadDemo01 {
    public static void main(String[] args) {
        // 1.创建一个新线程
        Thread thread1 = new MyThread();
        // 2.开启线程
        thread1.start();
    }
}

如果自定义的子类只在创建线程时出现过一次，也可以使用匿名内部类来创建一个自定义的线程：

1
2
3
4
5
6
7
8
9
10
11
12
13

public class ThreadDemo01 {
    public static void main(String[] args) {
        // 1.创建一个新线程
        Thread t1 = new Thread() {
            @Override
            public void run() {
                System.out.println("使用匿名内部类来创建线程");
            }
        };
        // 2.开启线程
        t1.start();
    }
}

（2）实现Runnable接口

除了通过继承Thread类来创建线程，我们还可以通过实现Runnable接口来创建线程。通过这种方式创建线程的步骤如下：

• 定义一个实现类实现Runnable接口
• 在Thread类的构造方法中传入实现类

下面将演示如何创建线程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("实现Runnable接口");
    }
}

public class ThreadDemo01 {
    public static void main(String[] args) {
        // 1.创建Runnable接口的实现类对象
        Runnable runnable = new MyRunnable();
        // 2.将实现类对象传入Thread的构造方法中
        Thread thread2 = new Thread(runnable);
        // 3.开启线程
        thread2.start();
    }
}

如果该实现类只在创建线程时使用一次，可以使用匿名实现类来实现Runnable接口。在Java 8 及之后的版本支持 lambda 表达式，因此也可以用 lambda 表达式来代替匿名实现类（这里可以使用 lambda 表达式是因为该接口只有一个方法，即run()方法）

1
2
3
4
5
6
7
8

public class ThreadDemo01 {
    public static void main(String[] args) {
        // 1.创建一个新线程
        Thread t2 = new Thread(() -> System.out.println("实现Runnale接口"));
        // 2.开启线程
        t2.start();
    }
}

（3）实现Callable接口

与Runnable不同的是，Callable是有返回值的，返回值通过FutureTask进行封装。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        return 123;
    }
}

public class ThreadDemo01 {
    public static void main(String[] args) {
        // 1.创建Callable类的实现类对象
        MyCallable mc = new MyCallable();
        // 2.创建FutureTask对象并传入Callable类的实现类对象
        FutureTask<Integer> ft = new FutureTask<>(mc);
        // 3.创建Thread对象并传入FutureTask对象（FutureTask类实现了Runnable接口的子类接口）
        Thread thread3 = new Thread(ft);
        thread3.start();
    }
}

二、 Thread or Runnable

如果一个类继承Thread，则不适合资源共享（因为Java不支持多继承）。但是如果实现了Runable接口的话，则很容易的实现资源共享（因为Java支持实现多个接口）。

实现Runnable接口比继承Thread类所具有的优势：

• 适给多个相同的程序代码的线程去共享同一个资源。
• 可以避免Java中的单继承的局限性。
• 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
• 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

因此推荐使用实现Runnable接口的方式来创建线程。

三、Executor

1、简介

在Java 5之后，并发编程引入了一堆新的启动、调度和管理线程的API。Executor 框架便是 Java 5 中引入的，其内部使用了线程池机制，它在java.util.cocurrent 包下，通过该框架来控制线程的启动、执行和关闭，可以简化并发编程的操作。下面给出 Executor 框架的 UML 图：

在 Java 5 之后，通过 Executor 来启动线程比使用 Thread 的 start 方法更好，除了更易管理，效率更好（用线程池实现，节约开销）外，还有关键的一点：有助于避免 this 逃逸问题（ this 逃逸问题是指如果我们在构造器中启动一个线程，因为另一个任务可能会在构造器结束之前开始执行，此时可能会访问到初始化了一半的对象，这会引起一些意想不到的错误，因此要避免这种情况的发生）。

Eexecutor 作为灵活且强大的异步执行框架，其支持多种不同类型的任务执行策略，提供了一种标准的方法将任务的提交过程和执行过程解耦开发，基于生产者-消费者模式，其提交任务的线程相当于生产者，执行任务的线程相当于消费者，并用 Runnable 来表示任务，Executor 的实现还提供了对生命周期的支持，以及统计信息收集，应用程序管理机制和性能监视等机制。

2、Executor & ExecutorService

（1）Executor

Executor是一个接口，在该接口中含有一个execute方法，功能是执行一个任务，其源代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public interface Executor {

    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

因此，我们可以使用Executor并调用execute方法来隐式地创建一个线程。

（2）ExecutorService

ExecutorService继承于Executor，是一个比Executor更泛用的接口，该接口提供了生命周期管理的方法。下面列出ExecutorService中的部分方法：

若需获取更多ExecutorService接口的API，请参阅：java.util.concurrent.ExecutorService。

3、Executors

Executors是一个工具类，该类提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口。

下面介绍Executors中常用的工厂方法：

若需获取更多Executors类的API，请参阅：java.util.concurrent.Executors。

4、实例：使用ExecutorService创建线程

上面介绍了ExecutorService接口及Executors工具类，下面我们将演示如何使用ExecutorService来创建线程并执行线程任务：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 1.使用Executors工具类中的工厂方法创建线程池
ExecutorService executorService = Executors.newCachedThreadPool();
// 2.执行线程任务
// 2.1 执行线程任务A
executorService.execute(new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println("线程任务A");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
// 2.2 执行线程任务B
executorService.execute(new Runnable() {
    @Override
    public void run() {
        System.out.println("线程任务B");
    }
});
// 3.有序关闭其中执行以前提交的任务
executorService.shutdown();

5、ThreadPoolExecutor

（1）构造方法

上面我们介绍了如何使用Executors工具类中的工厂方法创建线程池，那么这些工厂方法具体是如何实现的呢，我们以newCachedThreadPool方法为例，来分析工厂方法是如何创建线程池的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

/**
 * Creates a thread pool that creates new threads as needed, but
 * will reuse previously constructed threads when they are
 * available.  These pools will typically improve the performance
 * of programs that execute many short-lived asynchronous tasks.
 * Calls to {@code execute} will reuse previously constructed
 * threads if available. If no existing thread is available, a new
 * thread will be created and added to the pool. Threads that have
 * not been used for sixty seconds are terminated and removed from
 * the cache. Thus, a pool that remains idle for long enough will
 * not consume any resources. Note that pools with similar
 * properties but different details (for example, timeout parameters)
 * may be created using {@link ThreadPoolExecutor} constructors.
 *
 * @return the newly created thread pool
 */
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

通过阅读源码，我们可以清楚地知道Executors工具类的工厂方法是通过具体情况创建一个ThreadPoolExecutor对象来创建线程池的。下面我们对ThreadPoolExecutor构造方法的参数进行简单介绍：

• 注1：TimeUnit是一个枚举类型。
• 注2：BlockingQueue是一个特殊的队列，当其为空时，获取元素线程被阻塞直到队列变为非空；当其为满时，添加元素线程被阻塞直到队列不满。详细内容请参阅：java.util.concurrent.BlockingQueue。

（2）实现execute方法

介绍完ThreadPoolExecutor类的构造方法的相关参数的含义，下面我们将说明ThreadPoolExecutor是如何实现execute方法的：

• 如果线程池中的线程数量少于corePoolSize，即使线程池中有空闲线程，也会创建一个新的线程来执行新添加的任务。
• 如果线程池中的线程数量大于等于corePoolSize，但缓冲队列workQueue未满，则将新添加的任务放到workQueue中，按照FIFO的原则依次等待执行（线程池中有线程空闲出来后依次将缓冲队列中的任务交付给空闲的线程执行）。
• 如果线程池中的线程数量大于等于corePoolSize，且缓冲队列workQueue已满，但线程池中的线程数量小于maximumPoolSize，则会创建新的线程来处理被添加的任务。
• 如果线程池中的线程数量等于了maximumPoolSize，可通过RejectedExecutionHandler来处理线程溢出问题，详细内容请参考源码，这里不再展开。

总结起来就是：当有新的任务要处理时，先看线程池中的线程数量是否大于corePoolSize，再看缓冲队列workQueue是否满，最后看线程池中的线程数量是否大于maximumPoolSize。

另外，当线程池中的线程数量大于corePoolSize时，如果里面有线程的空闲时间超过了keepAliveTime，就将其移除线程池，这样就可以动态地调整线程池中线程的数量。

（3）缓冲队列

在前面的内容中已经多次提到了缓冲队列，下面我们将详细介绍一下缓冲队列的内容。ThreadPoolExecutor类的构造方法中需要传入BlockingQueue<Runnable>类型的参数，BlockingQueue<E>是一个接口，它的实现类如下：

通过API文档，我们可以知道BlockingQueue<E>有很多的实现类，那么我们该选择哪个实现类来实现该接口呢？

缓冲队列一般有直接提交、无界队列和有界队列这几种排队策略，下面我们来介绍一下这些策略的特点和使用场景。知道了这些，我们就可以对上面的问题做出回答了。

（4）缓冲型线程池和固定型线程池的区别

前面我们简单介绍了Executors的几种工厂方法，在了解Executors工厂方法的实现细节之后，我们便可总结出缓冲型线程池和固定型线程池的区别。

• newCachedThreadPool()

缓存型线程池，先查看池中有没有以前建立的线程，如果有，就进行重用，如果没有，就建一个新的线程加入池中。

1
2
3
4
5

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

它将 corePoolSize 设定为 0，而将 maximumPoolSize 设定为了 Integer 的最大值，线程空闲超过60秒，将会从线程池中移除。由于核心线程数为 0，因此每次添加任务，都会先从线程池中找空闲线程，如果没有就会创建一个线程来执行新的任务，并将该线程加入到线程池中，而最大允许的线程数为 Integer 的最大值 ，因此这个线程池理论上可以不断扩大。

CachedThreadPool 通常用于执行一些生存期很短的异步型任务，因此在一些面向连接的 daemon 型服务中用得不多。但对于生存期短的异步任务，它是Executor的首选。

• newFixedThreadPool(int nThreads)

FixedThreadPool 与 CacheThreadPool 差不多，也可以进行复用，但不能随时建新的线程。任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子。

1
2
3
4
5

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

它将 corePoolSize 和 maximumPoolSize 都设定为了 nThreads，这样便实现了线程池的大小的固定，不会动态地扩大。另外，keepAliveTime 设定为了 0，意味着线程只要空闲下来，就会被移除线程池。

和CacheThreadPool不同，FixedThreadPool 没有IDLE机制（闲时机制），所以 FixedThreadPool 主要用于一些很稳定很固定的并发线程，多用于服务器。

四、Executor or Thread

如果项目使用的JDK版本为1.5及以上，推荐使用 Executor 框架来进行多线程应用开发。当然，如果只需开启线程去执行一些简单的任务，使用 Thread 也未曾不可。

插入排序是一种简单直观的排序方法，其基本思想是每次将一个待排序的记录按其关键字大小插入前面已排好序的子序列，直到全部记录插入完成。下面将介绍几种常见的插入排序算法。

1、直接插入排序

这是一种最简单的插入排序算法。假设当前索引为 i，在这之前的为有序序列，在这之后的为无序序列，我们要做的就是把当前索引为 i 的元素插入到前面的有序序列中，组成一个新的有序序列，之后将索引向后移动一位，重复上述操作，直到整个序列为有序序列。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 直接插入排序
void insert_sort(int* arr, int length)
{
    for(int i = 1; i < length; i++)
    {
        // 有序队列的末尾下标
        int insert_idx = i-1;
        // 待插入的数
        int insert_val = arr[i];
        // 寻找待插入的位置
        while(insert_idx >= 0 && arr[insert_idx] > insert_val)
        {
            arr[insert_idx+1] = arr[insert_idx];
            insert_idx--;
        }
        // 插入数据
        arr[insert_idx + 1] = insert_val;
    }
}

该算法的时间复杂度为$O(n^2)$，空间复杂度为$O(1)$。

2、折半插入排序

当排序表为顺序表时，可对直接插入排序算法做一些改进，在查找插入位置时使用二分查找，查找完成之后统一地向后移动元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

void insert_sort(int* arr, int n) {
    int i, j, low, high, mid;
    for (i = 2; i <= n; i++) {
        // 将arr[i]暂存到arr[0]中
        arr[0] = arr[i];
        // 二分查找
        low = 1; high = i-1;
        while (low <= high) {
            mid = (low + high) / 2;
            if (arr[mid] > arr[0]) high = mid - 1;
            else low = mid + 1;
        }
        // 统一移动元素
        for (j = i - 1; j >= high + 1; --j)
            arr[j+1] = arr[j];
        // 插入操作
        arr[high + 1] = arr[0];
    }
}

该算法的时间复杂度为$O(n^2)$，空间复杂度为$O(1)$。

3、希尔排序

希尔排序（Shell Sort），又称缩小增量排序，是对直接插入排序的一个改进。

交换式算法：

1
2
3
4
5
6
7
8

void shell_sort(int* arr, int length)
{
    for(int gap = length; gap > 0; gap /= 2) // 增量为 gap/2 向下取整
        for(int i = gap; i < length; i++)
            for(int j = i - gap; j >= 0; j -= gap)
                if(arr[j] > arr[j+gap])
                    swap(&arr[j], &arr[j+gap]); // 交换
}

如果采用这种写法，排序的效率甚至不如直接插入排序，原因是大量的时间消耗在交换上了。

移动式排序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

void shell_sort2(int* arr, int length)
{
    // 增量gap, 并逐步缩小增量
    for(int gap = length; gap > 0; gap /= 2)
    {
        // 从第gap个元素起，逐个对其所在的组进行直接插入排序
        for(int i = gap; i < length; i++)
        {
            int j = i;
            int tmp = arr[j];
            while(j-gap >= 0 && arr[j-gap] > tmp)
            {
                arr[j] = arr[j-gap];
                j -= gap;
            }
            arr[j] = tmp;
        }
    }
}

二、交换排序

1、冒泡排序

1
2
3
4
5
6
7
8
9
10
11
12
13

void bubble_sort(int* arr, int length)
{
    int i, j;
    int tmp; // 用于暂存变量
    for(i = 0; i < length - 1; i++)
        for(j = 0; j < length - 1 - i; j++)
            if (arr[j] > arr[j+1])
            {
                tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
}

该算法的时间复杂度为$O(n^2)$，空间复杂度为$O(1)$。

改进算法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

void bubble_sort2(int* arr, int length)
{
    int i, j;
    int tmp; // 用于暂存变量
    bool flag = false; // 标识变量，表示是否进行过交换
    for(i = 0; i < length - 1; i++)
    {
        for(j = 0; j < length - 1 - i; j++)
            if (arr[j] > arr[j+1])
            {
                flag = true;
                tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        if (!flag) // 在一趟排序中一次交换都没有发生过
            break;
    }
}

2、快速排序

详见《快速排序》。

三、选择排序

1、简单选择排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14

void select_sort(int* arr, int length)
{
    int i, j;
    int min_idx;
    for(i = 0; i < length - 1; i++)
    {
        min_idx = i;
        for(j = i + 1; j < length; j++)
            if (arr[j] < arr[min_idx])
                min_idx = j;
        // 用封装的swap()函数进行交换
        swap(&arr[i], &arr[min_idx]);
    }
}

该算法的时间复杂度为$O(n^2)$，空间复杂度为$O(1)$。

改进算法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

void select_sort2(int* arr, int length)
{
    int i, j;
    int min_idx;
    for(i = 0; i < length - 1; i++)
    {
        min_idx = i;
        for(j = i + 1; j < length; j++)
            if (arr[j] < arr[min_idx])
                min_idx = j;
        // 判断是否需要进行交换
        if (min_idx != i)
            swap(&arr[i], &arr[min_idx]);
    }
}

选择排序的时间要小于冒泡排序。

2、堆排序

详见《堆排序》。

四、归并排序

详见《归并排序》。

五、排序算法之间的比较

归并排序（Merge Sort） 是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法（Divide and Conquer） 的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

二、具体实现

1、divide

分（divide）的过程很简单，只需不断的从中间划分序列即可。代码实现如下：

1
2
3
4
5
6
7
8
9
10
11
12

public static void mergeSort(int[] arr, int low, int high, int[] temp) {
    if (low < high) {
        // 从中间划分两个子序列
        int mid = (low + high) / 2;
        // 对左侧子序列进行递归排序
        mergeSort(arr, low, mid, temp);
        // 对右侧子序列进行递归排序
        mergeSort(arr, mid + 1, high, temp);
        // 归并
        merge(arr, low, mid, high, temp);
    }
}

2、conquer

在治（conquer）的阶段需要将两个已经有序的子序列合并成一个有序序列。例如上图中的最后一次合并，要将${4,5,7,8}$和${1,2,3,6}$两个已经有序的子序列，合并为最终序列${1,2,3,4,5,6,7,8}$，下面将介绍具体的实现步骤：

代码实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public static void merge(int[] arr, int low, int mid, int high, int[] temp) {
    int i = low; // 初始化i，左边有序序列的初始索引
    int j = mid + 1; // 初始化j，右边有序序列的初始索引
    int t = 0; // 指向辅助数组的当前索引
    // 1.将左右两边的数据按规则添加到辅助数组中
    while (i <= mid && j <= high) {
        if (arr[i] < arr[j]) {
            temp[t++] = arr[i++];
        } else {
            temp[t++] = arr[j++];
        }
    }
    // 2.将有剩余数据的一边依次添加到辅助数组中
    // 注意: 下面的两个while循环最多只会执行其中一个
    while (i <= mid) {
        temp[t++] = arr[i++];
    }

    while (j <= high) {
        temp[t++] = arr[j++];
    }
    // 3.保存辅助数组的当前长度并将指针初始化
    int len = t;
    t = 0;
    // 4.将辅助数组中的数据复制到原数组中
    while (t < len) {
        arr[low + t] = temp[t];
        t++;
    }
}

完整的实现已上传Gitee，仓库地址：https://gitee.com/fzcoder/data-structure-and-algorithms-demo。

三、性能分析

1、时间效率

每趟归并的时间复杂度为$O(n)$，共需进行$\lceil log_2n \rceil$趟归并，所以算法的时间复杂度为$O(nlog_2n)$。

2、空间效率

归并操作中，辅助空间的为 n 个单元，因此算法的空间复杂度为$O(n)$。

3、稳定性

由于归并操作不会改变相同关键字记录的相对次序，所以归并排序算法是一种稳定的排序算法。

队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。而在优先队列（Priority Queue） 中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出 （first in, largest out）的行为特征。通常采用堆这种数据结构来实现。

通常，优先队列包括最大优先队列和最小优先队列。最大优先队列可以确保每次获取到整个队列中的最大元素并将其删除，而最小优先队列则确保每次获取到整个队列中的最小元素并将其删除。

二、具体实现

1、基本功能

我们可以创建一个PriorityQueue<E>类来表示优先队列，下面将分别介绍一下该类的成员变量和公共方法：

• 成员变量

  成员名	类型	说明
  queue	Object[]	用于存放队列中的元素
  size	int	当前队列中元素的个数
  comparator	Comparator<? super E>	比较器，用于支持自定义比较

• 公共方法

  方法名及参数	返回值类型	说明
  isEmpty()	boolean	判断队列是否为空
  size()	int	获取队列中的元素个数
  offer(E e)	boolean	向队列中插入一个元素
  poll()	E	获取队首元素并将其从队列中移除
  peek()	E	获取队首元素但保留该元素

该部分的代码实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

public class PriorityQueue<E> {

    // 使用一个数组存放数据
    private Object[] queue;

    // 当前存放的元素数量
    private int size;

    // 比较器，用于支持自定义比较
    private Comparator<? super E> comparator;

    // 构造方法（默认比较器）
    public PriorityQueue(int capacity) {
        this(capacity, null);
    }

    // 构造方法（自定义比较器）
    public PriorityQueue(int capacity, Comparator<? super E> comparator) {
        if (capacity < 1) throw new IllegalArgumentException();
        this.queue = new Object[capacity];
        this.comparator = comparator;
    }
    
    // 判断队列是否为空
    public boolean isEmpty() {
        return size == 0;
    }

    // 获取队列中的元素个数
    public int size() {
        return size;
    }

    // 添加元素
    public boolean offer(E e) {
        int i = size;
        // 当队列满时返回false
        if (i == queue.length) return false;
        size = i + 1;
        if (i == 0)
            queue[0] = e;
        else
            shiftUp(i, e);
        return true;
    }

    // 获取队首元素并将其从队列中移除
    public E poll() {
        // 当队列为空时返回null
        if (size == 0) return null;
        int s = --size;
        E result = (E) queue[0];
        E x = (E) queue[s];
        queue[s] = null;
        if (s != 0) shiftDown(0, x);
        return result;
    }

    // 获取队首元素但保留该元素
    public E peek() {
        return size == 0 ? null : (E) queue[0];
    }
    
    // ...
}

在上面的代码中使用了shiftUp和shiftDown方法，它们分别表示上移和下移，下面将重点介绍这两个方法是如何实现的。

2、上移

如果在普通的队列中插入一个元素是非常容易的，只需将其插入队尾即可。但在优先队列中，除了将其插入队列中，还要确保插入元素后整个队列仍然保持优先队列的性质。这时，我们就需要通过上移操作来实现优先队列的插入操作。下面将通过实例来介绍上移操作的具体过程。

假设有一个优先队列${3,4,5,6,8}$，现在需要插入结点2。首先将新插入的结点放在队列的末尾，如下图所示：

之后将新插入的结点与其父结点进行比较。该例中新插入的结点所在位置的索引为 5，因此其父结点的索引为$(5-1)/2 = 2$，在索引为 2 的结点值为 5，由于该队列是最小优先队列，因此需要将新插入的结点与其父结点进行交换。

继续判断是否满足优先队列的条件。此时新插入结点的索引为 2，因此其父结点的索引为$(2-1)/2=0$，此处的值为 3，仍不满足条件，再次进行交换。

此时满足优先队列的条件，完成插入。

上移操作的代码实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

private void shiftUp(int k , E e) {
    if (comparator != null) {
        while (k > 0) {
            // 获取待插入位置的父结点索引
            int parent = (k-1) >>> 1;
            // 获取父结点的值
            Object elem = queue[parent];
            // 判断当前结点与其父结点的大小关系
            // 这里采用的是最小优先队列，因此当此结点大于其父结点时跳出循环
            if (comparator.compare(e, (E) elem) >= 0)
                break;
            queue[k] = elem;
            k = parent;
        }
        queue[k] = e;
    } else {
        Comparable<? super E> key =  (Comparable<? super E>) e;
        while (k > 0) {
            // 获取待插入位置的父结点索引
            int parent = (k-1) >>> 1;
            // 获取父结点的值
            Object elem = queue[parent];
            // 判断当前结点与其父结点的大小关系
            // 这里采用的是最小优先队列，因此当此结点大于其父结点时跳出循环
            if (key.compareTo((E) elem) >= 0)
                break;
            queue[k] = elem;
            k = parent;
        }
        queue[k] = e;
    }
}

3、下移

当删除优先队列中的元素时，首先返回队首元素，之后将队尾元素放在队首，并删除队尾。之后通过下移操作调整队列，使其满足条件。下面将通过实例来说明下移操作的完整过程。

接着上面的例子，假设需要删除 2，首先将队首元素 2 保存起来作为结果返回，并将队尾元素 5 放在队首，并删除队尾元素。

之后对队首结点的两个孩子进行比较（若右孩子存在），选择优先级最小的结点（这里是结点 3）与队首结点进行比较，因为队首元素的优先级大于结点 3，因此将这两个结点进行交换。

由于此时原队首元素已经是叶子结点，因此下移操作结束，整个删除操作完成。

下移操作的代码实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

private void shiftDown(int k, E e) {
    if (comparator != null) {
        int half = size >>> 1;
        // 当为非叶子结点时进行循环
        while (k < half) {
            // 获取当前结点的左孩子
            int child = (k << 1) + 1;
            Object c = queue[child];
            // 当前结点的右孩子的索引（若存在）
            int right = child + 1;
            // 比较当前结点左孩子和右孩子（若存在）的优先级
            // 若右孩子的优先级小，则将待比较的结点改为右孩子
            if (right < size && comparator.compare((E) c, (E) queue[right]) > 0)
                c = queue[child = right];
            // 将当前结点与其左（或右）孩子进行比较
            // 若当前结点的优先级小于被比较的结点，则跳出循环
            if (comparator.compare(e, (E) c) <= 0)
                break;
            queue[k] = c;
            k = child;
        }
        queue[k] = e;
    } else {
        Comparable<? super E> key = (Comparable<? super E>)e;
        int half = size >>> 1;
        // 当为非叶子结点时进行循环
        while (k < half) {
            // 获取当前结点的左孩子
            int child = (k << 1) + 1;
            Object c = queue[child];
            // 当前结点的右孩子的索引（若存在）
            int right = child + 1;
            // 比较当前结点左孩子和右孩子（若存在）的优先级
            // 若右孩子的优先级小，则将待比较的结点改为右孩子
            if (right < size && ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
                c = queue[child = right];
            // 将当前结点与其左（或右）孩子进行比较
            // 若当前结点的优先级小于被比较的结点，则跳出循环
            if (key.compareTo((E) c) <= 0)
                break;
            queue[k] = c;
            k = child;
        }
        queue[k] = key;
    }
}

优先队列的完整实现已上传到 Gitee，仓库地址：https://gitee.com/fzcoder/data-structure-and-algorithms-demo。

三、总结

优先队列与普通的队列相似，但可以确保每次出队的元素是当前队列中的最大（或最小）元素，可使用于需要获取最大的 K 个元素等情况。

1、堆

堆（heap） 是一个数组，它可以被看成一个近似的完全二叉树。树上的每一个结点对应数组中的一个元素，除最底层外，该树是完全充满的，而且是从左向右填充的。

二叉堆可以分为两种形式：最大堆和最小堆。在这两种堆中，结点的值都要满足堆的性质，但一些细节定义则有所差异。在最大堆中，最大堆性质是指除了根以外的所有结点都要满足$parent.val \ge node.val$，也就是父结点大于等于子结点；而最小堆正好相反，即除了根以外的所有结点都要满足$parent.val \le node.val$，也就是父结点小于等于子结点。

2、堆排序

堆排序（heap sort），顾名思义，就是一种通过堆实现排序的算法，在堆排序中使用的是最大堆。堆排序的基本思想如下：

• 将待排序的序列构造成一个最大堆，此时整个序列的最大值就是堆顶的根节点。
• 将其与末尾元素进行交换，此时末尾就为最大值。
• 然后将剩余$n-1$个元素重新构造成一个最大堆， 这样会得到剩余$n-1$个元素的最大值。
• 如此反复执行，便能得到一个有序的序列。

接下来我们将介绍堆排序的具体实现。

二、具体实现

1、建堆

首先我们需要做的就是将无需的序列建立一个初始堆（升序采用最大堆，降序采用最小堆），下面将结合实例来分析建堆的过程。

假设存在一个无序序列，该序列的二叉树形式和数组形式如下：

(1) 首先我们从最后一个非叶子结点开始（叶结点不需要调整，第一个非叶子结点$arr.length/2-1=5/2-1=1$,也就是结点6），从左至右，从下至上进行调整。

(2) 接下来找到第二个非叶子结点 4，由于在${4,9,8}$中结点 9 最大，因此将结点 4 和结点 9 交换。

(3) 然而上面的交换导致了子树中${4, 5,6}$不满足最大堆的要求，因此继续调整，在${4, 5,6}$中结点 6 最大，所以交换结点 4 和结点 6。此时，我们就将一个无序序列构造成了一个最大堆。

2、调整堆

在建好一个初始堆之后，需要将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行，直至将序列变成一个有序序列。下面将接着上面的例子来分析具体的过程。

(1) 首先，将堆顶元素 9 和末尾元素 4 进行交换。

(2) 重新调整结构，使其继续满足堆定义。

(3) 再将堆顶元素 8 与末元素 5 进行交换，得到第二大元素 8。

(4) 继续进行调整，如此反复进行，最终使得整个序列有序。

3、代码实现

堆排序采用Java语言的完整实现已上传Gitee，项目地址：https://gitee.com/fzcoder/data-structure-and-algorithms-demo，下面给出部分算法的实现。

(1) 堆排序算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public static void heapSort(int[] arr) {
    // 建堆
    for (int i = arr.length / 2 - 1; i >= 0; i--) {
        adjustHeap(arr, i, arr.length);
    }

    // 反复进行调整
    for (int j = arr.length - 1; j > 0; j--) {
        int temp = arr[j];
        arr[j] = arr[0];
        arr[0] = temp;
        adjustHeap(arr, 0, j);
    }
}

(2) 对以下标为 index 的根结点的子树进行调整

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public static void adjustHeap(int[] arr, int index, int length) {
    int temp = arr[index]; // 暂存树的根结点
    for(int k = 2 * index + 1; k < length; k = k * 2 + 1) {
        if (k + 1 < length && arr[k] < arr[k+1]) {
            k++; // 取值较大的子结点的下标
        }
        if (arr[k] > temp) {
            arr[index] = arr[k]; // 将较大的子结点调整到双亲结点上
            index = k; // 修改 index 值，以便继续向下筛选
        } else {
            break;
        }
    }
    arr[index] = temp; // 被筛选结点的值放入最终位置
}

三、性能分析

1、时间效率

建堆时间为$O(n)$，之后有$n-1$次向下调整操作，每次调整的时间复杂度为$O(h)$。因此在最好、最坏和平均情况下，堆排序的时间复杂度为$O(nlog_2n)$。

2、空间效率

仅使用了常数个辅助单元，所以空间复杂度为$O(1)$。

3、稳定性

进行筛选时，有可能把后面相同关键字的元素调整到前面，所以堆排序算法是一种不稳定的排序方法。

快速排序（Quick Sort） 的基本思想是基于分治法的，该算法通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

二、具体实现

由上图可知，在每一趟快速排序中，都需要选择一个元素将待排序表划分为两部分，这个用来划分待排序表的元素叫做主元（pivot element），或者叫做基准。一趟快速排序的过程是一个交替搜索和交换的过程，下面通过实例来进行介绍。

1、操作过程

假设有一个待排序的数组$= {49, 38, 65, 97, 76, 13, 27}$，我们选择数组的首个元素 49 作为主元，下面是一趟快速排序的过程：

• 指针 high 向前搜索，找到第一个小于主元49的元素27，并将其交换到 low 所指位置

• 指针 low 向后搜索，找到第一个大于主元49的元素65，并将其交换到 high 所指位置

• 指针 high 继续向前搜索找到第一个小于主元49的元素13，并将其交换到 low 所指位置

• 指针 low 向后搜索，找到第一个大于主元49的元素97，并将其交换到 high 所指位置

• 指针 high 继续向前搜索，直至$low = high$，之后将主元插入到 low 位置即可

2、代码实现

由上文可知，在每趟快速排序时需要一个划分算法对待排序的列表进行划分操作，之后对每块划分的区域再进行快速排序，因此可采用递归来实现快速排序算法，代码如下：

1
2
3
4
5
6
7
8
9
10

public static void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        // 将数组进行划分
        int pivot_pos = partition(arr, low, high);
        // 递归排序左子表
        quickSort(arr, low, pivot_pos - 1);
        // 递归排序右子表
        quickSort(arr, pivot_pos + 1, high);
    }
}

其中划分算法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public static int partition(int[] arr, int low, int high) {
    // 将当前表中的第一个元素设为主元，对表进行划分
    int pivot = arr[low];
    // 当low指针小于high指针时进行划分
    while(low < high) {
        // 比较所指元素与主元元素的大小关系, 并将high指针向左移动
        while (low < high && arr[high] >= pivot) --high;
        // 将比主元小的元素移动到左端
        arr[low] = arr[high];
        // 比较所指元素与主元元素的大小关系, 并将low指针向右移动
        while (low < high && arr[low] <= pivot) ++low;
        // 将比主元大的元素移动到右端
        arr[high] = arr[low];
    }
    // 主元元素存放到最终位置
    arr[low] = pivot;
    // 返回存放主元的最终位置
    return low;
}

三、性能分析

1、时间效率

快速排序的运行时间与划分是否对称有关。快速排序的最坏情况发生在两个区域分别包含 $n-1$ 和 0 个元素时，若每层递归都会出现这种情况，则时间复杂度为$O(n^2)$；若划分的比较平衡，此时的时间复杂度为$O(nlog_2n)$。快速排序在一般情况下与其最佳情况下的运行时间很接近。快速排序是所有内部排序算法中平均性能最优的排序算法。

2、空间效率

最好情况下为$O(log_2n)$，最坏情况下为$O(n)$ ，平均情况下为$O(log_2n)$ 。

3、稳定性

在划分算法中，若右端区域有两个关键字相同，且小于基准值的记录，则在交换到左端区间后，它们的相对位置会发生变化，即快速排序是一种不稳定的排序方法。

1、顺序查找

顺序查找（Sequential Search）又称线性查找，它对顺序表和链表都是适用的。对于顺序表，可通过数组下标递增来顺序扫描每个元素；对于链表，可通过指针域来依次扫描每个元素。

• 查找表的数据结构如下：

1
2
3
4
5

typedef struct
{
    ElemType *elem; // 元素空间的基地址
    int length; // 表的长度
}SSTable;

• 顺序查找的算法如下：

1
2
3
4
5
6
7

int seq_search(SSTable st, ElemType key)
{
    int i;
    st.elem[0] = key; // 哨兵
    for(i = st.length; st.elem[i] != key; --i); // 从后向前找
    return i; // 若表中不存在关键字为key的元素，将查找到i为0时退出for循环
}

在上述算法中使用了一个“哨兵”，即st.elem[0]，目的是使得算法内的循环不必判断数组是否会越界。引入“哨兵”可以避免很多不必要的判断语句，从而提高程序的效率。

顺序查找的平均查找长度（Average Search Length, ASL）为：
$$
ASL = \frac{1}{n} \sum_{i=1}^{n}i = \frac{n+1}{2}
$$
时间复杂度为：
$$
T(n) = O(n)
$$
下面来说明顺序查找的优点和缺点：

• 优点：算法简单，对表结构无任何要求，既适用于顺序结构，也适用于链式结构，无论记录是否按关键字有序均可应用。

• 缺点：平均查找长度较大，查找效率较低，所以当 n 很大时，不宜采用顺序查找。

2、折半查找

详见《二分查找》

3、分块查找

分块查找（Blocking Search）又称索引顺序查找，这是一种性能介于顺序查找和折半查找之间的一种查找方法。在此查找法中，除表本身以外，尚需建立一个“索引表”，如下图所示。

分块查找的基本思想：将查找表分为若干块。块内的元素可以无序，但块之间是有序的，即第一个块中的最大关键字小于第二个块中的所有记录的关键字，第二个块中的最大关键字小于第三个块中的所有记录的关键字，以此类推。再建一个索引表，索引表中的每个元素含有各块的最大关键字和各块中的第一个元素的地址，索引表按关键字有序排列。

分块查找的过程分为两步：第一步是在索引表中确定待查记录所在的块，可以顺序查找或折半查找索引表；第二步是在表内顺序查找。由此可见，分块查找的算法顺序为顺序查找和折半查找两种算法的简单合成。

分块查找的平均查找长度为：
$$
ASL_{bs} = L_b + L_w
$$
其中，$L_b$为查找索引表确定所在块的平均查找长度，$L_w$为在块中查找元素的平均查找长度。

若用顺序查找确定所在块，则分块查找的平均长度为：
$$
ASL_{bs} = L_b + L_w = \frac{1}{b}\sum_{j=1}^{b}j+\frac{1}{s}\sum_{i=1}^{s}i = \frac{b+1}{2}+\frac{s+1}{2} = \frac{1}{2}(\frac{n}{s}+s)+1
$$
可见，此时的平均查找长度不仅和表长 n 有关，而且和每一块中的记录个数 s 有关。

若用折半查找确定所在块，则分块查找的平均查找长度为：
$$
ASL_{bs} \approx log_2(\frac{n}{s}+1)+\frac{s}{2}
$$
下面来说明分块查找的优点和缺点：

• 优点：在表中插人和删除数据元素时，只要找到该元素对应的块，就可以在该块内进行插人和删除运算。由于块内是无序的，故插人和删除比较容易，无需进行大量移动。如果线性表既要快速查找又经常动态变化，则可采用分块查找。

• 缺点：要增加一个索引表的存储空间并对初始索引表进行排序运算。

二、树表的查找

1、二叉排序树

详见《二叉排序树》

2、平衡二叉树

详见《平衡二叉树》

3、B树与B+树

详见《B树与B+树》

三、散列表

详见《散列表》

散列表（Hash Table） 也叫哈希表，是根据关键码值（Key Value）而直接进行访问的数据结构。它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度，这个映射函数叫做散列函数。散列表建立了关键字和存储地址之间的一种直接映射关系。

当关键字全域 U 较小时，我们可以使用一个称为直接寻址表（direct-address table）的数组表示一个取自关键字全域的动态集合，其中每个位置称之为槽（slot），对应全域 U 中的一个关键字，槽 k 指向集合中一个关键字为 k 的元素。

但当关键字全域 U 比较大时，这样做显然是不合适的，因为这样的话直接寻址表的空间开销会很大，而且很大概率会浪费很多空间（取决于实际关键字的数量，如果数量相对于关键字全域很少，那么就会造成大量空间的浪费）。

因此，我们需要用散列函数根据关键字来计算出槽的位置。这样，散列函数 h 就将关键字的全域 U 映射到散列表$T[0..m-1]$的槽位上。散列表的大小 m 一般比关键字全域 U 小得多，这样就解决了当使用直接寻址表时造成的大量空间浪费的问题。但是这样做又会出现一个新的问题，假如不同的关键字的散列函数值相同，即不同的关键字被映射到同一个槽中，那么又该怎么办呢？我们称这种情形为冲突（collision），在下文中会介绍几种处理冲突的方法。

二、构造散列函数

上文中提到散列函数通过把关键码值映射到表中一个位置来访问记录，那么该如何构造散列函数呢？下面介绍几种常见的构造方法。

1、直接定址法

直接取关键字的某个线性函数值为散列函数，散列函数为：
$$
h(key) = a \times key + b
$$
式中 a 和 b 为常数。这种方法计算最简单，且不会产生冲突。它适合关键字分布基本连续的情况，若关键字分布不连续，空位较多，则会造成存储空间的浪费。

2、除留余数法

假定散列表表长为 m，取一个不大于 m 但最接近或等于 m 的质数 p，利用模运算将关键字转换为散列地址，散列函数如下：
$$
h(key) = key % p
$$
该方法的关键是选择一个好的 p，使得每个关键字通过该函数转换后等概率地映射到散列空间上的任一地址，尽可能减少冲突的可能性。

3、乘法散列法

该方法分为两个步骤。第一步，用关键字 key 乘上常数$A(0 < A < 1)$，并提取$key \times A$的小数部分。第二步，用 m 乘以这个值。散列函数如下：
$$
h(key) = \lfloor m \times (key \times A - \lfloor key \times A \rfloor) \rfloor
$$
乘法散列法的一个优点就是对 m 的选择不是特别关键，一般令$m = 2^p$（p 为某个整数）。常数 A 建议选择为$(\sqrt5 - 1) / 2$。

三、处理冲突

1、链接法

在链接法（chaining）中，把散列到同一槽中的所有元素都放在一个链表中，如下图所示。槽 j 中有一个指针，它指向存储所有散列到 j 的元素的链表的表头；如果不存在这样的元素，则槽 j中为空指针。

存放元素的链表可以是单链表，也可以是双向链表。图中链表画为双链，因为这样删除操作比较快。链接法适用于经常进行插入和删除的情况。

2、开放寻址法

在开放寻址法（open addressing）中，所有的元素都存放在散列表里。也就是说，每个表项或包含动态集合的一个元素，或包含空指针。当查找某个元素时，要系统地检查所有的表项，直到找到所需的元素，或者最终查明该元素不在表中。不像链接法，这里既没有链表，也没有元素存放在散列表外。因此在开放寻址法中，散列表可能会被填满，以至于不能插入任何新的元素。

开放寻址法的数学递推公式为：
$$
h_i = (h(key)+d_i) % m
$$
其中，$h(key)$为散列函数，$i \in [1, m-1]$且为整数，m 为散列表表长，$d_i$为增量序列。

接下来就要确定增量序列的取法，通常有以下三种取法：

（1）线性探查

当$d_i = 0, 1, 2, …, m-1$时，称之为线性探查（linear probing）。该方法的思想是：冲突发生时，顺序查看表中下一个单元（探测到表尾时下一个探测地址是表首地址），直到找出一个空闲单元。

线性探查方法比较容易实现，但它存在着一个问题，称为一次群集（primary clustering）。 随着连续被占用的槽不断增加，平均查找时间也随之不断增加。群集现象很容易出现，这是因为当一个空槽前有 i 个满的槽时，该空槽为下一个将被占用的概率是$(i+ 1)/m$。连续被占用的槽就会变得越来越长，因而平均查找时间也会越来越大。

（2）二次探查

当$d_i = 0^2, 1^2, -1^2, 2^2, -2^2, …, k^2, -k^2$，其中$k\le m/2$且 m 为可表示成$4k+3$的素数时，称为二次探查（quadratic probing）。

这是一种处理冲突的较好方法，但会导致一种轻度的群集，称为二次群集（secondary clustering），此外这种方法不能探测到散列表上的所有单元。

（3）双重散列

双重散列（double hashing）是用于开放寻址法的最好方法之一，因为它所产生的排列具有随机选择排列的许多特性。双重散列采用如下形式的散列函数：
$$
h(k, i) = (h_1(k) + ih_2(k)) % m
$$
其中$h_1$和$h_2$均为辅助散列函数，i 为冲突的次数，初始值为 0。初始探查位置为$T[h_1(k)]$，后续的探查位置是前一个位置加上偏移量$h_2(k)$模 m。因此，不像线性探查或二次探查，这里的探查序列以两种不同方式依赖于关键字k，因为初始探查位置、偏移量或者二者都可能发生变化。

四、性能分析

在分析散列表的性能之前，先来简单介绍一下装载因子的概念。装载因子记为$\alpha$，表示一个表的装满程度，即：
$$
\alpha = \frac{n}{m}
$$
其中 n 为表中记录数，m 为散列表的长度。

散列表的查找效率取决于三个因素：散列函数、处理冲突的方法和装填因子。散列表的平均查找长度依赖于装填因子，而不直接依赖于表中记录数和散列表的长度。装填因子越大，表示装填的记录越满，发生冲突的可能性就更大，反之发生冲突的可能性越小。

折半查找又称二分查找（Binary Search），它仅适用于有序的顺序表。

折半查找的基本思想是：首先将给定的关键字与表中中间位置的元素比较，若相等，则查找成功，返回该元素的存储位置；若不等，则所需查找的元素只能在中间元素以外的前半部分或后半部分。然后在缩小的范围内继续进行同样的查找，如此重复，直到找到为止，或确定表中没有所需要查找的元素，则查找不成功，返回查找失败的信息。

二、算法实现

二分查找的Java语言实现如下，完整的实现已上传至Gitee，仓库地址：https://gitee.com/fzcoder/data-structure-and-algorithms-demo。

1
2
3
4
5
6
7
8
9
10

public static int binarySearch(int[] arr, int key) {
    int low = 0, high = arr.length - 1;
    while (low <= high) {
        int mid = (low + high) / 2; // 取中间位置
        if (arr[mid] == key) return mid; // 查找成功则返回所在位置下标
        else if (arr[mid] > key) high = mid - 1; // 从前面部分继续查找
        else low = mid + 1; // 从后面部分继续查找
    }
    return -1; // 查找失败，返回-1
}

注：该算法循环执行的条件是low <= high，而不是low < high，因为low=high时，查找区间还有最后一个结点，还要进一步比较。

下面通过一个例子来说明折半查找算法的执行过程。

假设有一个有序表为：{ 5，16，20，27，30，36，44，55，60，67，71 }，现在要查找值为 27 的数据元素的位置，过程如下：

• 首先 mid = (1 + 11) / 2 = 6，elem[mid]的值为 36，36 > 27，因此high = mid - 1，即 high = 5。
• 之后 mid = (1 + 5) / 2 = 3，elem[mid]的值为 20，20 < 27，因此low = mid + 1，即 low = 4。
• 最后 mid = (4 + 5) / 2 = 4，elem[mid]的值为 27，27 = 27，因此已经找到位置，返回 4。

三、算法分析

上述查找过程的判定树为：

由此可见，折半查找法在查找成功时进行比较的关键字个数最多不超过判定树的深度。而判定树的形态只与表记录个数 n 相关，而与关键字的取值无关。因此，对于长度为 n 的有序表，折半查找法在查找成功时和给定值进行比较的关键字个数至多为：
$$
\lfloor log_2n \rfloor + 1
$$

现在假设如下：

$$
有序表的长度为n = 2^h - 1, 判定树的深度为 h = log_2(n+1)的满二叉树。假设表中每个记录的查找概率相等，均为P_i = \frac{1}{n}
$$

则查找成功时折半查找的平均查找长度为：
$$
ASL = \sum_{i=1}^{n} P_iC_i = \frac{1}{n}\sum_{j=1}^{h}j \cdot 2^{j-1} = \frac{n+1}{n}log_2(n+1)-1
$$
当 n 较大时，可有如下近似结果：
$$
ASL = log_2(n+1)-1
$$
因此，折半查找的时间复杂度为：
$$
T(n)=O(log_2n)
$$
下面来说明折半查找的优点和缺点：

• 优点：比较次数少，查找效率高。

• 缺点：对表结构要求高，只能用于顺序存储的有序表。查找前需要排序，而排序本身是一种费时的运算。同时为了保持顺序表的有序性，对有序表进行插人和删除时，平均比较和移动表中一半元素，这也是一种费时的运算。因此，折半查找不适用于数据元素经常变动的线性表。

1、基本概念

B 树是为磁盘或其他直接存取的辅助存储设备而设计的一种平衡搜索树。B 树类似于红黑树，但它们在降低磁盘I/O操作数方面要更好一些。许多数据库系统使用 B 树或者 B 树的变种（如 B+树）来存储信息。

B 树中所有结点的孩子个数的最大值称为 B 树的阶，通常用 m 表示，一棵 m 阶 B 树或为空树，或是具有以下性质的 m 叉树：

• 在每个结点中含有n个关键字$key_1, key_2, …, key_n$，以非降序存放，使得$key_1\le key_2\le …\le key_n$。
• 关键字$key_i$对存储在各子树中的关键字范围加以分割，如果$k_i$为任意一个存储在以当前结点为根结点的子树中的关键字，则有：$k_1\le key_1\le k_2\le key_2\le …\le k_n\le key_n\le k_{n+1}$。
• 每个叶子结点具有相同的深度。
• 每个结点所包含的关键字个数有上界和下界。除了根结点以外的所有非叶子结点至少有$\lceil m/2 \rceil - 1$个关键字，至多有$m-1$个关键字。

由上述性质的第四点可知，除了根结点以外的每个内部结点至少有$\lceil m/2 \rceil $个孩子，如果树非空，根结点至少有一个关键字。一个内部结点至多可有 m 个孩子。

2、B树的高度

B 树上大部分的操作所需的磁盘存取次数与 B 树的高度是成正比的。如果$n \ge 1$，那么对任意一棵包含 n 个关键字、高度为 h、阶数为 m 的 B 树 T，有：
$$
log_m(n+1) \le h \le log_{\lceil m/2 \rceil}((n+1)/2) + 1
$$

3、查找操作

在 B 树上进行查找与二叉搜索树类似，只是每个结点都是多个关键字的有序表，在每个结点上所做的不是两路分支决定，而是根据该结点的子树所做的多路分支决定。

B 树上的查找包含以下两个基本操作：

• 在B树中查找结点。此操作是在磁盘上进行的，当查找到目标结点后，就把该结点的信息加载进内存。
• 在结点内查找关键字。此操作是在内存中进行的，对结点内的关键字列表进行二分查找或顺序查找。

下面通过一个例子来说明 B 树的查找操作。假设需要在上图中的B树上查找是否存在关键字42，查找的具体步骤如下：

注：当查找到叶子结点（对应指针为空指针），则说明树中没有对应的关键字，查找失败。

4、插入操作

下面通过一个具体的实例来总结B树插入操作的方法。（设该B树的阶数 m = 5 ）

• 首先在空树中插入39。

• 继续插入22、97和41。由于结点中的关键字个数没有到达其最大值，因此可以直接插入。另外，B树中每个结点的关键字都是升序排列的，因此将22插在39的前面，将41和97插在39的后面。

• 继续插入53。注意，由于该B树的阶为5，因此每个结点最多只能有$5-1=4$个关键字，此时该结点已经有4个关键字了（一般称这种结点为满的（full）结点），因此要对该结点进行分裂（split）操作。该操作将一个满的结点按其中间关键字（median key）（位于$\lceil m/2 \rceil $处）分为两部分，左部分放在原结点处，右部分放在新结点处，中间位置的结点插入原结点的父结点（如果没有父结点就创建一个新结点）。但是如果父结点也是满的，就必须在插人新的关键字之前将其分裂，最终满结点的分裂会沿着树向上传播。

5、删除操作

B 树中的删除操作与插入操作类似，但要稍微复杂一些，即要使得删除后的结点中的关键字个数$\ge \lceil m/2 \rceil - 1$，因此将涉及结点的合并问题。下面通过具体的实例来总结B树的删除操作。

（1）当被删除的关键字 k 不在终端结点（最低层非叶子结点）中时，可以**用 k 的前驱（或后继）k’ 来替代 k，然后在相应的结点中删除 k’**。

在上图中，首先删除关键字80（用其前驱78替代），然后在终端结点中删除78，因此只需讨论删除终端结点中关键字的情形。

（2）当被删除的关键字在终端结点中时，分下列三种情况讨论：

• 若被删除关键字所在的结点关键字个数$\ge \lceil m/2 \rceil $，表明删除该关键字后仍满足B树的定义，则可直接删除该关键字。

• 若被删除关键字所在结点删除前的关键字个数$= \lceil m/2 \rceil - 1$,且与此结点相邻的右（或左）兄弟结点的关键字个数$\ge \lceil m/2 \rceil $，则需要调整该结点、右（或左）兄弟结点及其双亲结点，以达到新的平衡。

  

  如上图所示，当删除关键字65时，其右兄弟关键字个数$\ge \lceil m/2 \rceil $，因此将65的父结点71替换65，再用右兄弟结点中的关键字74替换父结点，最后直接删除右兄弟中的结点74。

• 若被删除关键字所在结点删除前的关键字个数$= \lceil m/2 \rceil - 1$,且与此结点相邻的左、右兄弟结点的关键字个数均$= \lceil m/2 \rceil - 1$，则将关键字删除后与左（或右）兄弟结点及双亲结点中的关键字进行合并。

  

  由上图所示，当删除结点5时，其右兄弟结点的关键字个数均$= \lceil m/2 \rceil - 1$，因此先删除5，然后将60合并到65结点中。

注：在合并过程中，双亲结点中的关键字个数会减1。若其双亲结点是根结点且关键字个数至0，则直接删除根结点，合并后的新结点为根。若其双亲结点不是根结点，且关键字个数减少到$\lceil m/2 \rceil - 2$，则又要与它自己的兄弟结点进行调整或合并，直到符合 B 树的要求为止。

二、B+树

1、基本概念

B+树是应数据库所需而出现的一种B树的变形树，它与B树的差异在于：

• 非叶结点仅具有索引作用，也就是说，非叶子结点只存储key，不存储value 。
• 树的所有叶结点构成一个有序链表，可以按照key排序的次序遍历全部数据。

一颗典型的B+树如下图所示：

2、相关操作

B+树的查找、插入和删除操作和 B 树的基本类似。只是在查找的过程中，非叶结点上的关键字值等于给定值时并不终止，而是继续向下查找，直到叶结点上的该关键字为止。所以，在B+树中查找时，无论查找是否成功，每次查找都是一条从根结点到叶结点的路径。

三、B树和B+树的对比

B+树的优点在于:

• 由于B+树在非叶子结点上不包含真正的数据，只当做索引使用，因此在内存相同的情况下，能够存放更多的key。

• B+树的叶子结点都是相连的，因此对整棵树的遍历只需要一次线性遍历叶子结点即可。 而且由于数据顺序排列并且相连，所以便于区间查找和搜索。而B树则需要进行每一层的递归遍历。

B树的优点在于:

由于B树的每-一个节点都包含key和value，因此我们根据key查找value时，只需要找到key所在的位置，就能找到value，但B+树只有叶子结点存储数据，索引每一次查找，都必须一直找到树的最大深度处，也就是叶子结点的深度，才能找到value。

2-3树是最简单的 B 树结构，其每个非叶节点都有两个或三个子女，而且所有叶子结点都在同一层上。2-3树不是二叉树，其节点可拥有3个孩子。

在2-3树中包含2-结点和3-结点，下面分别对这两个结点进行解释：

• 2-结点：含有一个键（及其对应的值）和两条链，左链接指向2-3树中的键都小于该结点，右链接指向的2-3树中的键都大于该结点。
• 3-结点：含有两个键（及其对应的值）和三条链，左链接指向的2-3树中的键都小于该结点，中链接指向的2-3树中的键都位于该结点的两个键之间，右链接指向的2-3树中的键都大于该结点。

二、查找

将二叉搜索树的查找算法一般化我们就能够直接得到2-3树的查找算法。 要判断一个键是否在树中，我们先将它和
根结点中的键比较。如果它和其中任意一个相等，查找命中；否则我们就根据比较的结果找到指向相应区间的连
接，并在其指向的子树中递归地继续查找。如果这个是空链接，查找未命中。

例如在上图中的2-3树中查找结点28，下面给出查找过程：

三、插入

1、向2-结点插入新结点

往2-3树中插入元素和往二叉搜索树中插入元素一样，首先要进行查找，然后将节点挂到未找到的结点上。如果查找后未找到的结点是一个2-结点，那么我们只需要将新的元素放到这个2-结点中使其变成一个3-结点即可。

2、向一颗只有3-结点的树插入新结点

假设2-3树只包含一个3-结点，这个结点有两个键，没有空间来插入第三个键了，最自然的方式是我们假设这个结点能存放三个元素，暂时使其变成一个4-结点，同时他包含四条链接。然后,我们将这个4-结点的中间元素提升，左边的键作为其左子结点，右边的键作为其右子结点。插入完成，变为平衡2-3查找树，树的高度从0变为1。

3、向一个父结点为2-结点的3-结点插入新结点

和上面的情况一样，我们也可以将新的元素插入到3-结点中，使其成为一个临时的4-结点，然后将该结点中的中间元素提升到父结点即2-结点中，使父结点成为一个3-结点，然后将左右结点分别挂在这个3-结点的恰当位置。

4、向一个父结点为3-结点的3-结点插入新结点

当我们插入的结点是3-结点的时候，我们将该结点拆分，中间元素提升至父结点，但是此时父结点是一个3-结点，插入之后，父结点变成了4-结点，然后继续将中间元素提升至其父结点，直至遇到一个父结点是2-结点，然后将其为3-结点，不需要继续进行拆分。

5、分解根结点

当插入结点到根结点的路径上全部是3-结点的时候，最终我们的根结点会编程一个临时的4-结点，此时，就需要将根结点拆分为两个2-结点，树的高度加1。

四、二叉树的性质

通过对2-3树插入操作的分析，我们发现在插入的时候，2-3树需要做一些局部的变换来保持2-3树的平衡。一棵完全平衡的2-3树具有以下性质：

1. 任意空链接到根结点的路径长度都是相等的。
2. 4-结点变换为3-结点时,树的高度不会发生变化,只有当根结点是临时的4结点,分解根结点时,树高+1。
3. 2-3树与普通二叉查找树最大的区别在于,普通的二叉查找树是自顶向下生长,而2-3树是自底向_性长。

2-3查找树实现起来比较复杂，在某些情况插入后的平衡操作可能会使得效率降低。但是2-3查找树作为一种比较重要的概念对于B树和B+树来说非常重要。

红黑树（red-black tree） 是一棵二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是RED或BLACK。通过对任何一条从根到叶子的简单路径上各个结点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因而是近似于平衡的。

红黑树具有以下性质：

• 每个结点或是红色的，或是黑色的。
• 根结点是黑色的。
• 每个叶结点(NIL)是黑色的。
• 如果一个结点是红色的，则它的两个子结点都是黑色的。
• 对每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点。

一颗典型的红黑树如下图所示（其中的NIL可以理解为空指针）：

一棵有 n 个内部结点的红黑树的高度至多为$2log_2(n+1)$。关于该结论的证明，可以参阅《算法导论》中的相关证明，这里不再进行赘述。

二、旋转

指针结构的修改是通过旋转（rotation）来完成的，这是一种能保持二叉搜索树性质的搜索树局部操作。下图给出了两种旋转：左旋和右旋。

下面来简单介绍一下左旋和右旋是如何实现的：

1、左旋

2、右旋

三、插入

这里先挖个坑，有时间再回来填，这里先推荐几个介绍红黑树的文章和视频：

https://zhuanlan.zhihu.com/p/79980618

https://zhuanlan.zhihu.com/p/91960960

https://www.bilibili.com/video/BV1iJ411E7xW?p=124

四、删除

这里先挖个坑，有时间再回来填。

为避免树的高度增长过快，降低二叉排序树的性能，规定在插入和删除二叉树的结点时要保证任意结点的左、右子树的高度差的绝对值不超过 1，将这样的二叉排序树称为平衡二叉树（Balanced Binary Tree），又称AVL树。

定义结点左子树与右子树的高度差为该结点的平衡因子，则平衡二叉树结点的平衡因子的值只可能是 -1、0 或 1。

二、插入操作

二叉排序树保证平衡的基本思想为：每当在二叉排序树中插入（或删除）一个结点时，首先检查其插入路径上的结点是否因为此次操作而导致了不平衡。若导致了不平衡，则先找到插入路径上离插入结点最近的平衡因子的绝对值大于 1 的结点 N，再对以 N 为根的子树，在保持二叉排序树特性的前提下，调整各结点的位置关系，使之重新达到平衡。

平衡二叉树的调整存在LL平衡旋转（右单旋转）、RR平衡旋转（左单旋转）、LR平衡旋转（先左后右双旋转）、RL平衡旋转（先右后左双旋转）这4种情况，下面将分别介绍这几种情况下的调整方法。

（1）LL平衡旋转

假设有一颗平衡二叉树，当该二叉树插入一个结点 6 时，根节点的平衡因子的绝对值大于 1，此时该二叉树不再是一颗平衡二叉树，如下图所示：

可以看到，由于在结点10的左孩子（结点8）的左子树上插入了一个新结点（结点6），结点10的平衡因子由 1 增至 2，导致以结点10为根的子树失去平衡，因此需要一次向右的旋转操作。

【操作步骤】

• 首先创建一个新结点，并将新结点的值设置为根结点的值

• 之后将新结点的左孩子设置为根结点的左孩子的右子树，将新结点的右孩子设置为根结点的右孩子

• 然后将根结点的值设置为其左孩子的值，并将根结点的右孩子设置为新结点

• 最后将根结点的左孩子设置为其左孩子的左子树

【实现效果】

可以看到，此时的根结点的值为8，原根结点10移动到现根结点8的右侧，相当于进行了一次向右旋转。

【代码实现】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// LL平衡旋转
private void rightRotate() {
    // 首先创建一个新结点，并将新结点的值设置为根结点的值
    TreeNode newNode = new TreeNode(val);
    // 将新结点的左孩子设置为根结点的左孩子的右子树
    newNode.left = left.right;
    // 将新结点的右孩子设置为根结点的右孩子
    newNode.right = right;
    // 将根结点的值设置为其左孩子的值
    val = left.val;
    // 将根结点的右孩子设置为新结点
    right = newNode;
    // 将根结点的左孩子设置为其左孩子的左子树
    left = left.left;
}

（2）RR平衡旋转

假设有一颗平衡二叉树，当该二叉树插入一个结点 8 时，根节点的平衡因子的绝对值大于 1，此时该二叉树不再是一颗平衡二叉树，如下图所示：

可以看到，由于在结点4的右孩子（结点6）的右子树上插入了一个新结点（结点8），结点4的平衡因子由 -1 减至 -2，导致以结点4为根的子树失去平衡，因此需要一次向左的旋转操作。

【操作步骤】

• 创建新的结点，并将新结点的值设置为根结点的值

• 将新的结点的左孩子设置成根结点的左孩子，并将新的结点的右孩子设置成根结点的右孩子的左子树

• 将根结点的值替换成右孩子的值，并将根结点的左孩子设置成新的结点

• 将根结点的右孩子设置成右孩子的右子树

【实现效果】

可以看到，此时的根结点的值为6，原根结点4移动到现根结点6的左侧，相当于进行了一次向左旋转。

【实现代码】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// RR平衡旋转
private void leftRotate() {
    // 创建新的结点，并将新结点的值设置为根结点的值
    TreeNode newNode = new TreeNode(val);
    // 把新的结点的左孩子设置成当前结点的左孩子
    newNode.left = left;
    // 把新的结点的右孩子设置成当前结点的右孩子的左子树
    newNode.right = right.left;
    // 把当前结点的值替换成右孩子的值
    val = right.val;
    // 把当前结点的左孩子设置成新的结点
    left = newNode;
    // 把当前结点的右孩子设置成右孩子的右子树
    right = right.right;
}

（3）LR平衡旋转

假设有一颗平衡二叉树，如下图(a)所示，当插入结点9后根结点的平衡因子为2，因此需要进行调整。如果我们直接进行RR平衡旋转，得到的结果如下图(b)所示，此时根结点的平衡因子为-2，仍然不是一颗平衡二叉树。

那么该如何调整上面的二叉树，使其成为一颗平衡二叉树呢？

首先通过观察，我们可以发现上图(a)中根结点的左孩子的右子树高度大于根结点的左孩子的左子树的高度，对于这种情况，我们可以先对根结点的左孩子进行RR平衡旋转，再对根结点进行LL平衡旋转，即LR平衡旋转。

【操作步骤】

• 先将根结点的左孩子进行RR平衡旋转

• 再将根结点进行LL平衡旋转

（4）RL平衡旋转

与LR平衡旋转类似，当根结点的右孩子的左子树高度大于根结点的右孩子的右子树的高度时，我们可以先对根结点的右孩子进行LL平衡旋转，再对根结点进行RR平衡旋转，即RL平衡旋转。

【操作步骤】

假设有一颗平衡二叉树 {2, 1, 6, 5, 7}，在插入结点3后，可根据如下步骤进行调整：

• 先将根结点的左孩子进行RR平衡旋转

• 再将根结点进行LL平衡旋转

三、查找操作

平衡二叉树的查找操作与二叉排序树相同，详细内容可阅读我之前写的一篇文章《二叉排序树》，这里不再进行赘述。这里需要注意的是，平衡二叉树在二叉排序树的基础上进行了优化，解决了极端情况下（二叉树变成了单链表）查找效率降低的问题。因此平衡二叉树的平均查找长度为$O(log_2n)$。

四、完整实现

1、获取二叉树的高度

在实现平衡二叉树的操作之前我们需要获取二叉树的高度，因为只有知道了树的高度才能判断在插入一个新结点后该树是否仍为平衡二叉树。因此我们需要在TreeNode类中添加以下方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 返回当前结点的左子树的高度
public int leftHeight() {
    return left == null ? 0 : left.height();
}

// 返回当前结点的右子树的高度
public int rightHeight() {
    return right == null ? 0 : right.height();
}

// 返回以当前结点为根结点的树的高度
public int height() {
    return Math.max(left == null ? 0 : left.height(), right == null ? 0 : right.height()) + 1;
}

2、在插入时进行平衡旋转

当可以获取二叉树的高度之后，就可以在TreeNode类插入结点方法中添加以下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public void add(TreeNode node) {
    // 插入结点
    // ...

    // 判断当前二叉树是否平衡
    if (rightHeight() - leftHeight() > 1) {
        // 如果当前结点的右孩子的左子树高度大于当前结点的右孩子的右子树的高度
        if (right != null && right.leftHeight() > right.rightHeight()) {
            // RL平衡旋转
            // 1.先对当前结点的右孩子向右旋转（LL平衡旋转）
            right.rightRotate();
            // 2.再对当前结点进行向左旋转（RR平衡旋转）
            leftRotate();
        } else {
            // RR平衡旋转
            leftRotate();
        }
    } else if (leftHeight() - rightHeight() > 1) {
        // 如果当前结点的左孩子的右子树高度大于当前结点的左孩子的左子树的高度
        if (left != null && left.rightHeight() > left.leftHeight()) {
            // LR平衡旋转
            // 1.先对当前结点的左孩子向左旋转（RR平衡旋转）
            left.leftRotate();
            // 2.再对当前结点进行向右旋转（LL平衡旋转）
            rightRotate();
        } else {
            // LL平衡旋转
            rightRotate();
        }
    }
}

完整的实现代码已上传到Gitee，仓库地址：https://gitee.com/fzcoder/data-structure-and-algorithms-demo。

1、基本概念

计算机上所有可运行的软件，通常也包括操作系统，被组织成若干顺序进程（sequential process），简称进程（process）。 一个进程就是一个正在执行程序的实例，包括程序计数器、寄存器和变量的当前值。从概念上说，每个进程拥有它自己的虚拟 CPU。当然，实际上真正的 CPU 在各进程之间来回切换。但为了理解这种系统，考虑在（伪）并行情况下运行的进程集，要比试图跟踪 CPU 如何在程序间来回切换简单得多。

• 在上图 (a) 中可以看到，在一台多道程序计算机的内存中有 4 道程序。

• 在上图 (b) 中，这 4 道程序被抽象为 4 个各自拥有自已控制流程（即每个程序自己的逻辑程序计数器）的进程，并且每个程序都独立地运行。当然，实际上只有一个物理程序计数器，所以在每个程序运行时，它的逻辑程序计数器被装人实际的程序计数器中。当该程序执行结束（或暂停执行）时，物理程序计数器被保存在内存中该进程的逻辑程序计数器中。

• 在上图 (c) 中可以看到，在观察足够长的一段时间后，所有的进程都运行了，但在任何一个给定的瞬间仅有一个进程真正在运行。即在单核 CPU 中进程是并发执行的（注意并发与并行的区别）。

为了使参与并发执行的程序（含数据）能独立地运行，必须为之配置一个专门的数据结构，称为进程控制块（Process Control Block, PCB）。操作系统利用 PCB 来描述进程的基本情况和运行情况，进而控制和管理进程。相应地，由程序段、相关数据段和 PCB 三部分构成了进程映像（进程实体）。所谓创建进程，实质上是创建进程映像中的 PCB；而撤销进程，实质上是撤销进程的 PCB。要注意，进程映像是静态的，而进程是动态的。

从不同的角度，进程可以有不同的定义，下面列出一些典型的定义：

• 进程是程序的一次执行过程。
• 进程是一个程序及其数据在处理机上顺序执行时所发生的活动。
• 进程是具有独立功能的程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位。

在介绍了进程映像的相关概念后，可对进程做如下定义：进程是进程映像的运行过程，是系统进行资源分配和调度的一个独立单位。

2、进程的状态

进程在其生命周期内，由于系统中各进程之间的相互制约关系及系统的运行环境的变化，使得进程的状态也在不断地发生变化。通常进程有以下5种状态，前3种是进程的基本状态。

• 就绪（Ready）状态：进程获得了除处理机外的一切所需资源，一旦得到处理机，便可立即运行。

• 运行（Running）状态：进程正在处理机上运行。在单处理机环境下，每个时刻最多只有一个进程处于运行状态。

• 阻塞（Blocked）状态：进程正在等待某一事件而暂停运行，如等待某资源为可用（不包括处理机）或等待输入/输出完成。即使处理机空闲，该进程也不能运行。

  就绪、运行和阻塞状态的转换关系如下：

• 创建状态：进程正在被创建，尚未转到就绪态。

• 结束状态：进程正从系统中消失，可能是进程正常结束或其他原因中断退出运行。

  在加入创建和终止状态的转换图如下：

3、进程控制

进程控制的主要功能是对系统中的所有进程实施有效的管理，它具有创建新进程、撤销已有进程、实现进程状态转换等功能。在操作系统中，一般把进程控制用的程序称为原语，原语的特点是执行期间不允许中断，它是一个不可分割的基本单位。

（1）进程的创建

引起进程创建的事件：

• 用户登录。在分时系统中，用户在终端键入登录命令后，若登录成功，系统将为该用户建立一个进程，并把它插入就绪队列中。

• 作业调度。在多道批处理系统中，当作业调度程序按一定的算法调度到某个(些)作业时，便将它(们)装入内存，为它(们)创建进程，并把它(们)插入就绪队列中。

• 提供服务。当运行中的用户程序提出某种请求后，系统将专门创建一个进程来提供用户所需要的服务，例如，用户程序要求进行文件打印，操作系统将为它创建一个打印进程，这样不仅可使打印进程与该用户进程并发执行，而且还便于计算为完成打印任务所花费的时间。

• 应用请求。在上述三种情况下，都是由系统内核为用户创建一 个新进程；而这类事件则是由用户进程自己创建新进程，以便使新进程以同创建者进程并发运行的方式完成特定任务。

进程的创建步骤（创建原语）：

• 申请空白PCB，为新进程申请获得唯一的数字标识符，并从PCB集合中索取一个空白PCB。

• 为新进程分配其运行所需的资源，包括各种物理和逻辑资源，如内存、文件、I/O 设备和 CPU 时间等。这些资源或从操作系统或仅从其父进程获得。新进程对这些资源的需求详情一般也要提前告知操作系统或其父进程。注意：若资源不足（如内存空间），则并不是创建失败，而是处于阻塞态，等待内存资源。

• 初始化进程控制块。PCB 的初始化包括：初始化标识信息，将系统分配的标识符和父进程标识符填入新PCB中；初始化处理机状态信息，使程序计数器指向程序的入口地址，使栈指针指向栈项；初始化处理机控制信息，将进程的状态设置为就绪状态或静止就绪状态，对于优先级，通常是将它设置为最低优先级，除非用户以显式方式提出高优先级要求。

• 如果进程就绪队列能够接纳新进程，便将新进程插入就绪队列。

（2）进程的终止

引起进程终止的事件：

• 正常结束。表示进程的任务已经完成，准备退出运行。在任何系统中，都应有一个用于表示进程已经运行完成的指示。

• 异常结束。是指进程在运行时发生了某种异常事件，使程序无法继续运行。常见的异常事件有：越界错、保护错、非法指令、特权指令错、运行超时、等待超时、算术运算错、I/O故障等。

• 外界干预。是指进程应外界的请求而终止运行。这些干预有：操作员或操作系统干预、父进程请求和父进程终止。

进程的终止步骤（撤销原语）：

• 根据被终止进程的标识符，从PCB集合中检索出该进程的PCB，从中读出该进程的状态。

• 若被终止进程正处于执行状态，应立即终止该进程的执行，并置调度标志为真，用于指示该进程被终止后应重新进行调度。

• 若该进程还有子孙进程，还应将其所有子孙进程也都予以终止，以防它们成为不可控的进程。

• 将被终止进程所拥有的全部资源或者归还给其父进程，或者归还给系统。

• 将被终止进程(PCB)从所在队列(或链表)中移出，等待其它程序来搜集信息。

（3）阻塞与唤醒

正在执行的进程，由于期待的某些事件未发生，如请求系统资源失败、等待某种操作的完成、新数据尚未到达或无新工作可做等。由系统自动执行阻塞原语（Block），使自己由运动态变为阻塞态。可见，进程的阻塞是进程自身的一种主动行为，也因此只有处于运行态的进程（获得CPU），才可能将其转为阻塞态。阻塞原语的执行过程如下：

• 找到将要被阻塞进程的标识号对应的PCB。
• 若该进程为运行状态，则保护其现场。将其状态转为阻塞态，停止运行。
• 把该PCB插入相应事件的等待队列，将处理机资源调度给其它就绪进程。

当被阻塞进程所期待的事件出现时，如它所启动的I/O操作已完成或其所期待的数据已到达，由有关进程（如：释放该I/O设备的进程，或提供数据的进程）调用唤醒原语（Wakeup），将等待该事件的进程唤醒。唤醒原语的执行过程如下：

• 在该事件的等待队列中找到相应进程的PCB。
• 将其从等待队列中移出，并置其状态为就绪状态。
• 把该PCB插入就绪队列，等待调度程序调用。

需要注意的是，Block 原语和 Wakeup 原语是一对作用刚好相反的原语，必须成对使用。Block 原语是由被阻塞进程自我调用实现的，而 Wakeup 原语则是由一个与被唤醒进程合作或被其它相关的进程调用实现的。

（4）挂起与激活

• 进程的挂起（suspend）

当系统中出现了引起进程挂起的事件时，OS 将利用挂起原语 suspend 将指定进程或处于阻塞状态的进程挂起。 suspend 的执行过程是：首先检查被挂起进程的状态，若处于活动就绪状态，便将其改为静止就绪；对于活动阻塞状态的进程，则将之改为静止阻塞；为了方便用户或父进程考查该进程的运行情况，而把该进程的 PCB 复制到某指定的内存区域；最后，若被挂起的进程正在执行，则转向调度程序重新调度。

• 进程的激活（active）

当系统中发生激活进程的事件时，OS 将利用激活原语 active，将指定进程激活。激活原语先将进程从外存调入内存，检查该进程的现行状态，若是静止就绪，便将之改为活动.就绪;若为静止阻塞，便将之改为活动阻塞。假如采用的是抢占调度策略，则每当有静止就绪进程被激活而插入就绪队列时，便应检查是否要进行重新调度，即由调度程序将被激活的进程与当前进程两者的优先级进行比较，如果被激活进程的优先级低，就不必重新调度;否则，立即剥夺当前进程的运行，把处理机分配给刚刚被激活的进程。

4、进程的层次结构

在操作系统中，允许一个进程创建另一个进程。此时创建者称为父进程，被创建的进程称为子进程。子进程可以继承父进程所拥有的资源。当子进程被撤销时，应将其从父进程那里获取的资源归还给父进程。此外，在撤销父进程时，必须同时撤销其所有的子进程。子进程自身可以创建更多的进程，组成一个进程的层次结构。

在 UNIX 中，进程和它的所有子进程以及后裔共同组成一个进程组。当用户从键盘发出一个信号时，该信号被送给当前与键盘相关的进程组中的所有成员（它们通常是在当前窗口创建的所有活动进程）。每个进程可以分别捕获该信号、忽略该信号或采取默认的动作，即被该信号杀死。

这里有另一个例子，可以用来说明进程层次的作用，考虑 UNIX 在启动时如何初始化自己。一个称为 init 的特殊进程出现在启动映像中。当它开始运行时，读入一个说明终端数量的文件。接着，为每个终端创建一一个新进程。这些进程等待用户登录。如果有一个用户登录成功，该登录进程就执行一个 shell 准备接收命令。所接收的这些命令会启动更多的进程，以此类推。这样，在整个系统中，所有的进程都属于以 init 为根的一棵树。

相反，Windows 中没有进程层次的概念，所有的进程都是地位相同的。唯一类似于进程层次的暗示是在创建进程的时候，父进程得到一个特别的令牌（称为句柄），该句柄可以用来控制子进程。但是，它有权把这个令牌传送给某个其他进程，这样就不存在进程层次了。在 UNIX 中，进程就不能剥夺其子继承的“继承权”。

5、进程的实现

为了实现进程模型，操作系统维护着一张表格（一个结构数组），即进程表（process table）。 每个进程占用一个进程表项（即进程控制块，PCB）该表项包含了进程状态的重要信息，包括程序计数器、堆栈指针、内存分配状况、所打开文件的状态、账号和调度信息，以及其他在进程由运行态转换到就绪态或阻塞态时必须保存的信息，从而保证该进程随后能再次启动，就像从未被中断过样。

上图展示了在一个典型系统中的关键字段。第一列中的字段与进程管理有关。其他两列分别与存储管理和文件管理有关。应该注意到进程表中的字段是与系统密切相关的，不过该图给出了所需要信息的大致介绍。

二、线程

1、为什么要使用线程

如果说，在 OS 中引入进程的目的是为了使多个程序能并发执行，以提高资源利用率和系统吞吐量，那么，在操作系统中再引入线程（thread），则是为了减少程序在并发执行时所付出的时空开销，使 OS 具有更好的并发性。

2、经典的线程模型

线程最直接的理解就是轻量级进程（lightweight process），它是一个基本的CPU执行单元，也是程序执行流的最小单元。在线程中有一个程序计数器，用来记录接着要执行哪一条指令。线程拥有寄存器，用来保存线程当前的工作变量。线程还拥有一个堆栈，用来记录执行历史，其中每一帧保存了一个已调用的但是还没有从中返回的过程。尽管线程必须在某个进程中执行，但是线程和它的进程是不同的概念，并且可以分别处理。进程用于把资源集中到一起，而线程则是在CPU上被调度执行的实体。

线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。

例如，在上图(a)中，可以看到三个传统的进程。每个进程有自己的地址空间和单个控制线程。相反，在上图(b)中，可以看到一个进程带有三个控制线程。尽管在两种情形中都有三个线程，但是在上图(a)中，每一个线程都在不同的地址空间中运行，而在上图(b)中，这三个线程全部在相同的地址空间中运行。

3、线程的实现

在介绍线程的实现之前，我们先来简单介绍一下 POSIX 线程。为了实现可移植的线程程序，IEEE 在 IEEE 标准 1003.1c 中定义了线程的标准。它定义的线程包叫作pthread。大部分 UNIX 系统都支持该标准。这个标准定义了超过 60 个函数调用。下面将通过一张表格来介绍一些主要的函数，以说明它是如何工作的。

所有pthread线程都有某些特性。每一个都含有一个标识符、一组寄存器（包括程序计数器）和一组存储在结构中的属性。这些属性包括堆栈大小、调度参数以及其他线程需要的项目。

线程的实现可以分为两类：用户级线程（User-Level Thread, ULT）和内核级线程（Kernel-Level Thread, KLT）。这两种方法各有利弊，下面我们将分别详细介绍这两种方法。

（1）用户级线程

在用户级线程中，有关线程管理（线程的创建、撤销和切换等）的所有工作都由应用程序完成，内核意识不到线程的存在。应用程序可以通过使用线程库设计多线程程序。下面将举一个使用pthread线程库编写的一个小程序的案例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define NUMBER_OF_THREADS 10

void *print_hello_world(void *tid)
{
    // 本函数输出线程的标识符，然后退出。
    print("Hello World. Greetings from thread %d\n", tid);
    pthread_exit(NULL);
}

int main(int argc, char *argv[])
{
    // 主程序创建10个线程，然后退出。
    pthread_t threads[NUMBER_OF_THREADS];
    int status, i;

    for(i = 0; i < NUMBER_OF_THREADS; i++) {
        printf("Main here. Creating thread %d\n", i);
        status = pthread_create(&threads[i], NULL, print_hello_world, (void *)i);

        if (status != 0) {
            printf("Oops. pthread_create returned error code %d\n", status);
        }
        exit(-1);
    }
    exit(NULL);
}

所有的这类实现都有同样的通用结构，如下图所示。线程在一个运行时系统的上层运行，该运行时系统是一个管理线程的过程的集合。

在用户空间管理线程时，每个进程需要有其专用的线程表（thread table），用来跟踪该进程中的线程。这些表和内核中的进程表类似，不过它仅仅记录各个线程的属性，如每个线程的程序计数器、堆栈指针、寄存器和状态等。该线程表由运行时系统管理。当一个线程转换到就绪状态或阻塞状态时，在该线程表中存放重新启动该线程所需的信息，与内核在进程表中存放进程的信息完全一样。

（2）内核级线程

在内核级线程中，线程管理的所有工作由内核完成，应用程序没有进行线程管理的代码，只有一个到内核级线程的编程接口。内核为进程及其内部的每个线程维护上下文信息，调度也在内核基于线程架构的基础上完成。下图说明了内核级线程的实现方式。

当使用内核级线程时就不再需要运行时系统了。另外，每个进程中也没有线程表。相反，在内核中有用来记录系统中所有线程的线程表。当某个线程希望创建一个新线程或撤销一个已有线程时，它进行一个系统调用，这个系统调用通过对线程表的更新完成线程创建或撤销工作。

内核的线程表保存了每个线程的寄存器、状态和其他信息。这些信息和在用户空间中（在运行时系统中）的线程是一样的，但是现在保存在内核中。这些信息是传统内核所维护的每个单线程进程信息（即进程状态）的子集。另外，内核还维护了传统的进程表，以便跟踪进程的状态。

（3）混合实现

有些系统使用混合方式进行实现，简单来说就是使用内核级线程，然后将用户级线程与某些或者全部内核线程多路复用起来，如下图所示。

如果采用这种方法，编程人员可以决定有多少个内核级线程和多少个用户级线程彼此多路复用。这一模型带来最大的灵活度。采用这种方法，内核只识别内核级线程，并对其进行调度。其中一些内核级线程会被多个用户级线程多路复用。如同在没有多线程能力操作系统中某个进程中的用户级线程一样，可以创建、撤销和调度这些用户级线程。在这种模型中，每个内核级线程有一个可以轮流使用的用户级线程集合。

4、多线程模型

有些系统同时支持用户线程和内核线程，由此产生了不同的多线程模型，即实现用户级线程和内核级线程的连接方式。

（1）多对一模型

将多个用户级线程映射到一个内核级线程，线程管理在用户空间完成。此模式中，用户级线程对操作系统不可见（即透明）。

优点：线程管理是在用户空间进行的，因而效率比较高。

缺点：一个线程在使用内核服务时被阻塞，整个进程都会被阻塞；多个线程不能并行地运行在多处理机上。

（2）一对一模型

将每个用户级线程映射到一个内核级线程。

优点：当一个线程被阻塞后，允许另一个线程继续执行，所以并发能力较强。

缺点：每创建一个用户级线程都需要创建一个内核级线程与其对应，这样创建的线程开销比较大，会影响到应用程序的性能。

（3）多对多模型

将 n 个用户级线程映射到 m 个内核级线程上，要求 $m \le n$。

特点：多对多模型是多对一模型和一对一模型的折中，既克服了多对一模型并发度不高的缺点，又克服了一对一模型的一个用户进程占用太多内核级线程而开销太大的缺点。此外，还拥有多对一模型和一对一模型各自的优点，可谓集两者之所长。

二叉排序树（Binary Sort Tree, BST）也称二叉搜索树，或是一颗空树，或者是具有一下性质的二叉树：

• 若左子树非空，则左子树上所有结点的值均小于根结点的值。
• 若右子结点非空，则右子树上所有结点的值均大于根结点的值。
• 左、右子树也分别是一颗二叉排序树。

根据二叉排序树的定义有：左子树结点值 < 根结点值 < 右子树结点值，所以对二叉排序树进行中序遍历，可以得到一个递增的有序序列。

如上图所示，该二叉排序树的中序遍历序列为 1 2 3 4 5 6。

二、相关操作

1、二叉排序树的插入

二叉排序树作为一种动态树表，其特点是树的结构通常不是一次生成的，而是在查找过程中，当树中不存在关键字值等于给定值的结点时再进行插入的。

首先确定二叉排序树结点的数据结构及成员方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    public TreeNode(int val) {
        this.val = val;
    }
    // 插入结点
    public void add(TreeNode node) {
        // 如果当前结点的值小于要插入结点的值
        if (node.val < this.val) {
            // 判断当前结点的左子结点是否为空
            if (this.left == null) {
                // 为空，在当前结点的左子结点位置插入结点
                this.left = new TreeNode(node.val);
            } else {
                // 不为空，继续向左子树查找插入的位置
                this.left.add(node);
            }
        }
        // 如果当前结点的值大于要插入结点的值
        if (node.val > this.val) {
            // 判断当前结点的右子结点是否为空
            if (this.right == null) {
                // 为空，在当前结点的右子结点位置插入结点
                this.right = new TreeNode(node.val);
            } else {
                // 不为空，继续向右子树查找插入的位置
                this.right.add(node);
            }
        }
    }
}

注：上面的算法忽略了当插入的值等于当前结点的情况，原因是二叉排序树一般用于当表中元素的值各不相同的情况时，如果在二叉排序树中插入多个相同值的结点时会影响查询的效率。

然后创建BinarySortTree类，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12

class BinarySortTree {
    // 二叉排序树的根结点
    private TreeNode root;
    // 插入结点
    public void insertNode(int value) {
        if (root == null) {
            root = new TreeNode(value);
        } else {
            root.add(new TreeNode(value));
        }
    }
}

之后在主方法中创建BinarySortTree类并调用其中的insertNode方法即可实现二叉排序树的插入。

例如，现在有一个数组为 { 45, 24, 53, 45, 12, 24, 90 }，则按上述算法生成二叉排序树的过程如下：

2、二叉排序树的查找

二叉排序树的查找是从根结点开始，沿某个分支逐层向下比较的过程。若二叉排序树非空，先将给定值与根结点的关键字比较，若相等，则查找成功；若不等，如果小于根结点的关键字，则在根结点的左子树上查找，否则在根结点的右子树上查找。这是一个递归的过程。

首先在TreeNode类中添加以下成员方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public TreeNode search(int value) {
    if (this.val == value) {
        // 查找的值等于当前结点的值
        // 返回当前结点
        return this;
    } else if (this.val > value && this.left != null) {
        // 查找的值小于当前结点的值且当前结点左子树非空
        // 在当前结点的左子树上查找
        return this.left.search(value);
    } else if (this.val < value && this.right != null) {
        // 查找的值小于当前结点的值且当前结点左子树非空
        // 在当前结点的左子树上查找
        return this.right.search(value);
    } else {
        // 查询不到结果，返回空值
        return null;
    }
}

然后在BinarySortTree类中添加以下成员方法：

1
2
3
4
5
6
7

public TreeNode searchNode(int value) {
    if (this.root != null) {
        return root.search(value);
    } else {
        return null;
    }
}

之后在主方法中调用BinarySortTree类的searchNode方法即可实现二叉排序树的查找。

3、二叉排序树的删除

在二叉排序树中删除一个结点时，不能把以该结点为根的子树上的结点都删除，必须先把被删除结点从存储二叉排序树的链表上移除，将因删除结点而断开的二叉链表重新链接起来，同时确保二叉排序树的性质不会丢失。下面将介绍在以下三种情况下删除结点的方法。

（1）删除叶子结点

如果被删除的结点是叶子节点，则直接删除，不会破坏二叉排序树的性质。在使用代码实现之前，我们需要分析一下算法的实现过程：

• 首先需要找到要删除的结点和它的父结点（如果存在的话）。
• 判断要删除的结点是其父结点的左子结点还是右子结点，并根据情况进行删除。

由上面的分析可知，我们需要在原有代码的基础上实现一个可以查找目标结点的父结点的方法，在TreeNode类中添加以下成员方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public TreeNode searchParent(int value) {
    // 如果当前结点的子结点即为要查找的结点
    if ((this.left != null && this.left.val == value)
        || (this.right != null && this.right.val == value)) {
        // 返回当前结点
        return this;
    } else {
        if (this.left != null && value < this.val) {
            // 如果左子树非空且查找的值小于当前结点的值
            // 向左子树查找
            return this.left.searchParent(value);
        } else if (this.right != null && value > this.val){
            // 如果右子树非空且查找的值小于当前结点的值
            // 向右子树查找
            return this.right.searchParent(value);
        } else {
            // 查找不到结果，返回空值
            return null;
        }
    }
}

在BinarySortTree类中添加以下成员方法：

1
2
3
4
5
6
7

public TreeNode searchParent(int value) {
    if (root != null) {
        return root.searchParent(value);
    } else {
        return null;
    }
}

下面我们将实现删除叶子结点的方法，在BinarySortTree类中添加如下成员方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// 删除结点
public void deleteNode(int value) {
    // 1.找到要删除的结点
    TreeNode target = searchNode(value);
    // 如果没有找到要删除的结点直接返回
    if (target == null) {
        return;
    }
    // 2.找要删除结点的父结点
    TreeNode parent = searchParent(value);
    // 如果找不到父结点。说明该结点就是根结点
    if (parent == null) {
        root = null;
        return;
    }
    // 3.如果目标结点是叶子结点
    if (target.left == null && target.right == null) {
        // 如果是父结点的左子结点
        if (target == parent.left) {
            parent.left = null;
            return;
        }
        // 如果是父结点的右子结点
        if (target == parent.right) {
            parent.right = null;
            return;
        }
    }
    // ...
}

（2）删除只有一个子结点的结点

若被删除的结点只有一颗左子树或右子树，则让该结点的子树成为父结点的子树，替代该结点的位置。

在BinarySortTree类中添加如下成员方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

if (target.left == null && target.right == null) { // 3.如果目标结点是叶子结点
    // ...
} else if (target.left != null && target.right != null) { // 4.如果目标结点有两个子结点
// ...
} else { // 5.如果目标结点只有一个子结点
    if (target.left != null) { // 如果目标结点的左子结点不为空
        if (target == parent.left) {
            parent.left = target.left;
        } else {
            parent.right = target.left;
        }

    } else { // 如果目标结点的右子结点不为空
        if (target == parent.left) {
            parent.left = target.right;
        } else {
            parent.right = target.right;
        }
    }
}

上述算法删除只有一个子结点的结点的过程如下图所示：

（3）删除有两个子结点的结点

若被删除的结点有左、右两颗子树，则令该结点的直接后继（或直接前驱）替代该结点，然后从二叉排序树中删除这个直接后继（或直接前驱），这样就转换成了第一或第二种情况。

1
2
3
4
5
6
7
8
9
10

if (target.left == null && target.right == null) { // 3.如果目标结点是叶子结点
    ...
} else if (target.left != null && target.right != null) { // 4.如果目标结点有两个子结点
    // 获取右子树中序第一个子结点的值并删除该结点
    int val = delRightSubTreeFirstNodeByInOrder(target.right);
    // 将要被删除的结点值改为右子树中序第一个子结点的值
    target.val = val;
} else { // 5.如果目标结点只有一个子结点
    // ...
}

其中获取右子树中序第一个子结点的方法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

public int delRightSubTreeFirstNodeByInOrder(TreeNode node) {
    TreeNode target = node;
    // 循环的查找左子节点，就会找到最小值
    while (target.left != null) {
        target = target.left;
    }
    // 保存结点的值
    int value = target.val;
    // 删除该结点
    deleteNode(value);
    // 返回被删除结点的值
    return value;
}

上述算法删除有两个子结点的结点的过程如下图所示：

三、算法分析

二叉排序树的查找效率，主要取决于树的高度。若二叉排序树的左、右子树的高度之差的绝对值不超过 1，则这样的二叉排序树称为平衡二叉树，它的平均查找长度为$O(log_2n)$。若二叉排序树是一个只有右（左）孩子的单支树（类似于有序的单链表），则其平均查找长度为$O(n)$。

从查找过程看，二叉排序树与二分查找相似。就平均时间性能而言，二叉排序树上的查找和二分查找差不多。但二分查找的判定树唯一，而二叉排序树的查找不唯一，相同的关键字其插入顺序不同可能生成不同的二叉排序树，如下图所示：

就维护表的有序性而言，二叉排序树无需移动结点，只需修改指针即可完成插入和删除操作，平均执行时间为$O(log_2n)$。二叉查找的对象是有序顺序表，若有插入和删除结点的操作，所花的代价是$O(n)$。当有序表是静态查找表时，宜用顺序表作为其存储结构，而采用二分查找实现其查找操作；若有序表是动态查找表，则应选择二叉排序树作为其逻辑结构。

1、基本定义

图（Graph）G 由两个集合 V 和 E 组成，记为 G = ( V, E )，其中 V 是顶点的有穷非空集合，E 是 V 中顶点偶对的有穷集合，这些顶点偶对称为边。V(G )和 E(G) 通常分别表示图 G 的顶点集合和边集合，E(G) 可以为空集。若 E(G) 为空，则图 G 只有顶点而没有边。

对于图 G，若边集 E(G) 为有向边的集合，则称该图为有向图；若边集 E(G) 为无向边的集合，则称该图为无向图。

2、相关术语

数据结构中图的相关术语与离散数学中的基本相同，这里不再赘述。

二、图的存储结构

1、邻接矩阵

邻接矩阵（Adjacency Matrix）是表示顶点之间相邻关系的矩阵。设 G(V, E) 是具有 n 个顶点的图，则 G 的邻接矩阵是具有如下性质的 n 阶方阵：

例如本文第一张图中的 G1 和 G2 的邻接矩阵如下所示：

对于带权图来说，若顶点 vi 和 vj 之间有边相连，则邻接矩阵中对应项存放着该边对应的权值，若顶点 Vi 和 Vj 不相连，则用 ∞ 来代表这两个顶点之间不存在边：

其中，Wij表示边上的权值；∞ 表示计算机允许的、大于所有边上权值的数。例如，下图为一个有向网和它的邻接矩阵：

用邻接矩阵表示法表示图，除了一-个用于存储邻接矩阵的二维数组外,还需要用一个一维数组来存储顶点信息。其形式说明如下：

1
2
3
4
5
6
7
8
9
10
11
12

#define MAXINT 0x7FFF // 表示极大值
#define MVNum 100 // 最大顶点数

typedef char VerTexType; // 假设顶点的数据类型为字符型
typedef int ArcType; // 假设边的权值类型为整型

typedef struct
{
    VerTexType vexs[MVNum]; // 顶点表
    ArcType arcs[]; // 邻接矩阵
    int vexnum, arcnum; // 图的当前点数和边数
}AMGraph;

2、邻接表

邻接表（Adjacency List）是图的一种链式存储结构。在邻接表中，对图中每个顶点 Vi 建立一个单链表，把与 Vi 相邻接的顶点放在这个链表中。邻接表中每个单链表的第一个结点存放有关顶点的信息，把这一结点看成链表的表头，其余结点存放有关边的信息，这样邻接表便由两部分组成：表头结点表和边表。

• 表头结点表：由所有表头结点以顺序结构的形式存储，以便可以随机访问任一顶点的边链表。表头结点包括数据域和链域两部分，如下图 (a) 所示。其中，数据域用于存储顶点 Vi 的名称或其他有关信息；链域用于指向链表中第-一个结点（即与顶点 V1 邻接的第一个邻接点）。

• 边表：由表示图中顶点间关系的 2n 个边链表组成。边链表中边结点包括邻接点域、数据域和链域三部分，如下图 (b) 所示。其中，邻接点域指示与顶点 Vi 邻接的点在图中的位置；数据域存储和边相关的信息，如权值等；链域指示与顶点 Vi 邻接的下一条边的结点。

例如，下图 (a) 和 (b) 所示分别为本文第一张图中 G1 和 G2 的邻接表。

图的邻接表存储结构说明如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#define MVNum 100 // 最大顶点数

// 边结点
typedef struct ArcNode
{
    int adjvex; // 该边所指向的顶点的位置
    struct ArcNode* nextarc; // 指向下一条边的指针
    // 其它相关信息
    ...
}ArcNode;

// 顶点信息
typedef struct VNode
{
    VerTexType data;
    ArcNode* firstarc; // 指向第一条依附该顶点的边的指针
}VNode, AdjList[MVNum]; // AdjList 表示邻接表类型

// 邻接表
typedef struct
{
    AdjList vertices;
    int vexnum, arcnum; // 图的当前顶点数和边数
}ALGraph;

三、图的遍历

1、深度优先搜索

（1）简介

深度优先搜索（Depth First Search, DFS）遍历类似于树的先序遍历，是树的先序遍历的推广。对于一个连通图，深度优先搜索遍历的过程如下：

• 从图中某个顶点 v 出发，访问 v。

• 找出刚访问过的顶点的第一个未被访问的邻接点，访问该顶点。以该顶点为新顶点，重复此步骤，直至刚访问过的顶点没有未被访问的邻接点为止。

• 返回前一个访问过的且仍有未被访问的邻接点的顶点，找出该顶点的下一个未被访问的邻接点，访问该顶点。

• 重复步骤 (2) 和 (3)，直至图中所有顶点都被访问过，搜索结束。

以下图 (a) 中所示的无向图 G4 为例，深度优先搜索遍历图的过程如下图 (b) 所示，具体过程如下：

• 从顶点 v1 出发，访问 v1。

• 在访问了顶点 v1 之后，选择第一个未被访问的邻接点 v2，访问 v2。以 v2 为新顶点，重复此步，访问 v4、v8、v5。 在访问了 v5 之后，由于 v5 的邻接点都已被访问，此步结束。

• 搜索从 v5 回到 v8，由于同样的理由，搜索继续回到 v4，v2 直至 v1，此时由于 v1 的另一个邻接点未被访问，则搜索又从 v1 到 v3，再继续进行下去。由此，得到的顶点访向序列为：
  $$
  v_1 \to v_2 \to v_4 \to v_8 \to v_5 \to v_3 \to v_6 \to v_7
  $$

（2）算法实现

深度优先搜索可以通过递归进行实现，算法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13