算法 练习1.1

最新推荐文章于 2025-08-10 21:28:09 发布
原创 最新推荐文章于 2025-08-10 21:28:09 发布 · 949 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #java #编程

本文解析了一系列Java编程习题，包括变量定义、条件判断、数组操作、递归算法等内容，并给出了详细的代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.1.1
a.7;
b.200.0000002；
c.true.

1.1.2
a.double,1.618;
b.double,10.0;
c.boolean,true;
d.string,33.

1.1.3

public class Exercise1_1_3{
    public static void main(String[] args){
        double a = Doubleparse.Double(args[0]);
        double b = Doubleparse.Double(args[1]);
        double c = Doubleparse.Double(args[2]);
        if(a == b&&b == c)
            System.out.println("equal");
        else
            System.out.println("not equal");
    }
}

1.1.4
a.if不能与then搭配；
b.应该用括号将a>b括起来；
c.没有问题；
d.c=0后面少个”;”.

1.1.5

public class Exercise1_1_5{
    public static void main(String[] args)  {
        double a = Doubleparse.Double(args[0]);
        double b = Doubleparse.Double(args[1]);
        if(a > 0&&a < 1&&b > 0&&b < 1)
            System.out.println("true");
        else
            System.out.println("false");
    }
}

1.1.6
0
1
1
2
3
5
8
13
21
34
55
89
144
233
377
610

1.1.7
a.3.00009;
b.499500;
c.10000.

1.1.8
a.98;
b.197;
c.e.

1.1.9

String s = "";
for(int n = N;n > 0;n /= 2)
    s = (n % 2) + s;

1.1.10
它没有用new为a[]分配内存。

1.1.11

import edu.princeton.cs.algs4.StdOut;//我是在eclipse中运行的
import edu.princeton.cs.algs4.StdRandom;

public class Exercise1_1_11{
    public static void main(String[] args){
        boolean[][] a = new boolean[10][10];
        a = RandomInitial(a);//随机初始化数组
        Print(a);//打印数组
    }
    public static void Print(boolean[][] a){
        for(int i = 0;i < a.length;i++)
            StdOut.print(" " + i);
            StdOut.print(" ");
            for(int i = 0;i < 10;i++){
                StdOut.print(i);
                for(int j = 0; j < 10;j++){
                if(a[i][j])
                    StdOut.print("*" + " ");
                else
                    StdOut.print(" " + " ");

            }
            StdOut.println();
        }
    }
    public static  boolean[][] RandomInitial(boolean[][] a){
        for(int i = 0;i < a.length;i++)
            for(int j = 0;j < a.length;j++){
                if(StdRandom.bernoulli(0.1))
                    a[i][j] = true;
                else
                    a[i][j] = false;
            }
            return a;
    }
}

1.1.12
0
1
2
3
4
5
6
7
8
9

1.1.13

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

public class Exercise1_1_13{
    public static void main(String[] args){
        int m = 5;
        int n = 5;
        int[][] a = new int[m][n];
        int[][] b = new int[n][m];
        a = RandomInitial(a,n);//初始化二维数组
        b = MigrateArrays(a,b);//转置二维数组
        MigratePrint(b);//打印转置的二维数组
    }
    public static void MigratePrint(int[][] b){
        StdOut.println("转置之后的二维数组");
        for(int i = 0;i < b.length;i++){
            for(int j = 0;j < b[0].length;j++)
                StdOut.print(b[i][j] + " ");
            StdOut.println();
        }
    }
    public static int[][] MigrateArrays(int[][] a,int[][] b){
        for(int i = 0;i < a.length;i++){
            for(int j = 0;j < a[0].length;j++){
                b[i][j] = a[j][i];
                //StdOut.print(a[i][j]);
            }
            //StdOut.println();
        }
        return b;
    }
    public static int[][] RandomInitial(int[][] a,int N){
        StdOut.println("初始化的二维数组");
        for(int i = 0;i < a.length;i++){
            for(int j = 0;j < a[0].length;j++){
                a[i][j] = StdRandom.uniform(N);
                StdOut.print(a[i][j] + " ");
            }
            StdOut.println();
        }
        return a;
    }
}

1.1.14*
(感觉这题好经典)

public static int lga(int N,int M){
    int a = 0;
    while(N >= M){
        N = N / M;
        a++;
    }
    return a;
}

