数据结构-算法

LSuccess

已于 2023-06-26 11:11:44 修改

阅读量688

点赞数 1

文章标签：数据结构算法 java

于 2023-06-24 00:02:22 首次发布

本文链接：https://blog.csdn.net/m0_53572054/article/details/131355513

版权

2-1 若要对n个数进行排序，则这个问题的规模指的是( )。

A.排序时间的大小 B.不同排序方法有不同的规模 C.n的大小 D.A和C

2-2        算法分析的目的是( )

A.找出数据结构的合理性        B.研究算法中的输入和输出的关系

C.分析算法的效率以求改进        D.分析算法的易读性和文档性

2-3 算法指的是（）。

A.计算机程序 B.解决问题的计算方法 C.搜索和排序方法 D.解决问题的有限运算序列

2-4 对算法分析的前提是（）。

A.算法必须简单 B.算法必须正确 C.算法结构性强 D.算法必须通用

2-5 算法的时间复杂度取决于（）

A.问题的规模 B.待处理数据的初态 C.A和B

2-6        算法分析的两个主要方面是( )

A.空间复杂度和时间复杂度          B.正确性和简明性

C.可读性和文档性                        D.数据复杂性和程序复杂性

2-7 当输入规模为n时，下列算法渐进复杂性中最低的是

A.5n B. $n^{2}$ C. $2n^{2}$ D.n!

2-8 下面程序的时间复杂度为（）。
for(i = 0; i < m; i++)
     for(j = 0; j < n; j++ )
          A[i][j] = i*j;
A.O( $m ^{2}$ ) B.O( $n^{2}$ ) C.O(m × n) D.O(m + n)

2-9 下面程序的时间复杂度为（）。
for(i = 0; i < m; i++)
      for(j = 0; j < t; j++)
           c[i][j] = 0;
for(i = 0; i < m; i++)
      for(j = 0; j < t; j++)
            for(k = 0; k < n; k++)
                 c[i][j] = c[i][j]+a[i][k] * b[k][j];
A.O(m × n × t) B.O(m + n + t) C.O(m + n × t) D.O(m × t + n)

2-10 执行下面程序段时，执行S语句的频度为（）。
for(int i=0;i<n;i++)
for(int j=1;j<=i;j++)
     S;
A. $n^{2}$ B. $n^{2}$ /2 C.n(n+1) D.n(n+1)/2

2-11 以下程序段的时间复杂度是
for (int i = 0; i * i < n; i++) {
    printf("%d\n", i);
}
A.O(n) B.O( $\sqrt[]{n}$ ) C.O( $n^{2}$ ) D.O(nlgn)

2-12 斐波那契数列FN的定义为：F0=0, F1=1, FN=FN−1+FN−2, N=2, 3, …。用递归函数计算FN的空间复杂度是：

A.O(logN) B.O(N) C.O(FN) D.O(N!)

2-13 下面代码段的时间复杂度是（）。
i=1;
while( i<=n )
    i=i*3;
A.O(n) B.O(n2) C.O(1) D.O( $\log_{3}n$ )

2-14 下面代码段的时间复杂度是（）。
x=0;
for( i=1; i<n; i++ )
    for ( j=1; j<=n-i; j++ )
        x++;
A.O(n) B.O( $n^{2}$ ) C.O( $n^{3}$ ) D.O( $2^{n}$ )

2-15 下面代码段的时间复杂度是（）。
x=n; //n>1
y=0;
while( x≥(y+1)*(y+1) )
    y++;
A.O(1) B.O( $n_{}^{1/2}$ ) C.O(n) D.O(log2n)

2-16 以下程序段的空间复杂度为( )。
int a[100];
for(int i=0; i<100; i++) 
    a[i] = 0;
A.O(n) B.O(100) C.O(1) D.O(404)

2-17 下面叙述正确的是？

A.算法的执行效率与数据的存储结构无关

B.算法的空间复杂度是指算法程序中指令（或语句）的条数

C.算法的有穷性是指算法必须能在执行有限个步骤之后终止

D.其他三种描述都不对

2-18 计算算法的时间复杂度属于（）。

A.事前统计的方法 B.事前分析估算的方法 C.事后统计的方法 D.事后分析估算的方法

2-19 下列代码的时间复杂度是：
if ( A > B ) {
    for ( i=0; i<N; i++ )
        for ( j=N*N; j>i; j-- )
            A += B;
}
else {
    for ( i=0; i<N*2; i++ )
        for ( j=N*2; j>i; j-- )
            A += B;
}
A.O(N) B.O( $N ^{2}$ ) C.O( $N ^{3}$ ) D.O( $N^{4}$ )

2-20 下列代码的时间复杂度是：
if ( A > B ) {
    for ( i=0; i<N*N/100; i++ )
        for ( j=N*N; j>i; j-- )
            A += B;
}
else {
    for ( i=0; i<N*2; i++ )
        for ( j=N*3; j>i; j-- )
            A += B;
}
A.O( $N^{3}$ ) B.O( $N^{4 }$ ) C.O( $N^{5 }$ ) D.O( $N^{6}$ )

2-21 要判断一个整数N（>10）是否素数，我们需要检查3到 $\sqrt{N}$ 之间是否存在奇数可以整除N。则这个算法的时间复杂度是：

A.O( $\sqrt{N}$ ) B.O( $\frac{N}{2}$ ) C.O( $\sqrt{N}$ logN) D.O(0.5logN)

2-22 时间复杂度分析，下面算法的时间复杂度为 ▁▁▁▁▁。
int foo(int n)
{
    return n * (n + 1) / 2;
}
A.O(n) B.O( $n^{2}$ ) C.O( $\sqrt{N}$ ) D.O(1)

2-23 时间复杂度分析，下面算法的时间复杂度为 ▁▁▁▁▁。
int foo(int n)
{
    int i, s = 0;
    for (i = 1; i <= n; i *= 2)
    {
        s += i;
    }
    return s;
}
A.O( $\sqrt{N}$ ) B.O(n) C.O( $2^{n}$ ) D.O( $\log_{2}n$ )

2-24 时间复杂度分析，下面算法的时间复杂度为 ▁▁▁▁▁。
int foo(int n)
{
    int i, s = 0;
    for (i = 1; i * i <= n; ++i)
    {
        s += i;
    }
    return s;
}
A.O( $\sqrt{N}$ ) B.O(n) C.O( $n^{2}$ ) D.O( $\log_{2}n$ )

2-25        T(n)表示当输入规模为n时的算法效率，以下算法中效率最优的是( )。

A.T(n)=T(n-1)+1,T(1)=1                                B.T(n)= $2n^{2}$

C.T(n)=T(n/2)+1,T(1)=1                                D.T(n)= $3n\log_{2}n$