算法第四版习题解答（1.2 Data Abstraction）

最新推荐文章于 2024-05-03 10:14:52 发布
最新推荐文章于 2024-05-03 10:14:52 发布
阅读量314 收藏 3
点赞数
分类专栏： # 《算法》 文章标签： 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51703174/article/details/127321459
版权

前言

使用的是《算法》第四版英文版，主要是习题解答。

书中jar包的导入请戳：算法（第四版）中algs4.jar下载和使用

EXERCISES

1.2.1

import edu.princeton.cs.algs4.Point2D;
import edu.princeton.cs.algs4.StdDraw;
import edu.princeton.cs.algs4.StdOut;

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        StdDraw.setPenColor(StdDraw.RED);
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        Point2D[] points = new Point2D[N];
        double distance = 1.0;
        for (int i = 0; i < N; i++) {
            double x = Math.random();
            double y = Math.random();
            Point2D point = new Point2D(x, y);
            if (points.length > 0) {
                for (int j = 0; j < i; j++) {
                    if (point.distanceTo(points[j]) < distance)
                        distance = point.distanceSquaredTo(points[j]);
                }
            }
            points[i] = point;
            point.draw();
        }
        StdOut.println(distance);
    }
}

1.2.2

import edu.princeton.cs.algs4.*;

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        Interval1D[] intervals = new Interval1D[N];
        for (int i = 0; i < N; i++) {
            double minN = StdIn.readDouble();    // 在algs4包里面的输入
            double maxN = StdIn.readDouble();
            intervals[i] = new Interval1D(minN, maxN);
        }
        for (int i = 0; i < N - 1; i++) {
            for (int j = i + 1; j < N; j++) {
                boolean isIntersect = intervals[i].intersects(intervals[j]);
                if (isIntersect) {
                    System.out.println(intervals[i] + " and " + intervals[j] + " is intersect");
                }
            }
        }
    }
}

1.2.3

import edu.princeton.cs.algs4.*;

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        double minN = scanner.nextDouble();
        double maxN = scanner.nextDouble();
        Interval2D[] intervals = new Interval2D[N];
        Point2D[] point2D1 = new Point2D[N];
        Point2D[] point2D2 = new Point2D[N];

        for (int i = 0; i < N; i++) {
            double d1 = StdRandom.uniform(minN, maxN);
            double d2 = StdRandom.uniform(minN, maxN);
            double d3 = StdRandom.uniform(minN, maxN);
            double d4 = StdRandom.uniform(minN, maxN);

            double xMin = min(d1, d2);
            double xMax = max(d1, d2);
            double yMin = min(d3, d4);
            double yMax = max(d3, d4);

            point2D1[i] = new Point2D(xMin, xMax);
            point2D2[i] = new Point2D(yMin, yMax);
            intervals[i] = new Interval2D(new Interval1D(xMin, xMax), new Interval1D(yMin, yMax));
        }

        for (int i = 0; i < N; i++) {
            intervals[i].draw();
        }

        int countIntersects = 0;

        for (int i = 0; i < N - 1; i++) {
            for (int j = i + 1; j < N; j++) {
                if (intervals[i].intersects(intervals[j]))
                    countIntersects++;
            }
        }

        int countContains = 0;
        for (int i = 0; i < N - 1; i++) {
            for (int j = i + 1; j < N; j++) {
                if (intervals[i].contains(point2D1[j]) && intervals[i].contains(point2D2[j]))
                    countContains++;
            }
        }

        System.out.println("The number of pairs of intervals that intersect is " + countIntersects);
        System.out.println("The number of intervals that are contained in one another is " + countContains);
    }

    public static double min(double d1, double d2) {
        return d1 < d2 ? d1 : d2;
    }

    public static double max(double d1, double d2) {
        return d1 > d2 ? d1 : d2;
    }
}

1.2.4

注：
   String对象被final修饰，值是不可变的。
   声明一个String类型的引用变量名为string1，在内存中创建一个String类型的对象值为"Hello"，然后把这个对象的引用赋值给变量string1
    // String string1 = "Hello";  
   这个变量可以被用于指向其他对象，但是对象的值不可变
   重新在内存中创建一个String类型对象值为"world"，将这个对象的引用赋值给变量string1
   // string1 = "world";
   如果内存中的对象没有引用指向它，那么JVM会自动回收
   GC机制可以了解一下
   四种引用类型可以了解一下

