作业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分)
O(logn)
O(n​1/2​​)
O(n)
O(nlogn)

2-2

计算机算法必须具备输入、输出和（）等五个特性。 (2分)
易读性、稳定性和安全性
可行性、可移植性和可扩充性
可行性、确定性和有穷性
确定性、有穷性和稳定性

2-3

下列代码

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

的时间复杂度是： (3分)
O(N)
O(N​2​​)
O(NlogN)
O(N×i)

2-4

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

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

O(n​2​​)
O(n​3​​)
O(n)
O(2​n​​)

2-5

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

2-6

计算机算法指的是（）。 (2分)
排序方法
计算方法
解决问题的有限运算序列
调度方法

2-7

给定N×N×N的三维数组A，则在不改变数组的前提下，查找最小元素的时间复杂度是：(2分)
O(N​3​​logN)
O(N​2​​)
O(NlogN)
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分)
O(N​4​​)
O(N​5​​)
O(N​3​​)
O(N​6​​)

2-9

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

2-10

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

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

O(1)
O(n​1/2​​)
O(n)
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;
}