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;

}