算法红皮书(第四版) on 随记

算法红皮书 3.2.1

Sun, 12 Jun 2022 22:09:27 +0000

二叉查找树#

使用每个结点含有两个链接（链表中每个结点只含有一个链接）的二叉查找树来高效地实现符号表
该数据结构由结点组成，结点包含的链接可以为空(null)或者指向其他结点
一棵二叉查找树（BST）是一棵二叉树，其中每个结点都含有一个Comparable 的键（以及相关联的值）且每个结点的键都大于其左子树中的任意结点的键而小于右子树的任意结点的键。

基本实现#

数据表示
- 每个结点都含有一个键、一个值、一条左链接、一条右链接和一个结点计数器左链接指向一棵由小于该结点的所有键组成的二叉查找树，右链接指向一棵由大于该节点的所有键组成的二叉查找树，变量N给出了以该结点为根的子树的结点总数
- 对于任意节点总是成立 size(x)=size(x.left)+size(x.right)+1
多棵二叉查找树表示同一组有序的键来实现构建和使用二叉查找树的高校算法
查找
- 在符号表中查找一个键可能得到两种结果：如果含有该键的结点存在表中，我们的查找就命中了，然后返回值；否则查找未命中（返回null)
- 递归：如果树是空的，则查找未命中；如果被查找的键和根节点的键相等，查找命中，否则在适当的子树中查找：如果被查找的键较小就选择左子树，否则选择右子树
- 下面的get()方法，第一个参数是一个结点（子树根节点），第二个参数是被查找的键，代码会保证只有该结点所表示的子树才会含有和被查找的键相等的结点
- 从根结点开始，在每个结点中查找的进程都会递归地在它的一个子结点上展开，因此一次查找也就定义了树的一条路径。对于命中的查找，路径在含有被查找的键的结点处结束。对于未命中的查找，路径的终点是一个空链接

基于二叉查找树的符号表

public class BST<Key extends Comparable<Key>, Value>
{
	private Node root;
	// 二叉查找树的根结点
	private class Node
	{
		private Key key;
		// 键
		private Value val;
		// 值
		private Node left, right;
		// 指向子树的链接
		private int N;
		// 以该结点为根的子树中的结点总数
		public Node(Key key, Value val, int N)
		{
			this.key = key;
			this.val = val;
			this.N = N;
		}
	}
	public int size()
	{
		return size(root);
	}
	private int size(Node x)
	{
		if (x == null) return 0; else return x.N;
	}
	public Value get(Key key)
	// 请见算法3.3（续1）
	public void put(Key key, Value val)
	// 请见算法3.3（续1）
	// max()、min()、floor()、ceiling()方法请见算法3.3（续2）
	// select()、rank()方法请见算法3.3（续3）
	// delete()、deleteMin()、deleteMax()方法请见算法3.3（续4）
	// keys()方法请见算法3.3（续5）
}

每个Node 对象都是一棵含有N 个结点的子树的根结点，它的左链接指向一棵由小于该结点的所有键组成的二叉查找树，右链接指向一棵由大于该结点的所有键组成的二叉查找树。root 变量指向二叉查找树的根结点Node 对象（这棵树包含了符号表中的所有键值对）

二叉查找树的查找和排序方法的实现

算法红皮书 3.1.1-3.1.7

Tue, 31 May 2022 23:52:57 +0000

查找#

经典查找算法
用符号表这个词来描述抽象的表格，将信息（值）存储在其中，然后按照指定的键来获取这些信息
符号表也被称为字典
- 在英语字典里，键就是单词，值就是单词对应的定义、发音和词源
- 符号表有时又叫索引
- 在一本书的索引中，键就是术语，而值就是书中该术语出现的所有页码
下面学习三种经典的数据类型：二叉查找树、红黑树和散列表

符号表#

符号表最主要的目的是将键和值联系起来
用例能够将一个键值对插入符号表并希望在之后能够从符号表的所有键值对中按照键直接找到相对应的值
符号表是一种存储键值对的数据结构，支持两种操作：插入(put)，即将一组新的键值对存入表中；查找(get)，即根据给定的键得到相应的值
典型的符号表应用

API#

符号表是一种典型的数据类型 ：代表着一组定义清晰的值及相应的操作。使用应用程序编程接口（API）来精确地定义这些操作一种简单的泛型符号表API ST(Symbol Table)
泛型对于符号表，我们通过明确地指定查找时键和值的类型来区分它们的不同角色【key和value】
重复的键
- 这里假设每个键只对应着一个值（表中不允许重复值）
- 当用例代码向表中存入的键值对和表中已有的键（及关联的值）冲突时，新的值会替代旧的值
- 上述定义了关联数组的抽象形式，可以将符号表想象成数组，键即索引，值即数组中的值
- 在一个关联数组中，键可以是任意类型，但我们仍然可以用它来快速访问数组的值
- 非Java使用st[key]来替代st.get(key)，用st[key]=val来替代st.put(key,val)
键不能为空
值不能为空（因为规定当键不存在时get()返回空）当值为空表示删除
删除操作
- 延时删除，先将键对应的值置空，之后在某个时刻删除所有值为空的键
- 即时删除，立即从表中删除指定的键 put实现的开头：
```
if(val == null){
 delete(key);
 return;
}
```
- 便捷方法
- 迭代在API第一行加上implements Iterable<Key> ，所有实现都包含iterator()方法来实现hasNext()和next()方法的迭代器；这里采用另一种方式：定义keys返回一个Iterable<Key>对象以方便便利所有的键，且允许遍历一部分
- 键的等价性自定义的键需要重写equals()方法；且最好使用不可变数据类型作为键

