算法题军训

A. 数据结构算法设计题

某链表中最常用的操作是在最后一个元素之后插入一个元素和删除最后一个元素,则采用( )存储方式最节省运算时间. (A)...已知带头结点的单链表L中的结点是按整数值递增排列的,试写一算法,将值为x 的结点插入到表L中,使得L仍然有序

B. 算法设计 题求解

1.
外层执行n+1次循环，内姿伏亏层m+1次，所以时间复杂度
O（n*m)=(n+1)*（m+1);
2.
外层执行n次循环，
内层迹神i次循环，i=0,1,2,..,n-1;
n次循环对应的次数：
0，1，2，...,n-1；
等于
（1+2+...+n-1)=n(n-1)/厅耐2;
算法执行次数如上：
它的时间复杂度
O（n*n);

C. 九月初，王红同学升入中学老师宣布学校要组织初一年级的学生去外地参加军训，要求每位同学准备好一周

设:第一天为X，第培拆二天为X+1，依次类推，直兄中段到第七羡誉天为X+6
X+X+1+ X+2+ X+3+ X+4+ X+5+ X+6=49
7X+21=49
7X=28
X=4

所以是第4天出发

D. 数据结构算法 试题 急！ 试构造下图的最小生成树，要求分步给出构造过程。

图有如下参数:

边数=8顶点数=5

顶点顶点边的权值
v1v26
v1v34
v1v42
v2v35
v2v48
v2v56
v3v45
v4v57

用Kruskal(克鲁斯卡尔)算法,求最小生成树.

先将所有边的权值按照从小到大排序:

顶点顶点边的权值
v1v42
v1v34
v2v35
v3v45
v1v26
v2v56
v4v57
v2v48

然后,每次提取权值最小边,逐步组成最小生成树:

(1)取最小边(v1,v4,2)

v1--v4

(2)取边(v1,v3,4),不会产生环路.

v1--v4
|
|
v3

(3)取边(v2,v3,5),不会产生环路.

v1--v4
|
|
v3--v2

(4)如果取边(v3,v4,5),会产生环路,所以不能取.
如果取边(v1,v2,6),会产生环路,所以不能取.
取边(v2,v5,6),不会产生环路.

v1--v4
|
|
v3--v2--v5

这就是最小生成树,连通了所有顶点,总权值最小.

顶点边的权值
(v1,v4)2
(v1,v3)4
(v2,v3)5
(v2,v5)6


//C语言测试程序

//最小生成树Kruskal(克鲁斯卡尔)算法
#include"stdio.h"

#defineMAXEDGE20
#defineMAXVEX20
#defineINF65535

typedefstruct
{
	intarc[MAXVEX][MAXVEX];
	intnumVertexes,numEdges;
}MGraph;

typedefstruct
{
	intbegin;
	intend;
	intweight;
}Edge;//对边集数组Edge结构的定义

//创建图
voidCreateMGraph(MGraph*G)
{
	inti,j;

	G->numEdges=8;//边数
	G->numVertexes=5;//顶点数

	for(i=0;i<G->numVertexes;i++)//初始化图
	{
		for(j=0;j<G->numVertexes;j++)
		{
			if(i==j)
				G->arc[i][j]=0;
			else
				G->arc[i][j]=G->arc[j][i]=INF;
		}
	}

	G->arc[0][1]=6;
	G->arc[0][2]=4;
	G->arc[0][3]=2;
	G->arc[1][2]=5;
	G->arc[1][3]=8;
	G->arc[1][4]=6;
	G->arc[2][3]=5;
	G->arc[3][4]=7;

	for(i=0;i<G->numVertexes;i++)
	{
		for(j=i;j<G->numVertexes;j++)
		{
			G->arc[j][i]=G->arc[i][j];
		}
	}
}

//交换权值以及头和尾
voidSwapn(Edge*edges,inti,intj)
{
	inttemp;
	temp=edges[i].begin;
	edges[i].begin=edges[j].begin;
	edges[j].begin=temp;
	temp=edges[i].end;
	edges[i].end=edges[j].end;
	edges[j].end=temp;
	temp=edges[i].weight;
	edges[i].weight=edges[j].weight;
	edges[j].weight=temp;
}