1.2.5

1.2.6

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        String t = scanner.nextLine();
        if (s.length() == t.length() && s.concat(s).indexOf(t) != -1)
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}

1.2.7

1.2.8

略

1.2.9

答案请戳这：习题1.2.9解答

1.2.10

import edu.princeton.cs.algs4.StdDraw;
import edu.princeton.cs.algs4.StdRandom;

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        int max = scanner.nextInt();
        StdDraw.setXscale(0, N + 1);
        StdDraw.setYscale(-max, max);
        StdDraw.line(0, 0, N + 1, 0);
        StdDraw.setPenColor(StdDraw.MAGENTA);
        StdDraw.setPenRadius(0.01);
        VisualCounter visualCounter = new VisualCounter(N, max);
        visualCounter.draw();
        for (int i = 0; i < N; i++) {
            if (StdRandom.bernoulli())
                visualCounter.increment();
            else
                visualCounter.decrement();
            visualCounter.draw();
        }
    }
}

class VisualCounter {
    private final int N;
    private final int max;
    private int value;
    private int operationCount;

    public VisualCounter(int N, int max) {
        this.N = N;
        this.max = max;
        this.value = 0;
        this.operationCount = 0;
    }

    public void increment() {
        if (operationCount++ < N && value < max)
            value++;
    }

    public void decrement() {
        if (operationCount++ < N && value > -max)
            value--;
    }

    public void draw() {
        StdDraw.point(operationCount, value);
    }
}

1.2.11

public class SmartDate{
    private final int month;
    private final int day;
    private final int year;

    public SmartDate(int month, int day, int year) throws Exception {
        this.year = year;

        if (month <= 12)
            this.month = month;
        else
            throw new Exception("month is illegal");


        boolean a = ((month == 4) || (month == 6) || (month == 9) || (month == 11));        // 这些月份最多30天
        boolean b = ((month == 1) || (month == 3) || (month == 5) || (month == 7) || (month == 8)   // 这些月份最多31天
                || (month == 10) || (month == 12));

        // 判断是否闰年
        if (year % 4 ==0 && year % 100 != 0 || year % 400 == 0) {
            if (month == 2 && day <= 29)
                this.day = day;
            else if (a && day <= 30)
                this.day = day;
            else if (b && day <= 31)
                this.day = day;
            else
                throw new Exception("day is illegal");
        } else {
            if (month == 2 && day <= 28) {
                this.day = day;
            } else if (a && day <= 30)
                this.day = day;
            else if (b && day <= 31)
                this.day = day;
            else
                throw new Exception("day is illegal");
        }
    }

    public int getMonth() {
        return month;
    }

    public int getDay() {
        return day;
    }

    public int getYear() {
        return year;
    }

    @Override
    public String toString() {
        return getMonth() + "/" + getDay() + "/" + getYear();
    }
}

1.2.12

判断如何通过日期计算星期几：蔡勒公式和朴素做法

public class SmartDate{
	....		// 省略部分为1.2.11
	....
	....

    public String dayOfTheWeek() {
        // 计算公式：w=(d+2*m+3*(m+1)/5+y+y/4-y/100+y/400+1)%7
        // 0-星期日  1-星期一  2-星期二  3-星球三  4-星期四  5-星期5   6-星期六
        int d = day;
        int m = month;
        int y = year;
        int res = (d + 2 * m + 3 * (m + 1) / 5 + y + y / 4 - y / 100 + y / 400 + 1) % 7;
        String[] weeks = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
        return weeks[res];
    }
}

1.2.13

class Transaction implements Comparable<Transaction> {
    private String name;
    private SmartDate date;
    private double amount;
    private String transaction;

    public Transaction(String name, SmartDate date, double amount) {
        this.name = name;
        this.date = date;
        this.amount = amount;
    }

    public Transaction(String transaction) {
        this.transaction = transaction;
    }

    public String getName() {
        return name;
    }

    public SmartDate getDate() {
        return date;
    }

