lbry算法的矿池

A. C语言 有两个单链表LA和LB，其元素均为非递减有序排列，编写一个算法。将他们合并成一个单链表LC

#include<stdio.h>
#include<stdlib.h>

typedefintElemtype;
typedefstructnode{
Elemtypedata;
structnode*next;
}NODE,*LinkList,*pNode;

LinkListGetNewList(){
pNodehead=(pNode)malloc(sizeof(NODE));
if(head==NULL)returnNULL;
head->data=0;
head->next=NULL;
returnhead;
}

LinkListmerge(LinkListLA,LinkListLB){
pNodea,b,c,head;
a=LA;
b=LB;
c=head=GetNewList();
head->data=LA->data+LB->data;
while(a->next&&b->next){
c->next=(pNode)malloc(sizeof(NODE));
if(c->next==NULL){
printf("内存分配失败！ ");
returnNULL;
}
if(a->next->data>=b->next->data){
c->next->data=a->next->data;
a=a->next;
}
else{
c->next->data=b->next->data;
b=b->next;
}
c=c->next;
}
while(a->next){
c->next=(pNode)malloc(sizeof(NODE));
if(c->next==NULL){
printf("内存分配失败！ ");
returnNULL;
}
c->next->data=a->next->data;
a=a->next;
c=c->next;
}
while(b->next){
c->next=(pNode)malloc(sizeof(NODE));
if(c->next==NULL){
printf("内存分配失败！ ");
returnNULL;
}
c->next->data=b->next->data;
b=b->next;
c=c->next;
}
c->next=NULL;
returnhead;
}

LinkListCreat(LinkListhead,inta[],intn){
inti;
pNodep=head;
head->data=n;
for(i=0;i<n;++i){
p->next=(pNode)malloc(sizeof(NODE));
if(p->next==NULL){
printf("内存分配失败！ ");
returnNULL;
}
p->next->data=a[i];
p=p->next;
}
p->next=NULL;
returnhead;
}

voidShow(LinkListhead){
pNodep=head->next;
while(p){
printf("%d",p->data);
p=p->next;
}
printf(" ");
}

intmain(){
Elemtypea[]={98,89,86,80,76,69,68,54,50,29};
intm=sizeof(a)/sizeof(a[0]);
Elemtypeb[]={96,85,74,69,68,67,65,60,58};
intn=sizeof(b)/sizeof(b[0]);
LinkListLA=GetNewList();
LA=Creat(LA,a,m);
LinkListLB=GetNewList();
LB=Creat(LB,b,n);
LinkListLC;
printf("LA:");
Show(LA);
printf("LB:");
Show(LB);
LC=merge(LA,LB);
printf("LC:");
Show(LC);
return0;
}

B. 有两个带头节点的循环单链表链表LA、LB，编写算法，将两个循环单链表合并成一个单链表，其头指针为LA

关于最后的头结点要不要释放
根据严蔚敏的《数据结构（C语言版）》37页，对DestroyList(LinkList
&L)的解释是：销毁线性链表L，L不再存在。

C. C++编写金块问题的分治算法

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int inf=(1<<30);
int n,val[11111]; //金块个数,每块金块的重量
void Bin(int l,int r,int &_max,int &_min,int &cnt_max,int &cnt_min)
{
if(l==r)
{
_max=_min=val[l];
cnt_max=cnt_min=l;
return ;
}
if(l+1==r)
{
if(val[l]>val[r])
{
_max=val[l],cnt_max=l;
_min=val[r],cnt_min=r;
}
else
{
_max=val[r],cnt_max=r;
_min=val[l],cnt_min=l;
}
return ;
}
int mid=(l+r)>>1;
int ha,la,hb,lb;
int cnt_ha,cnt_la,cnt_hb,cnt_lb;
Bin(l,mid,ha,la,cnt_ha,cnt_la);
Bin(mid+1,r,hb,lb,cnt_hb,cnt_lb);
if(ha>hb) _max=ha,cnt_max=cnt_ha;
else _max=hb,cnt_max=cnt_hb;
if(la<lb) _min=la,cnt_min=cnt_la;
else _min=lb,cnt_min=cnt_lb;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%d",&val[i]);
int _max,_min;
int cnt_max,cnt_min;
_max=-inf,_min=inf;
Bin(1,n,_max,_min,cnt_max,cnt_min);
cout<<cnt_max<<" "<<_max<<" "<<cnt_min<<" "<<_min<<endl;
return 0;
}