//对权值进行排序(选择排序法)
voidsort(Edgeedges[],MGraph*G)
{
	inti,j,min;
	for(i=0;i<(G->numEdges-1);i++)
{
min=i;
for(j=i+1;j<G->numEdges;j++)
{
if(edges[min].weight>edges[j].weight)
{
min=j;
}
}
if(i!=min)
{
Swapn(edges,i,min);
}
}

	printf("边的权值排序之后:
");
	for(i=0;i<G->numEdges;i++)
	{
		printf("(%d,%d)%d
",edges[i].begin,edges[i].end,edges[i].weight);
	}
}

//查找连线顶点的尾部下标
intFind(int*parent,intf)
{
	while(parent[f]>0)
	{
		f=parent[f];
	}
	returnf;
}

//生成最小生成树
voidMiniSpanTree_Kruskal(MGraphG)
{
	inti,j,n,m;
	intk=0;
	intparent[MAXVEX];//定义一数组用来判断边与边是否形成环路

	Edgeedges[MAXEDGE];//定义边集数组,edge的结构为begin,end,weight,均为整型

	//用来构建边集数组并排序
	for(i=0;i<G.numVertexes-1;i++)
	{
		for(j=i+1;j<G.numVertexes;j++)
		{
			if(G.arc[i][j]<INF)
			{
				edges[k].begin=i;
				edges[k].end=j;
				edges[k].weight=G.arc[i][j];
				k++;
			}
		}
	}
	sort(edges,&G);//从小到大排序

	for(i=0;i<G.numVertexes;i++)
{
parent[i]=0;
}

	printf("打印最小生成树：
");
	for(i=0;i<G.numEdges;i++)	//循环每一条边
	{
		n=Find(parent,edges[i].begin);
		m=Find(parent,edges[i].end);
		if(n!=m)//假如n与m不等，说明此边没有与现有的生成树形成环路
		{
			parent[n]=m;	//将此边的结尾顶点放入下标为起点的parent中
							//表示此顶点已经在生成树集合中
			printf("(%d,%d)%d
",edges[i].begin,edges[i].end,edges[i].weight);
		}
	}
}

intmain(void)
{
	MGraphG;
	CreateMGraph(&G);
	MiniSpanTree_Kruskal(G);
	return0;
}

E. 算法分析与设计题目

第一题用贪心思想 找出用时最短的m个作业交给机器同时开始加工 然后再依次将剩下的作业中最短完成作业取出放入已完成的机器加工 当最后一台机器完工时间就是所用最短时间 思路是这样子 具体算法实现的话。。由于我也是学生=、=写代码还不是很熟练。。可能等我写好了你考试来不及。。。你还是自己来吧

第二题
1.背包问题是什么=、=我们教材不一样 不了解具体问题。。
2.4皇后
#include<iostream.h>
const int n = 4 ;
const int n_sub = n - 1 ;
int queen[n] ;
bool row[n] ;
bool passive[2*n-1];
bool negative[2*n-1];
int main()
{
int cur = 0 ;
bool flag = false ;
queen[0] = -1 ;
int count = 0 ;
while(cur>=0)
{
while(cur>=0 && queen[cur]<n && !flag)
{
queen[cur]++ ;
if(queen[cur] >= n)
{
queen[cur] = -1 ;
cur-- ;
if(cur>=0)
{
row[queen[cur]] = false ;
passive[queen[cur] + cur] = false ;
negative[n_sub + cur - queen[cur]] = false ;
}
false ;
}
else
{
if(row[queen[cur]] == false)
{
flag = true ;
if( passive[queen[cur] + cur] == true || negative[n_sub + cur - queen[cur]] == true) {
flag = false ;
}
else
flag = true ;
if(flag) {
if(cur == n-1)
{
count++ ;
}
row[queen[cur]] = true ;
passive[queen[cur] + cur] = true ;
negative[n_sub + cur - queen[cur]] = true ;
cur++ ;
if(cur >= n) {
cur-- ;
row[queen[cur]] = false ;
passive[queen[cur] + cur] = false ;
negative[n_sub + cur - queen[cur]] = false ;
}
flag = false ;
}
}
}
}
}
cout<<n<<"皇后问题一共有"<<count<<"种解法"<<endl ;
return 0 ;
}
这个是代码。。。状态空间树这里画不出来。。。

第三题
你网络下基本都有的=、=。。。我网络出来不好意思贴了你自己去看下吧
比如1.的答案：
最坏情况给出了算法执行时间的上界，我们可以确信，无论给什么输入，算法的执行时间都不会超过这个上界，这样为比较和分析提供了便利。

F. python习题（算法）

这个就是循环2n次呀。先是让x=x+c,在把c更新一下c=c+b，最后让b=b+a，这就完成一次循环了。
不过你给的程序不完整。