1.1.15

public static int[] histogram(int[] a,int M){
    int m = 0;
    int n = 0;
    for(int i = 0;i < M;i++){
        for(int j = 0;j < a.length;j++){
            if(i == a[j])
              n++;
            b[i] = n;
    }
    n = 0;
}
    for(int i = 0;i < M;i++)
        m = m + b[i];
    return b;
}

1.1.16
311361142246

1.1.17
（书上有答案）
这段代码中的基础情况永远不会被访问。调用exR2(3)会产生调用exR2(0)、exR2(-3)和exR2(-6),循环往复直到发生StackOverflowError。

1.1.18
50,33,a*b;
65795,6574.(即为2^25,3^11).

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){
        int[] a = new [100];
        a = A(a);
    }
    public static long[] A(int[] a){
        a[0] = 0;
        a[1] = 1;
        for(int N = 2;N < 100;N++){
            a[N] = a[N -1] + a[N - 2];
            StdOut.println(N + " " +a[N]);
        }
    }
}

1.1.20

public static double factorialln(long N){
    if(N > 1)
        return Math.ln(N) + factorialln(N - 1);
    else
        return 0;
}

1.1.21

import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdOut;


public class Exercise1_1_21 {

    public static void main(String[] args) {
        int M = 3;
        int index = 0;
        String[] strs = new String[M];
        while(index < M)
            strs[index++] = StdIn.readLine();
        for(int i = 0; i < strs.length; ++i) {
            String[] arr = strs[i].split("\\s+");
            double temp = Double.parseDouble(arr[1]) / Double.parseDouble(arr[2]);
            StdOut.printf("%-10s   %-10s   %-10s   %-13.3f\n", arr[0], arr[1], arr[2], temp);
        };
    }
}

1.1.22

import java.util.Arrays;

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

public class Exercise1_1_22{
    public static void main(String[] args){
        int N = 1024;
        int[] arr = new int[N];
        for(int i = 0;i < arr.length;i++)
            arr[i] = StdRandom.uniform(N * 50);

        Arrays.sort(arr);
        StdOut.print("seq = ");
        for(int i = 0;i < arr.length;i++)
            StdOut.print(arr[i] + "\t");


        int key = arr[StdRandom.uniform(N)];
        StdOut.println("\nkey = " + key);
        StdOut.println("------------------------------------------------------------------");
        binarySearch(key,arr,0);
    }
    public static int binarySearch(int key,int[] arr,int depth){
        return rank(key,arr,0,arr.length - 1,depth);
    }
    public static int rank(int key,int[] arr,int low,int high,int depth){
        printCallInfo(low,high,depth);
        if(low > high)
            return -1;
        int mid = low + (high - low) / 2;
        if(key < arr[mid])
            return rank(key,arr,low,mid -1,depth + 1);
        else if(key > arr[mid])
            return rank(key,arr,mid + 1,high,depth + 1);
        else 
            return mid;

    }
    private static void printCallInfo(int low,int high,int depth){
        StdOut.print(depth + "\t");
        printIndent(depth);
        StdOut.println(low + "\t" + high);
    }
    private static void printIndent(final int indents){
        for(int i = 0;i < indents;i++)
        StdOut.print("-----------");
    }
}

1.1.23

import java.util.Arrays;

import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdOut;

public class Exercise1_1_23{
public static boolean BinaryLookup(int key,int[] arr){
    int low = 0;
    int high = arr.length - 1;
    while(low <= high){
        int mid = low + (high - low) / 2;
        if(key < arr[mid])
            high = mid - 1;
        else if(key > arr[mid])
            low = mid + 1;
        else
            return true;    
    }
    return false;
}
public static void main(String[] args){
    char symbol = '-';
    int[] whitelist = new In(args[0]).readAllInts();
    Arrays.sort(whitelist);
    while(!StdIn.isEmpty()){
        int key = StdIn.readInt();
        boolean found = BinaryLookup(key,whitelist);
        if('+' == symbol&&!found)
            StdOut.println(key);
        if('-' == symbol&&found)
            StdOut.println(key);

    }
}

}

测试命令：java xxx tinyW.txt < tinyT.txt

1.1.24

import edu.princeton.cs.algs4.StdOut;