有序符号表#

一种有序的泛型符号表的API
最大值和最小值、向下取整和向上取整、排名和选择
对于0到size()-1的所有i都有i==rank(select(i))，且所有的键都满足key == select(rank(key))
范围查找
例外情况当一个方法需要返回一个键但表中没有合适的键可以返回时，我们约定抛出一个异常
有序符号表中冗余有序性方法的默认实现
所有Comparable类型中compareTo()方法和equals()方法的一致性
★★成本模型在学习符号表的实现时，我们会统计比较的次数（等价性测试或是键的相互比较），在内循环**不进行比较（极少）**的情况下，我们会统计数组的访问次数

用例举例#

如何使用

行为测试用例简单的符号表测试用例

算法红皮书 2.5

Sun, 29 May 2022 22:20:39 +0000

排序如此有用的原因是，在有序的数组中查找一个元素，要比在一个无序的数组中查找简单得多
通用排序算法是最重要的
算法思想虽然简单，但是适用领域广泛

将各种数据排序#

Java的约定使得我们能够利用Java的回调机制将任意实现Comparable接口的数据类型排序
- 我们的代码直接能够将String、Integer、Double 和一些其他例如File 和URL 类型的数组排序，因为它们都实现了Comparable 接口
交易事务商业数据的处理，设想一家互联网商业公司为每笔交易记录都保存了所有的相关信息
```
public int compareTo(Transaction that)
{
	return this.when.compareTo(that.when);
}
```
指针排序我们使用的方法在经典教材中被称为指针排序，因为我们只处理元素的引用而不移动数据本身
不可变的键用不可变的数据类型作为键，比如String、Integer、Double和File等
廉价的交换
- 使用引用的另一个好处是不必移动整个元素对于几乎任意大小的元素，使用引用使得在一般情况下交换的成本和比较的成本几乎相同（代价是需要额外的空间存储这些引用）
- 研究将数字排序的算法性能的一种方法就是观察其所需的比较和交换总数，因为这里隐式地假设了比较和交换的成本是相同的
多种排序方法
- 根据情况将一组对象按照不同的方式排序。Java 的Comparator 接口允许我们在一个类之中实现多种排序方法

多键数组

一个元素的多种属性都可能被用作排序的键
- 我们可以定义多种比较器，要将Transaction 对象的数组按照时间排序可以调用： Insertion.sort(a, new Transaction.WhenOrder()) 或者这样来按照金额排序： Insertion.sort(a, new Transaction.HowMuchOrder())

使用Comparator的插入排序

public static void sort(Object[] a, Comparator c)
{
	int N = a.length;
	for (int i = 1; i < N; i++)
	for (int j = i; j > 0 && less(Comparator, a[j], a[j-1]); j--)
	exch(a, j, j-1);
}
private static Boolean less(Comparator c, Object v, Object w)
{
	return c.compare(v, w) < 0;
}
private static void exch(Object[] a, int i, int j)
{
	Object t = a[i];
	a[i] = a[j];
	a[j] = t;
}

使用比较器实现优先队列

算法红皮书 2.4

Fri, 27 May 2022 22:43:00 +0000

优先队列#

有些情况下，不需要要求处理的元素全部有序，只要求每次都处理键值最大的元素，然后再收集更多的元素，然后再处理键值最大的元素
需要一种数据结构，支持操作：删除最大元素和插入元素，这种数据类型叫做优先队列
优先队列的基本表现形式：其一或两种操作都能在线性时间内完成
基于二叉堆数据结构的优先队列，用数组保存元素并按照一定条件排序，以实现高效的删除最大元素和插入元素

API#

抽象数据类型，最重要的操作是删除最大元素和插入元素 delMax()和insert()
用“最大元素”代替“最大键值”或是“键值最大的元素”
泛型优先队列的API

优先队列的调用示例从N各输入中找到最大的M各元素所需成本

优先队列的用例 pq里面最多放5个，当大于5个的时候，就从中剔除1个

public class TopM
{
	public static void main(String[] args)
	{
		// 打印输入流中最大的M行
		int M = Integer.parseint(args[0]);
		MinPQ<Transaction> pq = new MinPQ<Transaction>(M+1);
		while (StdIn.hasNextLine())
		{
			// 为下一行输入创建一个元素并放入优先队列中
			pq.insert(new Transaction(StdIn.readLine()));
			if (pq.size() > M)
			 pq.delMin();
			// 如果优先队列中存在M+1个元素则删除其中最小的元素
		}
		// 最大的M个元素都在优先队列中
		Stack<Transaction> stack = new Stack<Transaction>();
		while (!pq.isEmpty()) stack.push(pq.delMin());
		for (Transaction t : stack) StdOut.println(t);
	}
}

应用

初级实现#

数组实现（无序） insert元素和栈的push()方法完全一样；要删除最大元素，可以添加一段类似选择排序的内循环的代码，将最大元素的边界元素交换，然后删除
数组实现（有序） insert()方法时，始终将较大的元素，向右边移动一格以使数组有序；删除最大元素就是pop()
链表表示法
可以用基于链表的下压栈的代码作为基础，而后可以选择修改pop() 来找到并返回最大元素，或是修改push() 来保证所有元素为逆序并用pop() 来删除并返回链表的首元素(也就是最大的元素)
优先队列的各种实现在最坏情况下运行时间的增长数量级
在一个优先队列上执行的一系列操作如表2.4.4所示