D. 利用两个线性表LA和LB分别表示两个集合A和B，现要求一个新的集合A=A并B。 算法是 void union(List &La,Lis

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef int status;
typedef int ElemType;
#define TRUE 1
#define ERROR 0
#define FALSE 0
#define OK 1
#define OVERFLOW -2
#define list_init_size 100
#define listincrement 10
typedef struct{
ElemType *elem;
int length;
int listsize;
}sqlist;
status equal(ElemType a,ElemType b)
{if(a==b)
return TRUE;
else
return FALSE;
}
int listlength(sqlist l)
{ return l.length;}
status listinsert(sqlist *l,int i,ElemType e)
{
ElemType *newbase,*q,*p;
if(i<1||i>(*l).length+1)
return ERROR;
if((*l).length>=(*l).listsize){
newbase=(ElemType*)realloc((*l).elem,((*l).listsize+listincrement)*sizeof(ElemType));
if(!newbase) exit(OVERFLOW);
(*l).elem=newbase;
(*l).listsize+=listincrement;
}
q=&((*l).elem[i-1]);
for(p=&((*l).elem[(*l).length-1]);p>=q;--p)
*(p+1)=*p;
*q=e;
++(*l).length;
return OK;
}
status initlist(sqlist *l){
(*l).elem=(ElemType*)malloc(list_init_size*sizeof(ElemType));
if(!(*l).elem)
exit(OVERFLOW);
(*l).length=0;
(*l).listsize=list_init_size;
return OK;
}
status getelem(sqlist l,int i,ElemType *e)
{ if(i<1||i>l.length)
exit(ERROR);
*e=*(l.elem+i-1);
return OK;
}
int LocateElem(sqlist L,ElemType e,status(*compare)(ElemType,ElemType))
{
ElemType *p;
int i=1;
p=L.elem;
while(i<=L.length&&!compare(*p++,e))
++i;
if(i<=L.length)
return i;
else
return 0;
}
void print(ElemType *c)
{
printf("%d ",*c);
}
status ListTraverse(sqlist l,void(*vi)(ElemType *))
{
ElemType *p;
int i;
p=l.elem;
for(i=1;i<=l.length;i++)
vi(p++);
printf("\n");
return OK;
}
void Union(sqlist *la,sqlist lb)
{
int la_len,lb_len;
int i;
ElemType e;
la_len=listlength(*la);
lb_len=listlength(lb);
for(i=1;i<=lb_len;i++)
{ getelem(lb,i,&e);
if(!LocateElem(*la,e,equal))
listinsert(la,++la_len,e);
}
}
void main()
{
sqlist la,lb;
int j,i;
i=initlist(&la);
if(i==1)
for(j=1;j<=6;j++)
i=listinsert(&la,j,j);
printf("la= ");
ListTraverse(la,print);
initlist(&lb);
for(j=1;j<=5;j++)
i=listinsert(&lb,j,2*j);
printf("lb= :");
ListTraverse(lb,print);
Union(&la,lb);
printf("la :");
ListTraverse(la,print);
}

E. 设计一个算法，将两个递增链表La、Lb合并成一个递增链表Lc。

//设计一个算法，将两个递增链表La、Lb合并成一个递增链表Lc;La,Lb,Lc均为带头结点的链表
#include<stdio.h>
typedef
int
datatype;
struct
PNode
{
datatype
data;
//定义链表中结点的数据域，DATATYPE为数据类型
struct
PNode
*next;
//定义链表中结点的指针域
};
typedef
struct
PNode
linklist;
linklist
*ListCreateNull()
//建立带头结点的空单链表，返回头结点的地址
{
linklist
*list;
list
=(linklist
*)malloc(sizeof(linklist));
//申请表头结点空间
if(list!=NULL)
list->next=NULL;
else
printf("Out
of
space!
\n");
return
list;
}
int
ListInsert(linklist
*L,datatype
x)
//在链表L的尾部插入X,返回1表示成功，0表示失败
{
linklist
*p,*q;
p=L;
while(p->next!=NULL)
p=p->next;
q=(linklist
*)malloc(sizeof(struct
PNode));
if(!q)return
0;
q->data=x;
p->next=q;
q->next=NULL;
return
1;
}
linklist
*fun(linklist
*La,linklist
*Lb,linklist
*Lc)
//将两个递增链表La、Lb合并成一个递增链表Lc
{
linklist
*p;
p=Lc;
while(La->next!=NULL&&Lb->next!=NULL)
{
if(La->next->data>Lb->next->data)
{
ListInsert(p,Lb->next->data);
Lb=Lb->next;
}
else
{
ListInsert(p,La->next->data);
La=La->next;
}
}
if(La->next==NULL)
{
while(Lb->next!=NULL)
{
ListInsert(p,Lb->next->data);
Lb=Lb->next;
}
}
if(Lb->next==NULL)
{
while(La->next!=NULL)
{
ListInsert(p,La->next->data);
La=La->next;
}
}
return
Lc;
}
main()
{
linklist
*La,*Lb,*Lc;
int
temp=1,i;
//初始化链表La
La=(linklist
*)ListCreateNull();
printf("请输入数据以零结束:\n");
for(i=0;i<3;i++)
{
scanf("%d",&temp);
ListInsert(La,temp);
}
//初始化链表Lb
temp=1;
Lb=(linklist
*)ListCreateNull();
printf("请输入数据以零结束:\n");
for(i=0;i<3;i++)
{
scanf("%d",&temp);
ListInsert(Lb,temp);
}
//初始化链表Lc
Lc=(linklist
*)malloc(sizeof(struct
PNode));
Lc->next=NULL;
Lc->data=NULL;
Lc=fun(La,Lb,Lc);
while(Lc->next!=NULL)
{
printf("%d
",Lc->next->data);
Lc=Lc->next;
}
printf("\n");
}

F. 请问如何在运行完的遗传算法中选出20个适应度较好的点然后运行另一算法的代码下面是遗传算法代码

我是通过比较出来的，因为每一组数组经过遗传之后优秀的解是同一个数字，我遗传的次数多。这样大部分数据是相同的，把相同的那个数组找出来就认为最优解。要不就求一个平均数！

G. 雷锋同志，我想要最短路径算法：点的最短路径种子下载，好东西大家分享

最短路径算法：点的最短路径种子下载地址：

H. 数据结构算法复杂度分析中答案中的lb是什么意思啊

程序所用时间关于数据规模的函数
比如：
给n个数排序需要n^2的时间
时间复杂度就是o（n^2）
通常有
o(2)
常数
与输入数据规模无关
o(n)
成正比
o(log2n)
平方与数据规模成正比
o(n^2)
与数据规模的平方成正比
o(n^3)
……三次方……
o(n!)
阶乘

I. 数据结构算法实现：利用两个线性表LA和LB分别表示两个集合A和B，现要求一个新的集合A=A并B。

我写的，你编译一下，改一改就行了。

void Union(LinkList *L1,LinkList *L2,LinkList *&L3)//交集
{
LinkList *p=L1->next,*q=L2->next,*s,*c;
L3=(LinkList *)malloc(sizeof(LinkList));
L3->next=NULL;
c=L3;
while(p!=NULL&&q!=NULL)
{ if(p->data<q->data)
{ s=(LinkList *)malloc(sizeof(LinkList));//复制结点
s->data=p->data;
c->next=s;c=s;
p=p->next;
}
else if(p->data>q->data)
{ s=(LinkList *)malloc(sizeof(LinkList));
s->data=q->data;
c->next=s;c=s;
q=q->next;
}
else
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=p->data;
c->next=s;c=s;
p=p->next;
q=q->next;
}
}

while(q!=NULL)
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=q->data;
c->next=s;c=s;
q=q->next;
}
c->next=NULL;

while(p!=NULL)
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=p->data;
c->next=s;c=s;
p=p->next;
}
c->next=NULL;

}