public class Exercise1_1_24 {
    public static void main(String[] args){
        int p = Integer.parseInt(args[0]);
        int q = Integer.parseInt(args[1]);
        int gcd = Euclid(p,q);
        StdOut.println(" **********" + gcd);
    }
    public static int Euclid(int p,int q){
        if(q == 0)
            return p;
    StdOut.println(q + " " + p % q);
    return Euclid(q,p % q);
    }
}

1.1.25
定理：gcd(a,b) = gcd(b,a mod b)

证明：a可以表示成a = kb + r，则r = a mod b
假设d是a,b的一个公约数，则有
d|a, d|b，而r = a - kb，因此d|r
因此d是(b,a mod b)的公约数

假设d 是(b,a mod b)的公约数，则
d | b , d |r ，但是a = kb +r
因此d也是(a,b)的公约数

因此(a,b)和(b,a mod b)的公约数是一样的，其最大公约数也必然相等，得证
(题目要求的用数学归纳法来证明的原理和该定理证明的原理一样，稍加修改即可。)

傻逼学习之——算法 第四版 1.1
jack_of_all_trades的博客
08-14 1881
初学算法，不会Java，各种捉急，用的算法第四版，跟着百度文库瞎掰。。。。。。。。一题一题的埋坑，，，， 下面给出可以测试多题的代码（要有Sedgewick老先生的一手安排，去网站下载库和相应的文件：http://algs4.cs.princeton.edu/code/     ） public class test { public static int lg(int N){ int
高中数学第一章算法初步1.1算法的概念练习.pptx
04-19
本节内容主要围绕算法的概念，通过具体的数学练习加深学生对算法的理解。 首先，教材会引导学生思考算法的定义。算法通常被定义为一系列的明确指令，用于完成特定任务或解决某个问题。在数学中，算法的概念相当重要...
队列模型
kunpengku
06-07 2794
队列在现实生活中是很常见的一种东西 。 产生队列的原因是 提供服务的速度 ，赶不上 需求的速度。 比如去某快餐吃饭，就需要排队，因为点单的人太多，而服务的人太少。在程序设计中，也会遇到这种情况。比如现在有一个发短信的任务 。 有10W条短信需要发， 而短信通道只支持每小时1W 条。 那么 有一条队列 就可以减轻人很多事情。这是队列就像弹簧，还控制 进入的速度。有10个人同时需要发短信 。他们
深度学习模型保存_深度学习中的模型修剪
weixin_39844590的博客
11-27 246
本文讨论了深度学习环境中的修剪技术。本再本文中，我们将介绍深度学习背景下的模型修剪机制。 模型修剪是一种丢弃那些不代表模型性能的权重的艺术。 精心修剪的网络会使其压缩版本更好，并且它们通常变得适合设备上的部署。本文的内容分为以下几节：· 函数和神经网络中的"非重要性"概念· 修剪训练好的神经网络· 代码片段和不同模型之间的性能比较· 现代修剪技术· 最后的想法和结论(我们将讨论的代码段将基于Ten...
34.1 算法介绍
csdn_immortal的博客
09-16 571
ipvs scheduler ipvs scheduler：根据其调度时是否考虑各RS当前的负载状态 两种：静态方法和动态方法 静态方法：仅根据算法本身进行调度 1、RR：roundrobin，轮询 2、WRR：Weighted RR，加权轮询 3、SH：Source Hashing，实现session sticky，源IP地址hash；将来自于同一个IP地址的请求始终发往第一...
简单队列模型
男儿当自强
10-25 265
"Hello World!" The simplest thing that doessomething 消息发送者： package com.tech.rabbitmq.normal; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; import java.nio.charset.Standar..
算法导论练习 1.1 Algorithms
Gorgeoustray
04-12 153
Sorting: Search engines need to sort the searching results. Computing a convex hull: computing the minimum diameters of a set of points on a plane. Coding efficiency, reading efficiency. Array. Stren...
关于算法练习1.1中的中参数传递方式思考
学习笔记
03-15 410
void addBSTreeNode(BSTreeNode *&pCurrent,int value) 这个函数参数是 BSTreeNode *&pCurrent 而不是BSTreeNode *pCurrent？ 用BSTreeNode *pCurrent 会错误 C++与Java中参数传递方式及相关问题 在C++中市面上的说法是有三种传递方法： 1、值传递 2、指针传递
算法练习工程1.1
lcshen1234的博客
08-07 248
算法练习工程（最长共同前缀）
leetcode算法练习
dearand的博客
01-06 272
leetcode算法练习
内蒙古准格尔旗高中数学第一章算法初步1.1算法的概念练习课件人教B版必修.ppt
05-19
4. 计算机算法的实现：文件中描述的算法概念练习课件揭示了计算机算法设计和实现的过程。计算机执行算法的过程是通过编程语言实现的。算法的设计要考虑到计算机的运算能力，因此需要尽可能高效，尤其是在处理大数据...
高中数学第一章算法初步1.1算法的含义.pptx
04-19
在当今科技迅速发展的时代背景下，算法作为解决...此外，通过课堂活动、数学利用例题以及作业练习等环节，学生不仅学会了如何定义和理解算法，而且能够将其应用于解决具体问题，从而培养了程序化思维和问题解决能力。
算法 Algorithms 1.1 答案
12-05
《算法 Algorithms 1.1 答案》是由著名计算机科学家Robert Sedgewick和Kevin Wayne合作编著的一部关于算法的权威教材。这本书是“算法”系列的一部分，旨在帮助读者深入理解和掌握各种基础及高级算法，提升编程能力...
高中数学第一章算法初步1.1算法与程序框图1.1.2.2条件结构课件新人教A版必修.ppt
07-30
根据提供的文件内容，我们可以构建以下关于高中数学第一章算法初步的知识点： 1. 算法的基本概念：算法是解决问题的一系列明确的、有顺序的指令集合，它可以通过人工执行或计算机程序来完成。在数学学习中，算法的...
蓝桥杯算法之搜索章 - 3
qiuyunoqy的博客
08-07 986
以上便是我们剪枝与优化的一部分内容了，我们还有一个记忆化搜索的内容在之后的文章。方便即时看到后续内容，如果以上部分有什么地方有问题的可以私信博主或者在评论一下。希望大家能够有所收获！
Java，八股，cv，算法——双非研0四修之路day27
qq3094554285的博客
08-07 1103
redis实践总结，JVM底层原理学习，快速回顾了一下mysql的基础篇，算法：二叉树的最大深度，二叉树的最小深度，完全二叉树节点的数量，平衡二叉树
数组指针-函数指针-回调函数
SixLegs的博客
08-07 1088
内存会划分为一个个的内存单元，每个内存单元都有一个独立的编号 - 编号也称为地址。地址在C语言中也被称为指针。指针（地址）需要存储起来 - 存储到变量中，这个变量也就被称为指针变量。指针的大小根据32位平台或64位平台固定是4/8个字节。地址是物理的电线上产生。32位机器 - 32根地址线 - 1/032个0/1组成的二进制序列，把这个二进制序列就作为地址，32个bit位才能存储这个地址，也就是需要4个字节才能存储。所以指针变量的大小就是4个字节。
非机动车识别mAP↑28%！陌讯多模态融合算法在智慧交通的实战解析
2501_92472966的博客
08-06 722
陌讯多模态融合算法显著提升非机动车识别性能，在边缘计算设备上实现mAP@0.5达89.1%，较基线提升28%。该方案通过偏振特征增强、HDR补偿等技术有效解决强光/逆光等复杂场景识别难题，使小目标识别率提升46.1%，早晚高峰漏检率降低85.3%。同时提供INT8量化等边缘部署优化方案，内存占用减少60%且保持精度损失<0.5%。实测数据表明，该技术可显著提升智慧交通场景下的非机动车识别准确率。
机械学习--DBSCAN 算法（附实战案例）
最新发布
enlybbq的博客
08-10 649
聚类效果：DBSCAN 成功将啤酒分为 3 个有意义的簇（常规啤酒、轻量啤酒、高端啤酒），并识别出 4 种特征异常的啤酒（噪声点），符合实际产品分类逻辑。参数影响：ε=0.6 和 MinPts=5 的组合效果较好，若 ε 增大，可能将噪声点划入簇；若 MinPts 增大，可能导致簇分裂为更多小簇。应用价值：该结果可辅助啤酒企业定位产品市场、优化产品线，或为消费者提供基于特征的选购参考。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值