堆的定义#

当一棵二叉树的每个节点都大于等于他的两个子结点时，它被称为堆有序

算法红皮书 2.1.2-2.1.3

Sat, 23 Apr 2022 15:54:21 +0000

排序#

初级排序算法#

选择排序#

命题A。对于长度为N 的数组，选择排序需要大约 N^2/2 次比较和N 次交换。

代码

public class Selection
{
	public static void sort(Comparable[] a)
	{
		// 将a[]按升序排列
		int N = a.length;
		// 数组长度
		for (int i = 0; i < N; i++)
		{
			// 将a[i]和a[i+1..N]中最小的元素交换
			int min = i;
			// 最小元素的索引
			for (int j = i+1; j < N; j++)
			if (less(a[j], a[min])) min = j;
			exch(a, i, min);
		}
	}
	// less()、exch()、isSorted()和main()方法见“排序算法类模板”
}

特点
- 运行时间与输入无关，即输入数据的初始状态（比如是否已排序好等等）不影响排序时间
- 数据移动是最少的（只使用了N次交换，交换次数和数组的大小是线性关系

插入排序#

命题B。对于随机排列的长度为N 且主键不重复的数组，平均情况下插入排序需要～ N^{2/4 次比较以及～ N}2/4 次交换。最坏情况下需要～ N^{2/2 次比较和～ N}2/2 次交换，最好情况下需要N-1次比较和0 次交换。

算法红皮书 2.1.1

Wed, 13 Apr 2022 22:43:21 +0000

排序#

排序就是将一组对象按照某种逻辑顺序重新排序的过程

对排序算法的分析有助于理解本书中比较算法性能的方法
类似技术能解决其他类型问题
排序算法常常是我们解决其他问题的第一步

初级排序算法#

熟悉术语及技巧
某些情况下初级算法更有效
有助于改进复杂算法的效率

游戏规则#

主要关注重新排序数组元素的算法，每个元素都会有一个主键
排序后索引较大的主键大于索引较小的主键
一般情况下排序算法通过两个方法操作数据，less()进行比较，exch()进行交换

排序算法类的模板

public class Example
{
	public static void sort(Comparable[] a)
	{
		/* 请见算法2.1、算法2.2、算法2.3、算法2.4、算法2.5或算法2.7*/
	}
	private static Boolean less(Comparable v, Comparable w)
	{
		return v.compareTo(w) < 0;
	}
	private static void exch(Comparable[] a, int i, int j)
	{
		Comparable t = a[i];
		a[i] = a[j];
		a[j] = t;
	}
	private static void show(Comparable[] a)
	{
		// 在单行中打印数组
		for (int i = 0; i < a.length; i++)
		StdOut.print(a[i] + " ");
		StdOut.println();
	}
	public static Boolean isSorted(Comparable[] a)
	{
		// 测试数组元素是否有序
		for (int i = 1; i < a.length; i++)
		if (less(a[i], a[i-1])) return false;
		return true;
	}
	public static void main(String[]
	args)
	{
		// 从标准输入读取字符串，将它们排序并输出
		String[] a = In.readStrings();
		sort(a);
		assert isSorted(a);
		show(a);
	}
}

使用

算法红皮书 1.5.1-1.5.3

Sat, 09 Apr 2022 08:01:47 +0000

案例研究：union-find 算法#

设计和分析算法的基本方法
- 优秀的算法能解决实际问题
- 高效的算法也可以很简单
- 理解某个实现的性能特点是一项有趣的挑战
- 在解决同一个问题的多种算法间选择，科学方法是一种重要工具
- 迭代式改进能让算法效率越来越高

动态连通性#

从输入中读取整数对p q，如果已知的所有整数对都不能说明p,q相连，就打印出pq
网络：整个程序能够判定是否需要在pq之间架设一条新的连接才能进行通信
变量名等价性（即指向同一个对象的多个引用）
数学集合：在处理一个整数对pq时，我们是在判断它们是否属于相同的集合
本节中，将对象称为触点，整数对称为连接，等价类称为连通分量或是简称分量
连通性问题只要求我们的程序能够判别给定的整数对pq是否相连，并没有要求给两者之间的通路上的所有连接
union-find算法的API
数据结构和算法的设计影响到算法的效率

实现#

public class UF
{
	private int[]	id;
	/* 分量id（以触点作为索引） */
	private int	count;
	/* 分量数量 */
	public UF( int N )
		{
		/* 初始化分量id数组 */
		count	= N;
		id	= new int[N];
		for ( int i = 0; i < N; i++ )
					id[i] = i;
	}
	public int count()
		{
		return(count);
	}
	public Boolean connected( int p, int q )
		{
		return(find( p ) == find( q ) );
	}
	public int find( int p )
		public void union( int p, int q )
	/* 请见1.5.2.1节用例（quick-find）、1.5.2.3节用例（quick-union）和算法1.5（加权quick-union） */
	public static void main( String[] args )
		{
		/* 解决由StdIn得到的动态连通性问题 */
		int	N	= StdIn.readint();
		/* 读取触点数量 */
		UF	uf	= new UF( N );
		/* 初始化N个分量 */
		while ( !StdIn.isEmpty() )
				{
			int	p	= StdIn.readint();
			int	q	= StdIn.readint();
			/* 读取整数对 */
			if ( uf.connected( p, q ) )
							continue;
			/* 如果已经连通则忽略 */
			uf.union( p, q );
			/* 归并分量 */
			StdOut.println( p + " " + q );
			/* 打印连接 */
		}
		StdOut.println( uf.count() + "components" );
	}
}

