作业3 算法时间复杂度和空间复杂度

1-1

2​N​​和N​N​​具有相同的增长速度。 (2分)

T          F

1-2

N​2​​logN和NlogN​2​​具有相同的增长速度。 (2分)

T          F

1-3

在任何情况下，时间复杂度为O(n​2​​) 的算法比时间复杂度为O(n*logn)的算法所花费的时间都长。 (1分)

T          F

1-4

对于某些算法，随着问题规模的扩大，所花的时间不一定单调增加。 (1分)

T          F

1-6

$100logN$是$O(N)$的。 (1分)

T          F

1-7

算法分析的两个主要方面是时间复杂度和空间复杂度的分析。 (1分)

T          F

2-1

下列函数

int func ( int n )
{   int i = 0, sum = 0;
    while ( sum < n )  sum += ++i;
    return i;
}

的时间复杂度是：(2分)

1. $O(logn)$
2. O(n​1/2​​)
3. $O(n)$
4. $O(nlogn)$

2-2

计算机算法必须具备输入、输出和（）等五个特性。 (2分)

1. 易读性、稳定性和安全性
2. 可行性、可移植性和可扩充性
3. 可行性、确定性和有穷性
4. 确定性、有穷性和稳定性

2-3

下列代码

for(i=0; i<n; i++)
  for(j=i; j>0; j/=2)
     printf(“%d\n”, j);

的时间复杂度是： (3分)

1. $O(N)$
2. O(N​2​​)
3. $O(NlogN)$
4. $O(N\times i)$

2-4

下面代码段的时间复杂度是（）。 (2分)

x=0;  
for( i=1; i<n; i++ )  
    for ( j=1; j<=n-i; j++ )  
        x++;

1. O(n​2​​)
2. O(n​3​​)
3. $O(n)$
4. O(2​n​​)

2-5

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

1. O(√​N​​​logN)
2. $O(N/2)$
3. O(√​N​​​)
4. $O(0.5logN)$

2-6

计算机算法指的是（）。 (2分)

1. 排序方法
2. 计算方法
3. 解决问题的有限运算序列
4. 调度方法

2-7

给定$N\times N\times N$的三维数组A，则在不改变数组的前提下，查找最小元素的时间复杂度是：(2分)

1. O(N​3​​logN)
2. O(N​2​​)
3. $O(NlogN)$
4. O(N​3​​)

2-8

下列代码

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;
}

的时间复杂度是：(2分)

1. O(N​4​​)
2. O(N​5​​)
3. O(N​3​​)
4. O(N​6​​)

2-9

下列函数中，哪个函数具有最慢的增长速度：(2分)

1. NlogN​2​​
2. N(logN)​2​​
3. N​1.5​​
4. N​2​​logN

2-10

下面代码段的时间复杂度是（）。(2分)

x=n; //n>1
y=0;
while( x≥(y+1)*(y+1) )
    y++;

1. $O(1)$
2. O(n​1/2​​)
3. $O(n)$
4. O(log​2​​n)

7-1 有序链表的插入（20 分）

已知一个递增有序链表L（带头结点，元素为整数），编写程序将一个新整数插入到L中，并保持L的有序性。 其中单链表的类型定义参考如下：

typedef int elementType;

typedef struct lnode

{ elementType data;

struct lnode *next;

}Lnode,* LinkList;

输入格式:

输入分三行

第一行 元素个数

第二行 元素的值，元素间用空格分隔。

第三行 待插入的元素值

输出格式:

在一行中输出有序链表元素值，每个元素前输出一个空格以便与相邻元素分隔。

输入样例:

5
1 3 5 7 9
4

输出样例:

 1 3 4 5 7 9

//数据结构联系 链表实现数据插入有序表
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
//函数状态码定义
#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE -1
#define OVERFLOW   -2

#define OVERFLOW   -2

typedef int elementType;
typedef struct lnode
{ elementType data;
struct lnode *next;
}Lnode,* LinkList;
void ListCreate_CL(LinkList &CL, int n)
{
    Lnode *curPtr, *rearPtr;
    //开辟头节点
    CL = (Lnode*)malloc(sizeof(Lnode));
    if(!CL) exit(OVERFLOW);
    CL->next = CL;
    rearPtr = CL;
    for(int i=1; i<=n; i++)
    {//每次开辟一个新节点，输入数据并赋值，并接到尾巴后面
        curPtr = (Lnode*)malloc(sizeof(Lnode));
        if(!curPtr)
            exit(OVERFLOW);
        scanf("%d",&curPtr->data);
        //尾指针的next成员指向当前结点
        rearPtr->next = curPtr;
        //更新尾结点
        rearPtr = curPtr;
    }
    //最后尾结点指向头节点
    rearPtr->next = CL;
}
void ListAdd_CL(LinkList &CL, int m)
{
    //先开辟一个结点，数据域等于m
    Lnode *temp;
    int flag=0;
    temp = (Lnode *)malloc(sizeof(Lnode));
    if(!temp) exit(OVERFLOW);
    temp ->data=m;
    //从头节点开始遍历指针，找到大于m数的位置，将m的结点插入
    Lnode *curPtr, *prePtr;
    curPtr = CL->next;
    prePtr = CL;
    while(curPtr!=CL)
    {
        if(curPtr->data>m)
        {
             //令前驱结点的next成员指向m的结点，m结点的next成员指向当前结点
             prePtr->next = temp;
             temp ->next = curPtr;
             flag=1;
             break;//插入后停止循环,否则一直插入m
        }
        else
        {
            prePtr = curPtr;
            curPtr = prePtr->next;
        }
    }//此时curPtr==CL
    //特殊情况，m比链表的数都大或空表时，都则插在尾巴上
    if(flag==0)
    {
       while(curPtr->next!=CL)
       {
           curPtr = curPtr ->next;
       }
        curPtr->next = temp;
        temp ->next = CL;
    }
}
void ListPrint_CL(LinkList &CL)
{
    Lnode *curPtr;
    //遍历，输出
    curPtr = CL->next;
    while(curPtr!=CL)
    {
        printf(" %d",curPtr->data);
        curPtr = curPtr->next;
    }
}
int main()
{
   LinkList CL;
   int n, m;
   scanf("%d",&n);
   ListCreate_CL(CL, n);
   scanf("%d",&m);
   ListAdd_CL(CL, m);
   ListPrint_CL(CL);
   return 0;
}