    public double getAmount() {
        return amount;
    }

    @Override
    public String toString() {
        return "Transaction{" + getName() + " " + getDate() + " " + getAmount() + "}";
    }

    @Override
    public int compareTo(Transaction o) {
        if (this.amount > o.amount)
            return 1;
        else if (this.amount < o.amount)
            return -1;
        else
            return 0;
    }
}

1.2.14

import java.util.Objects;

class Transaction implements Comparable<Transaction> {
	...		// 省略部分为1.2.13
	...
	...

    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null)
            return false;
        if (this.getClass() != o.getClass())
            return false;
        Transaction transaction = (Transaction) o;
        if (!this.name.equals(transaction.name))
            return false;
        if (!this.date.equals(transaction.date))
            return false;
        if (this.amount != transaction.amount)
            return false;
        return true;
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, date, amount, transaction);
    }
}

CREATIVE PROBLEMS

1.2.15

import edu.princeton.cs.algs4.In;

public class Solution {
    public static void main(String[] args) {
        int[] datas = readInts(args[0]);
        for (int i = 0; i < datas.length; i++) {
            System.out.println(datas[i]);
        }
    }

    public static int[] readInts(String name) {
        In in = new In(name);
        String input = in.readAll();
        String[] words = input.split("\\s+");
        int[] res = new int[words.length];
        for (int i = 0; i < words.length; i++) {
            res[i] = Integer.parseInt(words[i]);
        }
        return res;
    }
}

1.2.16

class Rational {
    private final long numerator;
    private final long denominator;

    public Rational(long numerator, long denominator) {
        if (denominator == 0)
            throw new RuntimeException("denominator is zero!!");
        long r = gcd(numerator, denominator);
        if (denominator < 0)
            r = -r;
        this.numerator = numerator / r;
        this.denominator = denominator / r;
    }

    public Rational plus(Rational b) {
        long d = denominator * b.denominator;
        long n = numerator * b.denominator + denominator * b.numerator;
        return new Rational(n, d);
    }

    public Rational minus(Rational b) {
        long d = denominator * b.denominator;
        long n = numerator * b.denominator - denominator * b.numerator;
        return new Rational(n, d);
    }

    public Rational times(Rational b) {
        long d = denominator * b.denominator;
        long n = numerator * b.numerator;
        return new Rational(n, d);
    }

    public Rational divides(Rational b) {
        long d = denominator * b.denominator;
        long n = numerator * b.numerator;
        return new Rational(n, d);
    }

    public boolean equals(Rational that) {
        if (this == that)
            return true;
        if (that == null)
            return false;
        if (this.getClass() != that.getClass())
            return false;
        return (numerator == that.numerator && denominator == that.denominator);
    }

    @Override
    public String toString() {
        if (this.denominator == 1)
            return String.format("%d", this.numerator);
        return String.format("%d/%d", this.numerator, this.denominator);
    }

    public static long gcd(long p, long q) {
        if (p < 0)
            p = -p;
        if (q < 0)
            q = -q;
        if (q == 0)
            return p;
        long r = p % q;
        return gcd(q, r);
    }
}

1.2.17

class Rational {
	....	// 省略部分和1.2.16相同
	....
	....	

    public Rational plus(Rational b) {
        assert (denominator < Long.MAX_VALUE && denominator > Long.MIN_VALUE);
        assert (b.denominator < Long.MAX_VALUE && b.denominator > Long.MIN_VALUE);
        long d = denominator * b.denominator;
        long n = numerator * b.denominator + denominator * b.numerator;
        return new Rational(n, d);
    }
}

1.2.18

public class Solution {
    public static void main(String[] args) {
        Accumulator accumulator = new Accumulator();
        accumulator.addDataValue(2);
        accumulator.addDataValue(3);
        accumulator.addDataValue(4);
        accumulator.addDataValue(8);
        System.out.println(accumulator);
    }
}

class Accumulator {
    private double m;
    private double s;
    private int n;

    public void addDataValue(double val) {
        n++;
        s = s + 1.0 * (n - 1) / n * (val - m) * (val - m);
        m = m + (val - m) / n;
    }

    public double mean() {
        return m;
    }

    public double var() {
        return s / (n - 1);
    }