union-find的成本模型：union-find API的各种算法，统计的是数组的访问次数，不论读写

算法红皮书 1.4.1-1.4.10

Thu, 07 Apr 2022 11:00:21 +0000

算法分析#

使用数学分析为算法成本建立简洁的模型，并使用实验数据验证这些模型

科学方法#

观察、假设、预测、观察并核实预测、反复确认预测和观察
原则：实验可重现

观察#

计算性任务的困难程度可以用问题的规模来衡量
问题规模可以是输入的大小或某个命令行参数的值
研究问题规模和运行时间的关系

使用计时器得到大概的运行时间

典型用例

public static void main(String[] args) {
 int N = Integer.parseInt(args[0]);
 int[] a = new int[N];
 for (int i = 0; i < N; i++)
 a[i] = StdRandom.uniform(-1000000, 1000000);
 Stopwatch timer = new Stopwatch();
 int cnt = ThreeSum.count(a);
 double time = timer.elapsedTime();
 StdOut.println(cnt + " triples " + time + " seconds");
 }

使用方法

数据类型的实现

public class Stopwatch {
 private final long start;

 public Stopwatch() {
 start = System.currentTimeMillis();
 }

 public double elapsedTime() {
 long now = System.currentTimeMillis();

 return (now - start) / 1000.0;
 }
}

数学模型#

程序运行的总时间主要和两点有关：执行每条语句的耗时；执行每条语句的频率

算法红皮书1.3.3.1-1.3.4

Wed, 06 Apr 2022 23:00:44 +0000

背包、队列和栈#

链表#

链表是一种递归的数据结构，它或者为空(null)，或者是一个指向一个结点（node）的引用，该节点含有一个泛型的元素和一个指向另一条链表的引用。

结点记录#

使用嵌套类定义结点的抽象数据类型
```
private class Node
{
	Item item;
	Node next;
}
```
- 该类没有其它任何方法，且会在代码中直接引用实例变量，这种类型的变量称为记录

构造链表#

需要一个Node类型的变量，保证它的值是null或者指向另一个Node对象的next域指向了另一个链表
如下图
链表表示的是一列元素
链式结构在本书中的可视化表示长方形表示对象；实例变量的值写在长方形中；用指向被引用对象的箭头表示引用关系
术语链接表示对结点的引用

在表头插入结点#

在首结点为first 的给定链表开头插入字符串not，我们先将first 保存在oldfirst 中，然后将一个新结点赋予first，并将它的item 域设为not，next 域设为oldfirst
时间复杂度为O(1)
如图

从表头删除结点#

将first指向first.next
原先的结点称为孤儿，Java的内存管理系统最终将回收它所占用的内存
如图

在表尾插入结点#

每个修改链表的操作都需要增加检查是否要修改该变量（以及做出相应修改）的代码
例如，当删除链表首结点时可能改变指向链表的尾结点的引用，因为链表中只有一个结点时它既是首结点又是尾结点
如图

其他位置的插入和删除操作#

删除指定结点；在指定节点插入新结点

需要将链表尾结点的前一个节点中的链接（它指向的是last）值改为null
为了找到指向last的结点，需要遍历链表，时间复杂度为O(n)
实现任意插入和删除操作的标准解决方案是双向链表

遍历#

将x初始化为链表首结点，然后通过x.item访问和x相关联的元素，并将x设为x.next来访问链表中的下一个结点，知道x=null(没有下一个结点了，到达链表结尾)
```
for (Node x = first; x != null; x = x.next)
{
// 处理x.item
}
```

栈的实现#

使用链表实现栈
将栈保存为一条链表，栈的顶部即为表头，实例变量first 指向栈顶。这样，当使用push() 压入一个元素时，我们会按照1.3.3.3 节所讨论的代码将该元素添加在表头；当使用pop() 删除一个元素时，我们会按照1.3.3.4 节讨论的代码将该元素从表头删除。要实现size() 方法，我们用实例变量N 保存元素的个数，在压入元素时将N 加1，在弹出元素时将N 减1。要实现isEmpty() 方法，只需检查first 是否为null（或者可以检查N 是否为0）

算法红皮书 1.3.1.1-1.3.2.5

Tue, 22 Mar 2022 13:51:26 +0000

背包、队列和栈#

数据类型的值就是一组对象的集合，所有操作都是关于添加、删除或是访问集合中的对象
本章将学习三种数据类型：背包Bag、队列Queue、栈Stack
- 对集合中的对象的表示方式直接影响各种操作的效率
- 介绍泛型和迭代
- 介绍并说明链式数据结构的重要性(链表)

API#

