lbry算法矿机

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

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

❷ 已知有两个带头的结点的循环单链表LA、LB,编写一个算法，将两个循环单链表合并为一个循环单链表

将两个循环单链表合并为一个循环单链表的算法如下
先找到两个链表的尾，并分别由指针p、q指向它们，然后将第一个链表的尾与第二个表的第一个结点链接起来，并修改第二个表的尾Q，使它的链域指向第一个表的头结点。
LinkList merge_1(LinkList LA,LinkList LB)
/*此算法将两个链表的首尾连接起来*/
{ Node *p, *q; p=LA; q=LB;
while (p->next!=LA) p=p->next; /*找到表LA的表尾*/
while (q->next!=LB) q=q->next; /*找到表LB的表尾*/
q->next=LA;/*修改表LB 的尾指针，使之指向表LA 的头结点*/
p->next=LB->next;/*修改表LA的尾指针，使之指向表LB 中的第一个结点*/
free(LB);
return(LA);
}

❸ 《数据结构》编写一个算法使之能实现将有序表Lb中的数据元素插入到有序表La中

//假设有序表为从小到大的整型链表
void Insert(List *&La, const List *Lb)
{
if (!La || !Lb)
return;
List *pa = NULL;
List *qb = Lb;
while(qb)
{
//插入为头结点
if(qb->data < La->data)
{
List *tmp = (List*)malloc(sizeof(List));
tmp = qb;
tmp->next = La;
qb = qb->next;
La = tmp;
pa = La;
continue;
}
else
{
pa = pa->next;
}
//
if(qb->data < pa->data && pa!= NULL)//La中
{
List *tmp = (List*)malloc(sizeof(List));
tmp = qb;
tmp->next = pa->next;
pa->next = tmp;
qb = qb->next;
}
else if(qb->data == pa->data && pa!= NULL)
{
qb = qb->next;
}
else if(qb->data > pa->data && pa->next == NULL)//La尾
{
List *tmp = (List*)malloc(sizeof(List));
tmp = qb;
qa->next = tmp;
tmp->next = NULL;
qb = qb->next;
}
else
{
pa = pa->next;
}
}
}
你测试下-。-~我没测试~

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

❺ 设计一个算法，将两个递增链表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");
}

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

以二为底的对数网络还是有的，直接搜 对数 lb n 计算机 这些关键才

❼ 设计算法，将一个带头节点的递增有序单链表LA拆分成2个带头节点的单链表LB和LC

先排序，把奇数的都放在左边，偶数的放在右边，记录中间位置，并把NEXT指针设为null，再把LC指向右边的链表。

❽ 利用两个线性表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);
}

❾ 想请教一下，为什么比特币的矿机有几十G,而莱特币的矿机只有1M2M这样呢

比特币的“挖矿”已经进入中后期，挖矿速度减慢，挖矿的人增多

莱特币现在不值钱，挖矿也刚刚开始

顺便说一句，现在比特币挖矿已经要自己设计芯片和配套芯片的算法

或者说直接设计配套比特币算法的芯片，组装“RISC并联计算阵列”才有可能赚到钱了

淘宝上卖的矿机一天只能挖几个聪，连电费都抵不了

所以不用想了，有胆子的话，进去买俩个玩一圈，要不就忘记这码事吧

❿ 数据结构算法实现：利用两个线性表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;

}