    public double stddev() {
        return Math.sqrt(this.var());
    }

    public String toString() {
        return String.format("%.5f %.5f", mean(), stddev());
    }
}

1.2.19

略

杨林山小野猪
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Algorithms:算法（第4版）习题
05-11
算法（第4版）    代码改进 解决文件重定向问题 在书中是通过文件重定向的方式进行算法测试的, 在IDEA中通过以下代码进行文件重定向 import java.io.FileInputStream; import java.io.FileNotFoundException; try { FileInputStream input = new FileInputStream("./data/tinyT.txt"); System.setIn(input); } catch (FileNotFoundException e) { e.printStackTrace(); }
数据结构——二叉树BinaryTree基本功能大全及代码实现（递归、非递归遍历、深度、结点数）
Jayphone17的博客
10-05 1046
一、需求分析与功能描述 现代社会生活中，计算机扮演着重要角色，而随着计算机运行速度的不断加快，对数据的处理能力也日益增强，因此，程序所涉及的数据很多，如何科学有效的对数据进行操作，使得计算机的时间和空间利用率最高是一个问题。针对这样的问题，我选择了二叉树对数据的各种操作作为我的课程设计主题，希望通过二叉树来提高对数据的处理能力，促进对数据结构课程的理解。 在二叉树的应用中，常常要求在树中查找...
替换手机号中间4位（php，js）
mobeinight的专栏
12-24 1603
JS方法function hideMobile(num){ var mphone =num.substr(3,4); var lphone = num.replace(mphone,"****"); return lphone; } php方法 $phone=substr_replace($phone,'****',3,4);
c/c++经典面试题
zyb408815041的博客
12-22 1118
来自：http://www.mianwww.com/html/2012/04/16174.html 面试题1：变量的声明和定义有什么区别 为变量分配地址和存储空间的称为定义，不分配地址的称为声明。一个变量可以在多个地方声明，但是只在一个地方定义。加入extern修饰的是变量的声明，说明此变量将在文件以外或在文件后面部分定义。 说明：很多时候一个变量，只是声明不分配内存空间，直到具
算法第四版习题解答（1.3 Bags, Queues, adn Stacks）
astralcon的博客
11-14 646
算法第四版练习1.3
算法第四版学习（chapter1.4）part1
z1261203654的博客
08-22 984
    马上开始今天的学习，今天的内容是算法分析，算法的一个评估环节，当我们在设计、使用一个算法的时候，一个算法的好坏往往与它的运行时间（时间复杂度），运行所需空间（空间复杂度）挂钩，首先来学习时间复杂度问题。      书中一开始提到一个例子，讲的是计算从数组中抽取三个数，统计三个数加起来等于0的个例，然后进行返回。文章之中给出的ThreeSum，典型的暴力算法，逐个遍历，在P112，我遇到了...