泛型可迭代的基础集合数据类型的API
- 背包
- 队列(先进先出FIFO)
- 下压(后进先出,LIFO)栈
泛型
- 泛型，参数化类型
- 在每份API 中，类名后的<Item> 记号将Item 定义为一个类型参数，它是一个象征性的占位符，表示的是用例将会使用的某种具体数据类型
自动装箱
- 用来处理原始类型
- Boolean、Byte、Character、Double、Float、Integer、Long 和Short 分别对应着boolean、byte、char、double、float、int、long 和short
- 自动将一个原始数据类型转换为一个封装类型称为自动装箱，自动将一个封装类型转换为一个原始数据类型被称为自动拆箱
可迭代的集合类型
- 迭代访问集合中的所有元素
背包是一种不支持从中删除元素的集合数据类型–帮助用例收集元素并迭代遍历所有收集到的元素（无序遍历）
- 典型用例，计算标准差
先进先出队列
- 是一种基于先进先出(FIFO)策略的集合类型
- 使用队列的主要原因：集合保存元素的同时保存它们的相对顺序
- 如图
- Queue用例(先进先出)
下压栈
- 简称栈，是一种基于后进先出LIFO策略的集合类型
- 比如，收邮件等，如图
- Stack的用例
用栈解决算数表达式的问题
（双栈算数表达式求值算法）

集合类数据类型的实现#

定容栈，表示容量固定的字符串栈的抽象数据类型
- 只能处理String值，支持push和pop
- 抽象数据类型
- 测试用例
- 使用方法
- 数据类型的实现
泛型
- public class FixedCapacityStack<Item>
- 由于不允许直接创建泛型数组，所以 ~~a =new Item[cap]~~ 不允许，应该改为
  a=(Item[])new Object[cap];
- 泛型定容栈的抽象数据类型
- 测试用例
- 使用方法
- 数据类型的实现
调整数组大小

算法红皮书 1.2.1-1.2.5

Tue, 22 Feb 2022 13:49:50 +0000

数据抽象#

数据类型指的是一组值和一组对这些值的操作的集合

定义和使用数据类型的过程，也被称为数据抽象
Java编程的基础是使用class关键字构造被称为引用类型的数据类型，也称面向对象编程
定义自己的数据类型来抽象任意对象
抽象数据类型（ADT）是一种能够对使用者隐藏数据表示的数据类型
抽象数据类型将数据和函数的实现相关联，将数据的表示方式隐藏起来
抽象数据类型使用时，关注API描述的操作上而不会去关心数据的表示；实现抽象数据类型时，关注数据本身并将实现对数据的各种操作
研究同一个问题的不同算法的主要原因是他们的性能不同

使用抽象数据类型#

使用一种数据类型并不一定非得知道它是如何实现的
使用Counter(计数器)的简单数据类型的程序，操作有
- 创建对象并初始化为0
- 当前值加1
- 获取当前值
场景，用于电子计票
抽象数据类型的API(应用程序编程接口)
- API用来说明抽象数据类型的行为
- 将列出所有构造函数和实例方法(即操作)
计算器的API
继承的方法
- 所有数据类型都会继承toString()方法
- Java会在用+运算符将任意数据类型的值和String值连接时调用toString()
- 默认实现：返回该数据类型值的内存地址
用例代码
- 可以在用例代码中，声明变量、创建对象来保存数据类型的值并允许通过实例方法来操作它们
对象
- 对象是能够承载数据类型的值的实体
- 对象三大特性：状态、标识和行为
  - 状态：数据类型中的值
  - 标识：在内存中的地址
  - 行为：数据类型的操作
- Java使用"引用类型"和原始数据类型区别
创建对象
- 每种数据类型中的值都存储于一个对象中
- 构造函数总是返回他的数据类型的对象的引用
- 使用new()，会为新的对象分配内存空间，调用构造函数初始化对象中的值，返回该对象的一个引用
抽象数据类型向用例隐藏了值的表示细节
实例方法：参数按值传递
方法每次触发都和一个对象相关
静态方法的主要作用是实现函数；非静态(实例)方法的主要作用是实现数据类型的操作
使用对象
开发某种数据类型的用例
- 声明该类型的变量，以引用对象
- 使用new触发能够创建该类型的对象的一个构造函数
- 使用变量名调用实例方法
赋值语句(对象赋值)
- 别名：两个变量同时指向同一个对象
将对象作为参数
- Java将参数值的一个副本从调用端传递给了方法，这种方式称为按值传递
- 当使用引用类型作为参数时我们创建的都是别名，这种约定会传递引用的值(复制引用)，也就是传递对象的引用
- 虽然无法改变原始的引用(将原变量指向另一个Counter对象)，但能够改变该对象的值
将对象作为返回值
- 由于Java只由一个返回值，有了对象实际上就能返回多个值
数组也是对象
- 将数组传递给一个方法或是将一个数组变量放在赋值语句的右侧时，我们都是在创建数组引用的一个副本，而非数组的副本
对象的数组
创建一个对象的数组
- 使用方括号语法调用数组的构造函数创建数组
- 对于每个数组元素调用它的构造函数创建相应的对象
  如下图
运用数据抽象的思想编写代码(定义和使用数据类型，将数据类型的值封装在对象中)的方式称为面向对象编程
总结
- 数据类型指的是一组值和一组对值的操作的集合
- 我们会在数据类型的Java类中编写用理
- 对象是能够存储任意该数据类型的值的实体
- 对象有三个关键性质：状态、标识和行为

抽象数据类型举例#

