习题答案
jimmysuncpt做的习题答案
国外做的习题答案
2022年1月1日
书本：15-24页
习题：递归1.1.16，17, 18，共3题；牛客NC115栈和排序
笔记：
程序简便记法
1）声明语句和赋值语句结合起来，如int i=1；
2）隐式赋值：①递增，如i++；②符合运算符，如i+=2,将变量放在等号左边作为第一个操作数
3）条件或循环语句只有一条语句，省略大括号
4）用for语句替换while语句，因为while循环包括3部分：初始化索引变量，包含索引变量的循环条件，while循环最后一条语句将索引变量加1
数组
1）创建数组的三步：①声明数组的类型和名称；②创建数组；③初始化数组元素
2）简化写法：①等号左侧声明数组，等号右侧创建数组。double类型数组默认初始化为0.0；int类型数组初始化为0；boolean类型数组，初始化为false。②等号左侧声明数组，等号右侧花括号包括逗号分隔的值。
3）复制数组：①数组变量赋值给另一个变量，结果是两个变量指向同一个数组；②复制数组需要将元素全部复制
4）数组作为参数：方法参数按值传递，意味着参数是原数组的别名，方法使用参数变量能改变原数组（调用者）的内容
5) 对象数组定义需要类型转换，Item[] item = (Item[]) new Object[3]
方法
1）方法包括静态方法和实例方法
静态方法的例子：
/**
* 判断一个数是否为素数
*/
public static boolean isPrime(int N){
if(N<2) return false;
for(int i=2;i*i<N;i++)
if(N%i==0) return false;
return true;
}
/**
* 牛顿迭代法求平方根
* 参考：https://www.cnblogs.com/qlky/p/7735145.html
*/
public static double sqrt(double c){
if(c<0) return Double.NaN;
double err = 1e-15;
double t =c;
while(Math.abs(t-c/t)>t*err){
t=(c/t+t)/2.0;
}
return t;
}
/**
* 计算调和级数
* @param N
* @return
*/
public static double H(int N){
double sum = 0.0;
for(int i=1;i<=N;i++) sum+=1/i;
return sum;
}
2)方法性质
①方法的参数按值传递，引用类型变量参数是别名，方法中使用参数会改变原对象的值
②方法名可以被重载，一个函数需要变量，另一个函数使用默认值
③方法只有一个返回值，如果返回多个值时，可返回引用类型变量
④方法调用自己就是递归
⑤外部库
<1>系统标准库java.lang.*包括Math库，Integer库等，不需要import
<2>系统库，比如java.util.Arrays,需要import导入
<3>其他库，需要import导入
递归代码编写注意三点：
<1>方法第一条语句为包含return的简单条件语句
<2>递归的参数范围不断缩小，递归需要收敛到最简单的情况
<3>递归调用父问题和子问题不应该有交集
/**
* 重载：有序数组二分查找的递归实现
*/
public static int rank(int key,int[] a){
return rank(key,a,0,a.length-1);
}
/**
* 有序数组二分查找的递归实现
*/
public static int rank(int key, int[] a,int lo,int hi){
if(lo>hi) return -1;
int mid = lo+(hi-lo)/2;
if(key<a[mid]) return rank(key,a,lo,mid-1);
else if(key>a[mid]) return rank(key,a,mid+1,hi);
else return mid;
}
/**
* 优化：有序数组二分查找的递归实现
*/
public static int betterRank(int key,int[] a){
int lo =0;
int hi = a.length-1;
while(lo<=hi){
int mid = lo+(hi-lo)/2;
if(key<a[mid]) hi =mid-1;
else if(key>a[mid]) lo= mid+1;
else return mid;
}
return -1;
}
/**
* 缩进打印递归调用参数：二分查找
*/
public static int rank(int key,int[] a,int lo,int hi,int depth){
for (int i = 0; i < depth; i++) {
System.out.printf(" ");
}
System.out.println("lo=" + lo + ", hi=" + hi);
if(lo>hi) return -1;
int mid = lo+(hi-lo)/2;
if(key<a[mid]){
return rank(key,a,mid-1,hi,depth + 1);
}else if(key>a[mid]){
return rank(key,a,mid+1,hi,depth + 1);
}else{
return mid;
}
}
3）优化递归
优化递归方法：使用数组存储中间值减少重复计算
习题1.1.19
在计算机上运行以下程序:
public class Fibonacci {
public static long F(int N) {
if (N == 0) return 0;
if (N == 1) return 1;
return F(N - 1) + F(N - 2);
}
public static void main(String[] args) {
for (int N = 0; N < 100; N++)
StdOut.println(N + " " + F(N));
}
}
计算机用这段程序在一个小时之内能够得到 F(N) 结果的最大 N 值是多少?开发 F(N) 的一个更好的实现，用数组保存已经计算过的值。
答案
public static long F2(int N){
long[] res = new long[N+1];
if(N==0) return res[0];
res[1]=1;
if(N==1) return res[1];
for(int i=2;i<=N;i++) res[i]=res[i-1]+res[i-2];
return res[N];
}
习题1.1.27
二项分布。估计用以下代码计算binomial(100, 50,0.25)将会产生的递归调用次数:
public static double binomial(int N, int k, double p) {
if (N == 0 && k == 0) return 1.0;
if (N < 0 || k < 0) return 0.0;
return (1.0 - p) * binomial(N - 1, k, p) + p * binomial(N - 1, k - 1, p);
}
将已经计算过的值保存在数组中并给出一个更好的实现
答案
public static double betterBinomial(int N,int k,double p){
double[][] res = new double[N+1][k+1];
for(int i=0;i<N;i++){
res[i][0]=Math.pow(1-p,i);
}
for(int i=1;i<=N;i++){
for(int j=1;j<=k;j++){
res[i][j]=(1-p)*res[i-1][j]+p*res[i-1][j-1];
}
}
return res[N][k];
}
27题参考
1月2日
书本：63-130页
习题：1.1.19, 20, 21, 22, 23, 24, 27，共7题
抽象数据类型（ADT）
1）将数据和函数实现关联，并将数据的表示方式隐藏起来
2）使用抽象数据类型时，将注意力集中在API描述的操作而不关心数据的表示
3）实现抽象数据类型时，将注意力集中在数据的表示和对数据的操作
使用抽象数据类型
1）创建对象构成：①new 类名() 为新对象分配内存空间；② 触发构造函数，初始化对象中的值。③构造函数无返回值，因为其总是返回它的数据类型的对象的引用；④对象的变量指向对象的引用
2）赋值语句，创建另一个引用指向已经存在的对象
3）对象作为参数，传递的是对象的引用（的值），能够改变对象的值。
4）对象作为返回值，能够返回多个值
抽象数据类型举例
1）系统标准库java.lang.*中抽象数据类型
2）系统库中抽象数据类型：需要import
3）I/O处理类抽象数据类型：输入输出流
4）面向数据类抽象数据类型：几何和信息处理中简化数据的组织和处理
①几何对象
②信息处理：定义和事物对应的对象
③字符串
???
5）集合类抽象数据类型：Bag，Stack，Queue；优先队列PQ；符号表ST和集合SET
6）面向操作的抽象数据类型：分析算法
①计数器
②累加器
③可视累加器
④计时器
7）图算法相关的抽象数据类型：图的表示和图的处理
1月3日
书本：131-140页
实例代码：动态数组实现可以遍历的栈，3遍
表示一组数据对象的数据结构
1）泛型：
①存储任意类型的数据；
②类名后，Item是类型参数，一个占位符，使用时用具体类型替换
③有了泛型只需要一份API就能处理所有类型的数据
2）可迭代的集合类型
①实现Iterable
②可以用foreach语句变量元素
3）背包
①不支持从中删除元素的集合类型
②迭代的顺序不确定且与用例无关
③典型用法求和
4）先进先出队列
①使用foreach语句迭代队列中的元素，元素处理顺序就是添加到队列的顺序
②日常现象中的自然模型
5）下压栈
①使用foreach迭代栈中的元素，元素处理顺序与被压入栈的顺序相反
②典型实例：不断地点击网页链接访问新网页，点击回退按钮浏览以前的网页
双栈法求算术表达式
可调节大小的数组实现下压栈
class ResizingArrayStack<Item> implements Iterable<Item> {
private Item[] a = (Item[])new Object[3];
private int N = 0;
public boolean isEmpty(){
return N==0;
}
public int size(){
return N;
}
public void resize(int max){
Item[] temp = (Item[])new Object[max];
for(int i=0;i<N;i++){
temp[i]=a[i];
}
a=temp;
}
public void push(Item item){
if(N==a.length){
resize(2*N);
}
a[N++]=item;
}
public Item pop(){
Item item = a[--N];
if(N>0&&N==a.length/4){
resize(a.length/2);
}
return item;
}
public Iterator<Item> iterator(){
return new ReverseArrayIterator();
}
private class ReverseArrayIterator implements Iterator<Item> {
private int i= N;
public Item next(){
return a[--i];
}
public boolean hasNext(){
return i>0;
}
public void remove(){
}
}
4524
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