Day1
yuan2yue的博客
07-04 881
ftp://10.10.2.200/面向对象编程方法：表示了对象具有的行为，主要包括两个部分：方法头和方法体方法头：访问修饰符 返回值类型 方法名（形参）               方法体：｛｝              可以把方法简单理解为菜谱面向对象三大特性（1）    封装（2）    继承（3）    多态一．    封装研究对象的 属性           姓名 品种 健康值 亲密度 ...
《算法第四版》课后练习题1.1.35答案
一个有故事的程序员
04-22 1221
习题：1.1.35 以下代码能够计算每种两个骰子之和的准确概率分布： int SIDES = 6; double[] dist = new double[2 * SIDES + 1]; for (int i = 1; i <= SIDES; i++) for (int j = 1; j <= SIDES; j++) dist[i + j] += 1.0; ...
java笔试试题含答案_Java笔试题带答案
weixin_32029863的博客
02-24 2214
一、 选择题(20分,每题2分)1. 给定Java代码，下列方法可以将其加入Sample类中，并且能够编译正确( )public class Sample{public int getSomething(int d){return d;}A. private int getSomething(int I,String s){}B. private void getSomething(int i)...
Data Abstraction and Problem Solving with C++(6th) 无水印pdf
09-22
Data Abstraction and Problem Solving with C++(6th) 英文无水印pdf 第6版 pdf所有页面使用FoxitReader和PDF-XChangeViewer测试都可以打开 本资源转载自网络，如有侵权，请联系上传者或csdn删除 本资源转载自...
算法-第四版-习题-答案
02-07
算法-第四版-习题-答案算法-第四版-习题-答案算法-第四版-习题-答案
Data-Abstraction-and-Problem-Solving-with-Java_co_data abstracti
09-22
Data Abstraction and Problem Solving with Java - code1
算法第四版（algorithms），2011年新出版，算法设计力作
02-07
1.2 Data Abstraction 64 1.3 Bags, Queues, and Stacks 120 1.4 Analysis of Algorithms 172 1.5 Case Study: Union-Find 216 2 Sorting . . . . . . . . . . . . . . . . . . . . . . . 243 2.1 Elementary Sorts ...
Objects, Abstraction, Data Structures and Design - Using C++ 无水印pdf
09-22
Objects, Abstraction, Data Structures and Design - Using C++ 英文无水印pdf pdf所有页面使用FoxitReader和PDF-XChangeViewer测试都可以打开 本资源转载自网络，如有侵权，请联系上传者或csdn删除 本资源...
Object-Orientation Abstraction and Data Structures Using Scala(2nd) 无水印pdf
09-29
Object-Orientation Abstraction and Data Structures Using Scala(2nd) 英文无水印pdf 第2版 pdf所有页面使用FoxitReader和PDF-XChangeViewer测试都可以打开 本资源转载自网络，如有侵权，请联系上传者或csdn...
笔试强训-day17_T2 十字爆破
最新发布
weixin_46186903的博客
05-03 467
模拟即可，但是由于数据量过⼤，我们可以提前把每⼀⾏以及每⼀列的和存起来，⽅便统计总和。解法二：提前把每⼀⾏以及每⼀列的和存起来，然后输入输出使用快速的IO方式，解答如下所示。解法一：暴力遍历，这种方法很容易想到，并且也容易编写出代码，但是会超时。因为1+2+3=6，1+2+4=7，1+3+4=8，2+3+4=9。牛牛选择一个方格，可以得到和这个方格同行、同列的所有数之和的得分。现在牛牛想知道下一步选择每个格子的得分情况，你可以帮帮他吗？m个方格，每个方格中有一个整数。
leetcode16-3Sum Closest
我的程序人生
04-29 312
这道题目和那道3Num的题目很类似，解题思路也是类似的，我们先对数组排序，然后固定一个元素，通过双指针遍历剩下的元素，用一个哨兵记录三个元素的和与target的diff，分别处理三个元素的和小于target，大于target，等于target这三种情况即可。请你从 nums 中选出三个整数，使它们的和与 target 最接近。解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2)。输入：nums = [-1,2,1,-4], target = 1。假定每组输入只存在恰好一个解。
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真
熟悉MATLAB/fpga/RK3588/LABVIEW/protus/单片机/dsp/Multisim
04-30 652
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真。基于模糊PI控制算法的龙格-库塔（Runge-Kutta, RK）连续搅拌釜反应器（Continuous Stirred Tank Reactor, CSTR）模型控制系统，是将模糊控制理论与经典的数值积分方法相结合的一种先进控制策略。模糊控制是一种基于模糊集合理论和语言变量的控制方法，适用于非线性、时变系统的控制。
c++容器与算法概述
北风
05-01 421
简单讲述输入输出运算符重载 以及容器的简单使用及接口哦苦
Data abstraction
10-19
数据抽象是一种将程序中展示数据的部分与操控数据的部分隔离开来的设计方法。它的目的是为了让程序员和客户端无需关心数据的具体存储方式，只需使用和设计操作即可。数据抽象的核心思想是将数据类型的表示和操作分离开来，这样可以使得程序更加模块化，易于维护和扩展。在数据抽象中，抽象类型是由一组操作所刻画的数据类型，而不关心数据结构的细节实现。ADT是由操作定义的，与其内部如何实现无关。数据抽象的优点是可以提高程序的可读性、可维护性和可扩展性。同时，数据抽象也可以使得程序更加安全，因为客户端无法直接访问数据的内部表示，只能通过定义好的操作来访问数据。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值