本书中将会用到或开发的所有数据类型
- java.lang.*
- Java标准库中的抽象数据类型，需要import，比如java.io、java.net等
- I/O处理嘞抽象数据类型,StdIn和StdOut
- 面向数据类抽象数据类型，计算机和和信息处理
- 集合类抽象数据类型，主要是为了简化对同一类型的一组数据的操作，包括Bag、Stack和Queue，PQ(优先队列)、ST(符号表)、SET(集合)
- 面向操作的抽象数据类型(用来分析各种算法)
- 图算法相关的抽象数据类型，用来封装各种图的表示的面向数据的抽象数据类型，和一些提供图的处理算法的面向操作的抽象数据类型
几何对象(画图(图形)的)[跳过]
信息处理
- 抽象数据类型是组织信息的一种自然方式
- 定义和真实世界中的物体相对应的对象
字符串
- java的String
- 一个String值是一串可以由索引访问的char值
- 有了String类型可以写出清晰干净的用例代码而无需关心字符串的表示方式

抽象数据类型的实现#

使用Java的类(class)实现抽象数据类型并将所有代码放入一个和类名相同并带有.java扩展名的文件
如下图
实例变量
用来定义数据类型的值(每个对象的状态)
构造函数
- 每个Java类都至少有一个构造函数以创建一个对象的标识
- 每个构造函数将创建一个对象并向调用者返回一个该对象的引用
实例方法
- 如图
作用域
- 参数变量、局部变量、实例变量
- 范围(如图)
API、用例与实现
- 我们要学习的每个抽象数据类型的实现，都会是一个含有若干私有实例变量、构造函数、实例方法和一个测试用例的Java类
- 用例和实现分离(一般将用例独立成含有静态方法main()的类)
- 做法如下
  - 定义一份API，APi的作用是将使用和实现分离，以实现模块化编程
  - 用一个Java类实现API的定义
  - 实现多个测试用例来验证前两步做出的设计决定
- 例子如下
  - API
  - 典型用例
  - 数据类型的实现
  - 使用方法(执行程序)

数据类型的设计#

抽象数据类型是一种向用例隐藏内部表示的数据类型
- 封装(数据封装)
- 设计APi
算法与抽象数据类型
- 能够准确地说明一个算法的目的及其他程序应该如何使用该算法
- 每个Java程序都是一组静态方法和(或)一种数据类型的实现的集合
本书中关注的是抽象数据类型的实现中的操作和向用例隐藏其中的数据表示
例子，将二分法封装
- API
- 典型的用例
- 数据类型的实现
接口继承
- Java语言为定义对象之间的关系提供了支持，称为接口
- 接口继承使得我们的程序能够通过调用接口中的方法操作实现该接口的任意类型的对象
本书中使用到的接口
继承
- 由Object类继承得到的方法
- 继承toString()并自定义
- 封装类型(内置的引用类型，包括Boolean、Byte、Character、Double、Float、Integer、Long和Short)
等价性
- 如图
- 例子，在Date中重写equals
内存管理
Java具有自动内存管理，通过记录孤儿对象并将它们的内存释放到内存池中
不可变性
使用final保证数据不可变
使用final修饰的引用类型，不能再引用(指向)其他对象，但对象本身的值可改变
契约式设计
- Java语言能够在程序运行时检测程序状态
- 异常(Exception)+断言(Assertion)
异常与错误
允许抛出异常或抛出错误
断言
程序不应该依赖断言

End#

算法红皮书 1.1.6-1.1.11

Tue, 22 Feb 2022 09:55:11 +0000

基础编程模型#

静态方法#

本书中所有的Java程序要么是数据类型的定义，要么是一个静态方法库
当讨论静态方法和实体方法共有的属性时，我们会使用不加定语的方法一词
方法需要参数(某种数据类型的值)并根据参数计算出某种数据类型的返回值(例如数学函数的结果)或者产生某种副作用(例如打印一个值)
静态方法由签名(public static 以及函数的返回值,方法名及一串参数)和函数体组成
调用静态方法(写出方法名并在后面的括号中列出数值)
方法的性质
- 方法的参数按值传递，方法中使用的参数变量能够引用调用者的参数并改变其内容(只是不能改变原数组变量本身)
- 方法名可以被重载
- 方法只能返回一个值，但能包含多个返回语句
- 方法可以产生副作用
递归：方法可以调用自己可以使用数学归纳法证明所解释算法的正确性,编写递归重要的三点
- 递归总有一个最简单的情况(方法第一条总包含return的条件语句)
- 递归调用总是去尝试解决一个规模更小的子问题
- 递归调用的父问题和尝试解决的子问题之间不应该由交集如下图中，两个子问题各自操作的数组部分是不同的
基础编程模型
- 静态方法库是定义在一个Java类中的一组静态方法
- Java开发的基本模式是编写一个静态方法库(包含一个main()方法)类完成一个任务
- 在本书中，当我们提到用于执行一项人物的Java程序时，我们指的就是用这种模式开发的代码(还包括对数据类型的定义)
模块化编程
- 通过静态方法库实现了模块化编程
- 一个库中的静态方法也能够调用另一个库中定义的静态方法
单元测试
- Java编程最佳实践之一就是每个静态方法库中都包含一个main()函数来测试库中所有的方法
- 本书中使用main()来说明模块的功能并将测试用例留作练习
外部库
- 系统标准库 java.lang.*:包括Math库;String和StringBuilder库
- 导入的系统库 java.util.Arrays
- 本书中其他库
- 本书使用了作者开发的标准库Std*

API#

模块化编程重要组成部分，记录库方法的用法并供其他人参考的文档
会统一使用应用程序编程接口API的方法列出每个库方法、签名及简述
用例(调用另一个库中的方法的程序)，实现(实现了某个API方法的Java代码)
作者自己的两个库，一个扩展Math.random(),一个支持各种统计
- 随机静态方法库(StdRandom)的API
- 数据分析方法库(StdStats)的API
- StdRandom库中的静态方法的实现
编写自己的库
- 编写用例，实现中将计算过程分解
- 明确静态方法库和与之对应的API
- 实现API和一个能够对方法进行独立测试的main()函数
- API的目的是将调用和实现分离

字符串#

字符串拼接，使用 +
类型转换(将用户从键盘输入的内容转换成相应数据类型的值以及将各种数据类型的值转换成能够在屏幕上显示的值)
如果数字跟在+后面，那么会将数据类型的值自动转换为字符串
命令行参数
- Java中字符串的存在，使程序能够接收到从命令行传递来的信息
- 当输入命令java和一个库名及一系列字符串后，Java系统会调用库的main()方法并将后面的一系列字符串变成一个数组作为参数传递给它

输入输出#

Java程序可以从命令行参数或者一个名为标准输入流的抽象字符流中获得输入，并将输出写入另一个名为标准输出流的字符流中
默认情况下，命令行参数、标准输入和标准输出是和应用程序绑定的，而应用程序是由能够接受命令输入的操作系统或是开发环境所支持
使用终端来指代这个应用程序提供的供输入和显示的窗口,如图
命令和参数
- 终端窗口包含一个提示符，通过它我们能够向操作系统输入命令和参数
- 操作系统常用命令
标准输出
- StdOut库的作用是支持标准输出
- 标准输出库的静态方法的API
- 格式化输出字符%并紧跟一个字符表示的转换代码(包括d,f和s)。%和转换代码之间可以插入证书表示值的宽度，且转换后会在字符串左边添加空格以达到需要的宽度。负数表示空格从右边加
- 宽度后用小数点及数值可以指定精度(或String字符串所截取的长度)
- 格式中转换代码和对应参数的数据类型必须匹配
标准输入
- StdIn库从标准输入流中获取数据，然后将标准输出定向到终端窗口
- 标准输入流最重要的特点，这些值会在程序读取后消失
- 例子
- 标准输入库中的静态方法API
重定向和管道
- 将标准输出重定向到一个文件
```
java RandomSeq 1000 100.0 200.0 > data.txt
```
- 从文件而不是终端应用程序中读取数据
```
java Average < data.txt
```
- 将一个程序的输出重定向为另一个程序的输入，叫做管道
```
java RandomSeq 1000 100.0 200.0 | java Average
```
  - 突破了我们能够处理的输入输出流的长度限制
  - 即使计算机没有足够的空间来存储十亿个数，
  - 我们仍然可以将例子中的1000 换成1 000 000 000 （当然我们还是需要一些时间来处理它们）。当RandomSeq 调用StdOut.println() 时，它就向输出流的末尾添加了一个字符串；当Average 调用StdIn.readInt() 时，它就从输入流的开头删除了一个字符串。这些动作发生的实际顺序取决于操作系统
- 命令行的重定向及管道
基于文件的输入输出
In和Out库提供了一些静态方法,来实现向文件中写入或从文件中读取一个原始数据类型的数组的抽象
用于读取和写入数组的静态方法的API
标准绘图库(基本方法和控制方法)–这里跳过

二分查找#

如图，在终端接收需要判断的数字，如果不存在于白名单(文件中的int数组)中则输出
开发用例以及使用测试文件(数组长度很大的白名单)
模拟实际情况来展示当前算法的必要性，比如
- 将客户的账号保存在一个文件中，我们称它为白名单；
- 从标准输入中得到每笔交易的账号；
- 使用这个测试用例在标准输出中打印所有与任何客户无关的账号，公司很可能拒绝此类交易。

使用顺序查找

public static int rank(int key, int[] a)
{
 for (int i = 0; i < a.length; i++)
 if (a[i] == key) return i;
 return -1;
}

当处理大量输入的时候，顺序查找的效率极其低

展望#

下一节，鼓励使用数据抽象，或称面向对象编程，而不是操作预定义的数据类型的静态方法
使用数据抽象的好处
- 复用性
- 链式数据结构比数组更灵活
- 可以准确地定义锁面对的算法问题

1.1 End#

算法红皮书 1.1.1-1.1.5

Mon, 21 Feb 2022 16:53:04 +0000

基础编程模型#

Java程序的基本结构#

本书学习算法的方法：用Java编程语言编写的程序来实现算法(相比用自然语言有很多优势)
劣势：编程语言特定，使算法的思想和实现细节变得困难(所以本书尽量使用大部分语言都必须的语法)
把描述和实现算法所用到的语言特性、软件库和操作系统特定总称为基础编程模型
Java程序的基本结构
- 一段Java程序或者是一个静态方法库，或者定义了一个数据类型，需要用到的语法
  - 原始数据类型(在计算机中精确地定义整数浮点数布尔值等)
  - 语句(创建变量并赋值，控制运行流程或引发副作用来进行计算，包括声明、赋值、条件、循环、调用和返回)
  - 数组(多个同种数据类型值的集合)
  - 静态方法(封装并重用代码)
  - 字符串(一连串的字符，内置一些对他们的操作)
  - 标准输入/输出(是程序与外界联系的桥梁)
  - 数据抽象(数据抽象封装和重用代码，可以定义非原始数据类型，进而面向对象编程)
- 把这种输入命令执行程序的环境称为虚拟终端
- 要执行一条Java程序，需要先用javac命令编译，然后用java命令运行，比如下面的文件，需要使用命令
```
javac BinarySearch.java
java BinarySearch 
```

原始数据类型与表达式#

数据类型就是一组数据和其所能进行的操作的集合
Java中最基础的数据类型(整型int，双精度实数类型double,布尔值boolean,字符型char)
Java程序控制用标识符命名的变量
对于原始类型，用标识符引用变量，+-*/指定操作，用字面量来表示值(如1或3.14),用表达式表示对值的操作( 表达式:(x+2.334)/2 )
只要能够指定值域和在此值域上的操作，就能定义一个数据类型(很像数学上函数的定义)
+-*/是被重载过的
运算产生的数据的数据类型和参与运算的数据的数据类型是相同的(5/3=1,5.0/3.0=1.6667等)
如下图(图歪了亿点点..)
表达式
表达式具有优先级，Java使用的是中缀表达式(一个字面量紧接运算符，然后是另一个字面量)。逻辑运算中优先级 ! && || ,运算符中 * / % 高于+ - 。括号能改变这些规则。代码中尽量使用括号消除对优先级的依赖
类型转换
- 数值会自动提升为高级数据类型，如1+2.5 1会被先转为double 1.0，值也为double的3.5
- 强转(把类型名放在括号里讲其转换为括号中的类型) 讲高级数据类型转为低级可能会导致精度的缺失，尽量少使用
比较
- ==、!=、<、<=、>、>=，这些运算符称为混合类型运算符，因为结果是布尔型而不是参与比较的数据类型
- 结果是布尔型的表达式称为布尔表达式
其他原始类型(int为32位，double为64位)
- long,64位整数
- short,16位整数
- char,16位字符
- byte,8位整数
- 32位单精度实数,float

语句#

语句用来创建和操作变量、对变量赋值并控制操作的执行流程
包括声明语句、赋值语句、条件语句、循环语句、调用和返回语句
声明：让一个变量名和一个类型在编译时关联起来
赋值：将(由一个表达式定义的)某个数据类型额值和一个变量关联起来

条件语句：

if (<boolean expression>) { <block statement> }

循环语句
```
while(<boolean expression>) { <block statement> }
```
其中循环语句中的代码段称为循环体
break与continue语句
- break，立即退出循环
- continue，立即开始下一轮循环

简便记法#

声明并初始化
隐式赋值
- ++i;–i
- i/=2;i+=1
单语句代码段(省略if/while代码段的花括号)

for语句

for(<initialize>;<boolean expression>;<increment>)
{
 <block statements>
}

这段代码等价于后面的

<initialize>;
while(<boolean expression>)
{
 <block statments>
 <increment>;
}

java语句总结

数组#

数组能够存储相同类型的多个数据
N个数组的数组编号为0至N-1；这种数组在Java中称为一维数组
创建并初始化数组
- 需要三个步骤，声明数组名字和类型，创建数组，初始化数组元素
- 声明并初始化一个数组
- 简化写法
  double[] a = new double[N];
- 使用数组(访问的索引小于0或者大于N-1时会抛出ArrayIndexOutOfBoundsException)
- 典型的数组处理代码
起别名
- 下面的情况并没有将数组新复制一份，而是a，b指向了同一个数组
二维数组
- Java中二维数组就是一堆数组的数组
- 二维数组可以是参差不齐，比如a[0]=new double[5],a[1]=new double[6]之类
- 二维数组的创建及初始化
```
double[][] a;
a = new double[M][N];
for (int i = 0; i < M; i++)
 for (int j = 0; j < N; j++)
 a[i][j] = 0.0;
```
- 精简后的代码 double[][] a=new double[M][N];

算法红皮书(第四版) on 随记

算法红皮书 3.2.1

二叉查找树#

基本实现#

算法红皮书 3.1.1-3.1.7

查找#

符号表#

API#

有序符号表#

用例举例#

算法红皮书 2.5

将各种数据排序#

算法红皮书 2.4

优先队列#

API#

初级实现#

堆的定义#

算法红皮书 2.1.2-2.1.3

排序#

初级排序算法#

选择排序#

插入排序#

算法红皮书 2.1.1

排序#

初级排序算法#

游戏规则#

算法红皮书 1.5.1-1.5.3

案例研究：union-find 算法#

动态连通性#

实现#

算法红皮书 1.4.1-1.4.10

算法分析#

科学方法#

观察#

数学模型#

算法红皮书1.3.3.1-1.3.4

背包、队列和栈#

链表#

结点记录#

构造链表#

在表头插入结点#

从表头删除结点#

在表尾插入结点#

其他位置的插入和删除操作#

遍历#

栈的实现#

算法红皮书 1.3.1.1-1.3.2.5

背包、队列和栈#

API#

集合类数据类型的实现#

算法红皮书 1.2.1-1.2.5

数据抽象#

使用抽象数据类型#

抽象数据类型举例#

抽象数据类型的实现#

更多抽象数据类型的实现#

数据类型的设计#

End#

算法红皮书 1.1.6-1.1.11

基础编程模型#

静态方法#

API#

字符串#

输入输出#

二分查找#

展望#

1.1 End#

算法红皮书 1.1.1-1.1.5

基础编程模型#

Java程序的基本结构#

原始数据类型与表达式#

语句#

简便记法#

数组#